Communication série, 2013/2014, TD2

Introduction

Projet mené par Flavien Royer, Thibault Scholaert et Jean-Michel Tournier

L'objectif de ce projet est de réaliser une interface web permettant de piloter la communication entre la FoxBoard et la NanoBoard via le port série. Pour cela il est nécessaire de traiter le cas de l'émission de données et le cas de la réception de données et cela pour chacun de ces périphériques. Au final, on doit pouvoir envoyer un caractère depuis la FoxBoard, que la NanoBoard stock, affiche sur les led et renvoie à la FoxBoard après appui d'un bouton.

Partie Electronique

Séance n°1

Nous avons tout d’abord commencé par faire le tutoriel afin de nous familiariser avec le logiciel altium designer. Nous avons ensuite réfléchi à une solution pour l’émission mais nous nous sommes finalement tournés vers la réception,sous conseils des professeurs, qui était plus facile à réaliser. Nous avons tout d’abord pensé à un registre à décalage qui nous permettrait de convertir de parallèle vers série. Il fallait ensuite gerer les bits de start et de stop ainsi que le bouton de déclenchement. Puis nous avons commencé à réaliser ce montage que nous avons terminé à la 2e séance :

Emission

• un registre à décalage SR16 qui permet la conversion série/parallèle
• le bit de validation d’envoi correspond au bouton poussoir.
• un configurable Digital IO (DIO) qui nous sert à pouvoir rentrer le bus de données directement à partir du logiciel altium designer
• D15 à 1 correspond à l'etat initial
• D14 à 0 corespond au bit de start
• D6 à D13 correspond à la donnée
• Q15 la sortie du registre à décalage vers la broche RS_TX

Le seul problème que cet solution peut poser vient du fait que l'on ne filtre pas les appuis de bouton. En effet si l'on rappuie sur le bouton (ou que celui ci reste enfoncé), des erreurs de transmission peuvent alors apparaître. (Même si un 2nd appui avant la fin et peu probable, à 9600 bauds)

Séance n°2

Lors de la deuxième séance, nous avons donc fini la partie réception. Nous avons inséré un Digital IO (DIO) afin de pouvoir rentrer le bus de données directement à partir du logiciel altium designer. Puis nous avons inséré un bouton poussoir SW_USER0 dans le montage.

Nous avons ensuite implanté notre partie réception sur la nanoboard. On a donc utilisé le DIO et inséré le mot 0110 1001. Avec un bit de start à 0 et un bit de stop à 1,ainsi que des sorties sur les pin de la NanoBoard, nous avons pu vérifier le fonctionnement grâce à l'analyseur numérique :

Analyseur

On observe sur D3 le signal de la clock et sur D1 la réception.

Sur D3 :

On oberve la clock à une fréquence de 9600 Hz.

Sur D1 :

• Initialement à 1

• Bit de start à 0 au front montant de la clock

• Le mot de 8 bits : on observe 1001 0110 mais comme le poids faible est en tête, le mot est inversé, donc bien 0110 1001

• Le bit de stop à 1

• Finalement à 1 (le bit de stop n'est donc pas réellement visible car il est confondu avec l'initialisation qui est à 1)

Les résultats se sont donc avérés concluants et nous avons ensuite pu passer à la partie émission qui s’est avérée plus compliquée.

Séance n°3

Pour la partie émission, nous avions besoin de deux horloges :

• La première à une fréquence de 9600 Hz

• La seconde à une fréquence de 2x9600 Hz pour générer un demi-top et avoir une horloge décalée au milieu de chaque bit pour pouvoir les détecter correctement.

Nous avions ensuite besoin de :

• un multiplexeur qui servait à activer soit la clock à 9600 Hz soit celle à 2x9600 Hz
• un compteur qui servait à compter le nombre de tops d'horloge
• une bascule D qui servait à savoir quand activer la CE du compteur (elle est activée lorsque le compteur est <1 c'est à dire =0)
• un registre à décalage SR16 qui permettait la conversion série vers parallèle
• deux comparateurs :
  

  avec bascule D sync

• • L'un servait à comparer le compteur à 1 afin de savoir quand activer la bascule D (lorsque compteur < 1) ou activer la clock à 9600 Hz (lorsque compteur > 1)

• • L'autre servait à comparer le compteur à 10 afin de savoir quand activer le clear du compteur et de la bascule (lorsque le compteur > 10)

Nous avons tout d'abord testé notre montage en reliant directement l'émission à la réception et testé via des DIO.

Nous sommes arrivés à une solution qui fonctionnait de temps en temps voir pas du tout lors des tests. Nous avons donc du trouver l’erreur en plaçant des plusieurs endroits stratégiques afin d’observer l’évolution des différents circuits logiques. Nous avons ainsi trouvé d’où venait l’erreur(avec un peu d'aide), il s’agissait en fait de la bascule qui ne s’activait pas. Par la suite nous avons remarqué qu’elle était synchrone

avec bascule D async

et attendait donc un top d’horloge pour faire le clear, mais ce top d’horloge qui n’arrivait jamais. Lorsque nous l’avons remplacée par une bascule asynchrone, le clear fonctionnait correctement ainsi que tout le montage.

Nous avons rassemblé puis testé le tout (émission + réception) via la nanoboard et une liaison fournie à HyperTerminal par notre enseignant en essayant l’émission et la réception de caractères. Le test a confirmé que tout fonctionnait et a donc été validé par l’enseignant.

Ainsi, pour reprendre, lorsque un bit à 0 apparaît (start) alors la bascule D passe à 1, le comparateur sortant bien lower. Le compteur commence donc à compter de 0 à 1 à vitesse double puis de 1 à 10 à vitesse normale grâce au multiplexeur modifier par le comparateur. Le comparateur active aussi le registre à décalage, qui enregistre donc les 8 bits de donnés. Lorsque le compteur arrive à 10, le système est réinitialisé (clear du compteur et de la bascule) grâce au 2nd comparateur. Les donnés restent néanmoins présentes à la sortie du registre.

Schéma fonctionnel final

Partie Informatique

Pour la réalisation de la partie informatique nous avons travaillé avec un Arduino configuré de manière à renvoyer des caractères ASCII en cas de réception de caractère.

Par exemple en cas d'envoi du mot test la réponse obtenue était :

##### #### #### #####
  #   #    #      #
  #   #### ####   #
  #   #       #   #
  #   #### ####   #

Séance n°1

Lors de la première séance nous avons commencé par réaliser l'interface web de notre projet c'est à dire une page web contenant deux zones de texte. Une afin d'y mettre les caractères à envoyer et l'autre qui recevrait les caractère renvoyé par l'Arduino.

Une fois terminé avec l'interface nous avons commencé par la partie émission car elle était plus simple. Nous avons réalisé un PHP permettant l’écriture sur le port série à l'aide de l'exemple fourni. Nous nous sommes ensuite renseignés sur JQuery car nous devions nous en servir afin d'appeler notre PHP.

Séance n°2

La deuxième séance fut consacré à la réalisation de la partie réception ainsi qu'a l'implémentation de la partie émission dans l'interface web à l'aide de JQuery.

Cette partie fut un peu plus compliqué car il était nécessaire de gérer le cas ou aucun caractère n’était reçu sinon notre fonction de lecture aurai bouclé sans fin ce qui pose problème au niveau de la page web. Pour cela nous avons utilisé la fonction sleep afin de définir que la fonction devrait s’arrêter au bout de 5 secondes sans lire un caractère.

Suite à un conseil de notre enseignant nous avons par la suite amélioré cette fonction afin qu'elle ne fasse plus de pause si il y a eu réception d'un caractère de manière à rendre l'interface plus réactive.

Séance n°3

Lors de la séance n°3 nous avons fait l'exportation de nos fichiers sur la FoxBoard puis, après quelques tests afin de résoudre les problèmes, la communication avec la FoxBoard était fonctionnelle. Il nous reste juste un léger problème au niveau de la lecture qui provient probablement d'un caractère d'échappement dans notre code et qui fais que nous obtenons en réponse :

##### #### #### #####

  #   #    #      #

  #   #### ####   #

  #   #       #   #

  #   #### ####   #

Conclusion

Pour conclure, les deux parties de notre projet sont fonctionnelles en revanche faute de temps nous n'avons pas eu l'occasion de relier les deux pour finaliser le projet.