Communication série, 2013/2014, TD2 : Différence entre versions

De Wiki de Projets IMA
(→‎Séance n°2)
(→‎Séance n°2)
 
(52 révisions intermédiaires par 3 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 
= Introduction =
 
= 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 =
 
= Partie Electronique =
  
 
== Séance n°1 ==
 
== 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 qui était plus facile à réaliser.
+
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.  
+
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 :
 
Puis nous avons commencé à réaliser ce montage que nous avons terminé à la 2e séance :
−
[[Fichier:reception_projet.jpg]]
+
[[Fichier:reception_projet.jpg|thumb|600px|left|super|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
 +
 
 +
<br /><br /><br /><br /><br /><br /><br /><br />
 +
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 ==
 
== 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.
 
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 1001 0110. Avec un bit de start à 0 et un bit de stop à 1, nous avons pu observer grâce à l'analyseur numérique :
+
 
 +
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 :
  
  
−
[[Fichier:analyseurproj.jpg]]
+
[[Fichier:analyseurproj.jpg|thumb|500px|left|Analyseur]]
  
  
 
On observe sur D3 le signal de la clock et sur D1 la réception.  
 
On observe sur D3 le signal de la clock et sur D1 la réception.  
 +
  
 
Sur D3 :
 
Sur D3 :
 +
 
On oberve la clock à une fréquence de 9600 Hz.
 
On oberve la clock à une fréquence de 9600 Hz.
 +
  
 
Sur D1 :  
 
Sur D1 :  
−
<math>_</math> Initialement à 1
+
 
−
<math>_</math> Bit de start à 0 au front montant de la clock
+
*Initialement à 1
−
<math>_</math> Le mot de 8 bits : 1001 0110
+
 
−
<math>_</math> Le bit de stop à 1
+
*Bit de start à 0 au front montant de la clock
−
<math>_</math> Finalement à 1 (le bit de stop n'est donc pas réellement visible car il est confondu avec l'initialisation qui est à 1)
+
 
 +
*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)
 +
<br /><br /><br /><br /><br /><br /><br /><br /><br /><br />
  
 
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.
 
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.
Ligne 34 : Ligne 59 :
 
== Séance n°3 ==
 
== Séance n°3 ==
  
−
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, il s’agissait en fait de la bascule qui ne s’activait pas. Par la suite nous avons remarqué qu’elle était synchrone 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.  
+
Pour la partie émission, nous avions besoin de deux horloges :
−
Nous avons rassemblé puis testé le tout (émission + réception) via la nanoboard et une liaison fournie par notre enseignant en essayant l’émission et la réception de caractères. Le test nous a confirmé que ça fonctionnait et a donc été validé par l’enseignant.
+
 
 +
 
 +
*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 : [[Fichier:Ex.jpg|thumb|right|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[[Fichier:emissionbis.jpg|thumb|right|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.
 +
[[Fichier:4_tout_relie_final.png|thumb|center|500px|Schéma fonctionnel final]]
  
 
= Partie Informatique =
 
= 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 ==
 
== 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 ==
 
== Séance n°2 ==
 +
 +
La deuxième séance fut consacrée à 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ée car il était nécessaire de gérer le cas ou aucun caractère n’était reçu sinon notre fonction de lecture aurait bouclé sans fin ce qui pose problème au niveau de la page web. Pour cela, nous avons décidé de définir un temps maximum d’acquisition des caractères, afin de faire ceci, nous avons ajouté une boucle while qui va faire 50 itérations.
 +
 +
A chaque itération de cette boucle, le php va tenter de lire un caractère, si il y parviens il va alors initialiser une variable à 1 (la variable success) ce qui va permettre d’arrêter l’acquisition à la fin de cette boucle. Dans le cas contraire il va continuer à faire cette boucle jusqu'à avoir réalisé 50 itérations.
 +
 +
A l'aide de la fonction ''sleep'' nous avons ajouté une pause afin d'augmenter le temps de parcours de notre boucle, il y a une pause de 100ms à chaque itération ce qui fait un maximum de 5 secondes avant de stopper l'acquisition des caractères. De plus en cas d'acquisition réussie des caractères le php va se terminer immédiatement et écrire les caractères sur l'interface web.
 +
 +
Voici à quoi ressemble le fichier php permettant la réception de caractères.
 +
 +
<?php
 +
 +
define('SERIAL_DEVICE','/dev/ttyACM0');
 +
 +
 +
// Lecture d'un message sur le port serie
 +
 +
$f=fopen(SERIAL_DEVICE,'r');
 +
if($f===false) die('Je ne peux pas ouvrir le port série');
 +
stream_set_blocking($f,0);
 +
$time=0;
 +
$success=0;
 +
while($time != 50){
 +
  $byte=fread($f,1);
 +
 +
  if((strlen($byte)!=1) && ($success == 1))$time=50;
 +
 +
  else if((strlen($byte)!=1) && ($success == 0)){
 +
usleep(100000);
 +
$time++;
 +
}
 +
  else{
 +
echo $byte;
 +
$success=1;
 +
 +
  }
 +
}
 +
fclose($f);
 +
?>
  
 
== Séance n°3 ==
 
== 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 :
 +
 +
##### #### #### #####
 +
 +
  #  #    #      #
 +
 +
  #  #### ####  #
 +
 +
  #  #      #  #
 +
 +
  #  #### ####  #
 +
 +
Pour réaliser les tests, il faut ouvrir le fichier ''saisi.html'' afin d'ouvrir l'interface web puis insérer le texte à envoyer dans le cadre du haut, pour finir il ne reste plus qu'à cliquer sur Envoyer afin de valider l'envoi du texte.
  
 
= Conclusion =
 
= 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.

Version actuelle datée du 7 mai 2014 à 18:11

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ée à 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ée car il était nécessaire de gérer le cas ou aucun caractère n’était reçu sinon notre fonction de lecture aurait bouclé sans fin ce qui pose problème au niveau de la page web. Pour cela, nous avons décidé de définir un temps maximum d’acquisition des caractères, afin de faire ceci, nous avons ajouté une boucle while qui va faire 50 itérations.

A chaque itération de cette boucle, le php va tenter de lire un caractère, si il y parviens il va alors initialiser une variable à 1 (la variable success) ce qui va permettre d’arrêter l’acquisition à la fin de cette boucle. Dans le cas contraire il va continuer à faire cette boucle jusqu'à avoir réalisé 50 itérations.

A l'aide de la fonction sleep nous avons ajouté une pause afin d'augmenter le temps de parcours de notre boucle, il y a une pause de 100ms à chaque itération ce qui fait un maximum de 5 secondes avant de stopper l'acquisition des caractères. De plus en cas d'acquisition réussie des caractères le php va se terminer immédiatement et écrire les caractères sur l'interface web.

Voici à quoi ressemble le fichier php permettant la réception de caractères. 

<?php

define('SERIAL_DEVICE','/dev/ttyACM0');


// Lecture d'un message sur le port serie

$f=fopen(SERIAL_DEVICE,'r');
if($f===false) die('Je ne peux pas ouvrir le port série');
stream_set_blocking($f,0);
$time=0;
$success=0;
while($time != 50){
  $byte=fread($f,1);

  if((strlen($byte)!=1) && ($success == 1))$time=50;

  else if((strlen($byte)!=1) && ($success == 0)){
	 usleep(100000);
	 $time++;
	}
  else{
	 echo $byte;
	 $success=1;
	 
  }
}
fclose($f);
?>

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 : 

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

  #   #    #      #

  #   #### ####   #

  #   #       #   #

  #   #### ####   #

Pour réaliser les tests, il faut ouvrir le fichier saisi.html afin d'ouvrir l'interface web puis insérer le texte à envoyer dans le cadre du haut, pour finir il ne reste plus qu'à cliquer sur Envoyer afin de valider l'envoi du texte.

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.

Récupérée de « https://projets-ima.plil.fr/mediawiki/index.php?title=Communication_série,_2013/2014,_TD2&oldid=13098 »