WIKI de Bertrand VANDEPORTAELE

cours bus de com cours_bus_terrain_livret_portrait.pdf

• Prise en main de l'environnement Arduino
• Prise en main du système d'exploitation Linux (Debian)
• Syntaxe Arduino
• Utilisation de la maquette Arduino
• Utilisation haut niveau d'une communication série asynchrone
• Compréhension de la structure d'une trame série asynchrone
• Utilisation de FIFO

Arduino est une plateforme de développement open-source qui se compose d'une carte microcontrôleur et d'un environnement de développement associé. La carte Arduino UNO se compose de :

• un microcontrôleur 8-bit Atmega328p cadencé à 16Mhz (exécutant une instruction par cycle d'horloge) https://www.google.fr/url?q=https://docs.google.com/viewer%3Fa%3Dv%26pid%3Dsites%26srcid%3DZGVwaW5mb25hbmN5Lm5ldHxtaW5lc3xneDo0NjFmYzI1NTdkZDU2YmE2&sa=U&ved=0ahUKEwjolNmb5MTKAhXECBoKHVDtCD4QFggWMAA&usg=AFQjCNGxQ8y7E0qcjTBHVI0f65so7he5jg
• un convertisseur USB/UART TTL
• une régulation de tension 5v
• un connecteur au pas de 2.54mm au standard Arduino

Le schéma de cette carte est visible sur: http://arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf

Pour plus d'informations, vous reporter à http://arduino.cc/

Il existe des cartes compatibles arduino que vous pouvez acheter pour 4 euros par exemple sur: http://www.ebay.com/itm/NEW-UNO-R3-ATmega328P-CH340-Mini-USB-Board-Compatible-Arduino-/311155383820?pt=LH_DefaultDomain_0&hash=item48724e5e0c

Il existe aussi des kits tels que: https://www.dx.com/fr/p/funduino-uno-r3-lcd-1602-keypad-shield-v2-0-lcd1602-expansion-board-building-blocks-deep-blue-315276?tc=EUR&gclid=CJ_Hvd645b4CFaXHtAod-1MA4A#.VMRAaTVrpwH

Il est également possible d'utiliser un outils en ligne pour développer sur arduino sans rien installer sur votre machine: https://codebender.cc/

fichiers eagle: http://homepages.laas.fr/bvandepo/files/iut/td1_capt/carte-arduino-max3232-B-15.sch et http://homepages.laas.fr/bvandepo/files/iut/td1_capt/carte-arduino-max3232-B-15.brd

La carte d'extension utilisé pour ce TD, connecte le port série matériel ainsi qu'un ensemble d'entrées/sorties à deux connecteurs DB-9 mâle et femelle afin que la carte puisse prendre au choix, le rôle de DCE ou DTE. Cette carte propose des cavaliers de configurations permettant d'utiliser le port série en mode intégré “UART HARD” (Jumper RX et TX à droite) ou en mode émulé “UART SOFT” (Jumper RX et TX à gauche). La carte intègre un composant PHY (LIRE LA DOC http://www.farnell.com/datasheets/70989.pdf , surtout la page 5) qui se charge de générer les tensions nécessaires au respect de la norme RS-232 (de l'ordre de +5.5v à -5.5v) à partir de la tension d'alimentation de la carte (5v dans ce cas).

Le composant PHY contient deux convertisseurs de TTL vers RS232 et deux convertisseurs de RS232 vers TTL: - Le niveau logique 1 (5V en niveau TTL) est représenté par une tension négative (entre -3V et -25V) coté RS232. - Le niveau logique 0 (0V en niveau TTL) est représenté par une tension positive (entre +3V et +25V) coté RS232.

Deux convertisseurs sont utilisés pour les signaux de données RX et TX et les deux autres sont utilisés pour les signaux de contrôle de FLUX RTS/CTS.

Les indicateurs RTS et CTS sont câblés sur des ports d'entrées/sorties de la carte et sont également reliés à des LED.

Lors de la programmation de la carte Arduino depuis l'IDE, il est nécessaire de configurer le cavalier RX en mode UART émulé ou bien de l'ouvrir (peut être changé après programmation).

Les 2 figures suivantes montre le cablage d'un connecteur DE9 coté DTE (le PC):

Dans le TP nous connecterons la carte arduino au PC via un cable droit. Le cablage se fera entre le DTE (PC) et l'arduino coté DCE tel qu'indiqué sur ce schéma:

Les schémas de cablage suivants sont indiqués pour référence: Le premier correspond à un cable croisé permettant de connecter deux DCE en connectique DE9:

Les deux schémas suivants illustrent la connectique DE25:

Les deux schémas suivants illustrent des cables pour relier des connectiques DE9 et DE25:

Les cartes Arduino distribués en TP sont numérotés, ils vous appartient donc d'en prendre soin tout au long du module de communication.

La carte Arduino se branche au PC via un des ports USB disponibles en façade. Le connecteur côté Arduino est de type USB-A mâle et le connecteur côté PC est de type USB-B femelle. Avant de passer à la suite, connectez la carte au PC à l'aide du câble fourni.

Pour chaque TP, la carte sera dotée d'un shield d'extension pour faciliter l’accès au périphérique étudié.

La carte Arduino n'étant pas protégée, il est préférable de vérifier que la table de TP est libre de tout objet métallique afin d'éviter les court-circuits !

Le système d'exploitation utilisé lors des TP de bus de communication est Debian (basé Linux). Sous Linux le lancement des utilitaires peut se faire de deux manières:

• Utilisation d'un raccourci sur le bureau
• Lancement au travers de la ligne de commande

Pour lancer l'application Arduino au travers de la ligne de commande, suivez la suite d'instructions suivante :

1. Taper ALT+F2 puis saisir lxterm et touche entrée
2. Dans le terminal, taper le nom de l'application (arduino) suffixé par &

1. Attendre le chargement de l'application, une fois l'application chargée, vous devriez avoir la vue suivante

Dans l'onglet “Outils”, accédez au menu “Port Série” et cliquez sur la valeur /dev/ttyACM0. Accédez aussi eu menu “Carte” et vérifiez que la valeur sélectionnée est “Arduino Uno”.

Maintenant que l'editeur est lancé, nous pouvons entrer dans la fenêtre le programme suivant

blink.ino

 
int led = A2;
 
// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}
 
// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Copier coller le contenu dans votre fichier et cliquez sur le bouton “Vérifier” pour le compiler.

Les erreurs de compilation apparaissent en rouge (et en anglais) dans la fenêtre de compilation en bas de l'IDE.

Une fois que la compilation ne génère plus d'erreurs, chargez le fichier sur la carte Arduino (préalablement connectée sur le port USB) en cliquant sur le bouton “Téléverser”

A partir de ce point, si votre code est correct, la led RTS de la carte d'extension doit clignoter.

• Pensez à sauvegarder votre code fréquement à l'aide la combinaisn ctrl+s
• La carte Arduino étant “nue”, faîtes attention à ne pas provoquer de court-circuit en manipulant des objets métalliques
• Le carte étant posé sur la table et le cable étant branché sous la table, faites attention à ne pas accidentellement tirer sur le câble.

Une description de la librairie Serial a été fournie en TD. Vous pouvez également accéder au descriptif de cette librairie en sélectionnant le menu “Aide” puis le menu “Référence”.

Mettre les cavaliers en mode RX SOFT et TX SOFT pour que le shield n'intervienne pas sur l'UART HARD que vous allez programmer. Vous accéderez à l'UART HARD uniquement à travers du convertisseur USB/Série.

L'application à programmer doit implémenter le comportement suivant :

1. Configurer l'UART pour une communication 8N1 à 9600Bauds (Serial.begin)
2. Attendre que un caractère soit disponible sur le périphérique UART (Serial.available)
3. Lire le caractère (Serial.read)
4. Si le caractère est une minuscule, le convertir en majuscule (?)
5. Envoyer le caractère sur la liaison série (Serial.write)

Pour des formats de trames autres que 8N1, vous trouverez les valeurs de paramètres adaptés à la méthode Serial.begin à l'adresse: http://arduino.cc/en/Serial/Begin

A partir de la description de l'application, écrire le code correspondant dans un nouveau fichier (Fichier → Nouveau). Vous devez implémenter les fonction setup et loop (vous inspirer du programme précédent).

L'IDE arduino dispose d'une console série permettant de visualiser les caractères envoyés par l'Arduino sur son port périphérique matériel. Pour accéder à la console série, il suffit de cliquer sur la loupe en haut à droite de l'éditeur de code.

Une console série apparaîtra alors sous la forme suivante.

Il suffit alors de configurer le baudrate de la communication à l'aide la liste déroulante en bas à gauche.

Pour envoyer des caractères à l'application, il suffit de les rentrer dans la zone de texte en haut de de la fenêtre, puis de cliquer sur “Envoyer”.

Les caractères émis par l'UART HARD du Arduino doivent ensuite s'afficher dans la partie basse de la fenêtre.

La librairie Serial fournie dans l'environnement Arduino utilise le périphérique UART intégré de l'Atmega328p. Il est aussi possible de programmer le microcontrôleur pour mimer le comportement d'une liaison asynchrone 1200 bauds, 8N1 en utilisant les entrées/sorties du microcontrôleur.

Dans cette exercice nous allons utiliser la sortie 6 de l'Arduino pour envoyer un caractère en respectant le format d'une trame série à 1200 bauds, 8N1. (start, 8-bit de données en commençant par le bit de poids faible, stop). Pour mimer cette communication, il est nécessaire de respecter les aspects temporels de celle-ci. Pour gérer l'aspect temporel nous utiliserons la fonction delayMicroseconds(delay), et l’interaction avec le port d'entrée sortie se fera avec la fonction digitalWrite(PIN, VAL). Vous devrez configurer la broche TX en sortie et l'initialiser à la bonne valeur.

Pour la construction de la trame série, vous pouvez vous reporter au premier TD. Dans un premier temps vous devez formaliser la construction de cette trame en complétant la description suivante (on partira du principe que la ligne TX a été initialisée à 1). On considère ici une trame au format 8N1.

Vous veillerez à définir 2 variables:

1. int TXPIN pour le numéro de la broche utilisée.
2. int DUREEBIT pour la durée du bit en microsecondes.

La séquence à réaliser est la suivante:

1. Mettre la ligne TX à 0 (bit de start) en utilisant la fonction digitalWrite
2. Attendre T µs (T étant le durée d'un bit) en utilisant la fonction delayMicroseconds
3. Pour chaque bit (i ème bit) de l'octet à envoyer, en partant du bit de poids faible, faire
   1. Isoler le bit à la position i de l'octet (pensez à utiliser les masquages et décalages)
   2. Ecrire sur la sortie TX la valeur du bit, en utilisant la fonction digitalWrite
   3. Attendre T µs, en utilisant la fonction delayMicroseconds
4. Mettre la ligne TX à 1 (bit de stop), en utilisant la fonction digitalWrite
5. Attendre T µs (T étant la durée d'un bit), en utilisant la fonction delayMicroseconds

A partir de la description, codez la fonction void EnvoieCar(char c), c étant l'octet à envoyer. Une fois la fonction codée, faire un programme principal (fonction loop) qui envoie en boucle le caractère 0x55 ('U'), suivi d'un délai de 100ms. Une fois le code compilé et chargé sur la carte, connectez le câble série (disponible sur la table) au port DTE de la carte d'extension. Lisez la notice d'utilisation de minicom pour tester. Relever les signaux à l'oscilloscope pour le signal TX de chaque coté du composant PHY MAX3232. Modifier la valeur de DUREEBIT pour obtenir un débit de 9600 secondes. Configurer minicom pour ce débit et observer que cela ne fonctionne pas. En analysant la trame à l'aide de l'oscilloscope, proposer une solution et la tester.

Ensuite, vous pouvez modifier la fonction loop pour envoyer les chiffres de 0 à 9 (codes ascii de cette séquence) sur cet UART. L'envoi de chaque chiffre devra être suivi d'un délai de 100ms.

Le logiciel minicom permet de gérer la communication en mode texte sur une liaison série.

Lancer minicom sur le port série 3 à 1200 Bauds au format 8N1 en tapant dans une console:

minicom -D /dev/ttyS0 -b 1200

Si les caractères émis par la carte arduino ne s'affichent pas dans minicom, tenter de brancher l'autre cable série présent sur la table à la carte arduino.

Pour quitter minicom, presser successivement et rapidement les touches ESC et Z, puis presser q et valider par entrée.

affichage des caractères reçus

Le comportement que nous venons de décrire est en fait déjà codé (de manière plus optimisée) dans la librairie Arduino. Cette Librairie permet de créer un port série émulé en utilisant les entrées/sorties numériques 6 et 5 de la carte.

softSerial.ino

#include <SoftwareSerial.h>
 
SoftwareSerial mySerial(5, 6); //Création d'un port Série émulé nommé mySerial avec RX=pin 5, TX=pin 6
 
void setup()  
{
  mySerial.begin(4800); // configuration du baudrate à 4800 bauds
  mySerial.println("Hello, world?"); // Envoi de la chaîne terminée par un saut de ligne
}
 
void loop()
{
  char a ;
  if (mySerial.available()){
     a = mySerial.read();
     mySerial.write(a+1);
  }
}

Exécutez ce programme et expliquer son fonctionnement. Pour tester ce programme, vous devez avoir le câble série connecté au port DTE du shield d'extension et utiliser le terminal minicom (voir exercice précédent)

Dans cet exercice, nous allons utiliser les fifos décrites en cours et programmées en TD pour gérer une communication avec deux hotes pour lesquels le rythme de communication est différent (tant au niveau du baudrate que de la fréquence des échanges).

Cet exercice implique :

• Le PC connecté à l'Arduino au travers de la liaison USB/Série, 115200 bauds, 8N1. Cette communication utilise la liaison série intégrée.
• Le PC connecté connecté à l'arduino au travers du shield (côté DCE), 1200 bauds 8N1. Cette communication utilise la liaison série émulée SoftSerial (pensez à configurer les cavaliers du shield en position SOFT).

Dans cet exercice, le PC envoie un caractère sur la laison USB/Série (connectée à l'UART HARD), et le programme doit envoyer la phrase “Le caractère envoyé est X” sur la liaison UART SOFT comme le montre le schéma suivant:

L'intégralité du code doit fonctionner avec des fonctions d'envoi non-bloquantes,

La fonction setup doit implémenter le comportement suivant :

1. Configuration de l'UART matériel
2. Configuration de l'UART logiciel
3. Initialisation de la fifo
4. Configuration de l'entrée/sortie A3 en sortie (que l'on visualise sur la led RTS du shield MAX232)

La boucle principale doit implémenter le fonctionnement suivant :

1. Vérifier si un caractère est disponible sur l'UART matériel
   1. Réception d'un caractère sur l'UART matériel
   2. Écrire dans la fifo la phrase demandée (écriture caractère par caractère), à coder dans la fonction RemplirFifo
      1. Si l'écriture a échouée (débordement de Fifo), allumer la LED RTS
2. Lire un caractère depuis la fifo, et si la lecture à réussie (fifo non vide):
   1. Écrire le caractère sur l'UART émulé

ATTENTION: veillez à bien configurer la console Arduino en 115200 Bauds et option: Pas de fin de ligne

testFifo.ino

char  inByte = 0;         // incoming serial byte
 
const int rtsPin = 16;
const int ctsPin = 17;
 
#include <SoftwareSerial.h>
 
char ChaineEmission[]="Le caractere envoye est ";
 
#define FIFOSIZE 32
char FifoBuffer[FIFOSIZE];
////////////////////////////////////////////
 
struct charFifo{
  char * data ;
  unsigned int fifo_size ;
  unsigned int write_index ;
  unsigned int read_index ;
  unsigned int nb_available ; 
};
 
struct charFifo myFifo;    // la variable FIFO à utiliser
////////////////////////////////////////////
void char_fifo_init(struct charFifo * pf, char * buf, unsigned int f_size){
   pf -> data = buf ;
   pf -> fifo_size = f_size ;
   pf -> write_index = 0 ;
   pf -> read_index = 0 ;
   pf -> nb_available = 0 ;
 }
//////////////////////////////////////////// 
 char write_char_fifo(struct charFifo * pf, const char token){
  if(pf->nb_available >= pf->fifo_size) return 0 ;
  pf->data[pf->write_index] = token ;
  pf->write_index = pf->write_index + 1;
  if(pf->write_index >= pf->fifo_size) pf->write_index = 0 ;
  pf->nb_available = pf->nb_available + 1 ;
  return 1 ;
}
//////////////////////////////////////////// 
 char read_char_fifo(struct charFifo * pf, char * ptr_token){
  if(pf->nb_available == 0) return 0;
  *ptr_token = pf->data[pf->read_index]  ;
  pf->read_index = pf->read_index + 1;
  if(pf->read_index >= pf->fifo_size) pf->read_index = 0 ;
  pf->nb_available = pf->nb_available -1 ;
  return 1 ;
 
}
//////////////////////////////////////////// 
 char peek_char_fifo(struct charFifo * pf, char * ptr_token){
  if(pf->nb_available == 0) return 0 ;
  *ptr_token = pf->data[pf->read_index]  ;
  return 1 ;
}
////////////////////////////////////////////
 
 
 
SoftwareSerial mySerial(5, 6); // uart soft avec les broches RX,TX
// http://arduino.cc/en/Reference/softwareSerial
 
//////////////////////////////////////////// 
void setup()
{
  pinMode(rtsPin, OUTPUT);      
  pinMode(ctsPin, INPUT);     
  Serial.begin(115200);  // start serial port at 115200 bps:
  Serial.print("Bonjour");       
  mySerial.begin(1200);  // set the data rate for the SoftwareSerial port
  mySerial.println("Hello, world?");
  char_fifo_init(&myFifo,FifoBuffer, FIFOSIZE);   //initialisation de la FIFO
  digitalWrite(rtsPin, 1);      //éteind la led RTS
}
//////////////////////////////////////////// 
 void RemplirFifo(char c)
 {
  //écrire tous les caractères de la chaine ChaineEmission + le caractère c et mettre RTS à 0 si débordement de la FIFO
  //à implémenter
 }
//////////////////////////////////////////// 
void loop()
{
   int i; 
 
 //réception du nouveau caractère
   if (Serial.available() != 0)
     {
    //à compléter
     }  
   //vidage de la FIFO
   if(read_char_fifo(&myFifo,&inByte)==1)
     {
    //à compléter
     }
 
}

• Lire le code de la fonction peek_char_fifo(…) et expliquer son fonctionnement

• Compléter les fonctions void loop() et void RemplirFifo(char c)

A l'aide de la datasheet de l'Atmega328P (UART à partir de la page 176, https://www.google.fr/url?q=https://docs.google.com/viewer%3Fa%3Dv%26pid%3Dsites%26srcid%3DZGVwaW5mb25hbmN5Lm5ldHxtaW5lc3xneDo0NjFmYzI1NTdkZDU2YmE2&sa=U&ved=0ahUKEwjolNmb5MTKAhXECBoKHVDtCD4QFggWMAA&usg=AFQjCNGxQ8y7E0qcjTBHVI0f65so7he5jg ),

Etablir la configuration des registres suivants pour une communication 9600 bauds, 8N1:

• UBRR0H
• UBRR0L
• UCSR0C
• UCSR0A
• UCSR0B

L'arduino comporte plusieurs USART matériels, le module 0 est utilisé comme UART. Comme la documentation est générique et s'applique aux différents modules, il faudra remplacer n par le chiffre 0 pour l'UART matériel utilisé.

Définir ensuite:

• Une fonction bloquante d'envoi d'un caractère sur le port série: void USART_Transmit(unsigned char data )
• Une fonction bloquante de réception caractère sur le port série: unsigned char USART_Receive(void )

Dans la fonction loop, faire en sorte de renvoyer chaque caractère reçu sur l'UART en ajoutant 1 à son code ASCII

Cet exercice consiste à appréhender le contrôle de flux matériel RTS/CTS. En plus du cours, vous pouvez consulter la page suivante: http://en.wikipedia.org/wiki/RS-232#RTS.2FCTS_handshaking

Nous allons piloter le RTS du PC comme une requête d'autorisation d'envoi au arduino

1. Le PC active son RTS pour faire une demande d'autorisation d'envoi
2. L'arduino reçoit sur son CTS la requête du PC
3. L'arduino active (s'il est prêt, par exemple parce qu'il y a la place dans sa FIFO de réception) son RTS pour indiquer qu'il est prêt à recevoir les données du PC
4. Le PC reçoit l'autorisation d'envoi sur son CTS et peut alors transférer la donnée

Pour piloter finement le port série du PC, nous utiliserons une console texte appelée miniterm.py. Pour lancer miniterm.py avec le bon numéro de port série, par exemple pour le port série 1, saisir dans une console:

miniterm.py --port /dev/ttyS0

Pour configurer miniterm, il faut tout d'abord utiliser un caractère dit “d'échappement”, qui ne sera pas traité comme tous les autres caractères. Ce caractère spécial est saisi à l'aide de la combinaison CTRL+t. Il suffit ensuite de taper une ou plusieurs autres touches pour les différentes fonctions. Pour obtenir la liste des touches, il faut faire: CTRL+t puis CTRL+h qui conduit à l'affichage suivant:

1. – pySerial (2.5) - miniterm - help
2. –
3. – Ctrl+] Exit program
4. – Ctrl+T Menu escape key, followed by:
5. – Menu keys:
6. – Ctrl+T Send the menu character itself to remote
7. – Ctrl+] Send the exit character itself to remote
8. – Ctrl+I Show info
9. – Ctrl+U Upload file (prompt will be shown)
10. – Toggles:
11. – Ctrl+R RTS Ctrl+E local echo
12. – Ctrl+D DTR Ctrl+B BREAK
13. – Ctrl+L line feed Ctrl+A Cycle repr mode
14. –
15. – Port settings (Ctrl+T followed by the following):
16. – p change port
17. – 7 8 set data bits
18. – n e o s m change parity (None, Even, Odd, Space, Mark)
19. – 1 2 3 set stop bits (1, 2, 1.5)
20. – b change baud rate
21. – x X disable/enable software flow control
22. – r R disable/enable hardware flow control

Pour activer ou désactiver la sortie RTS du PC, tapez CTRL+t puis CTRL+r

Pour activer le mécanisme de contrôle de flux matériel (RTS/CTS), tapez CTRL+t puis SHIFT+r puis vérifier que l'affichage suivant est bien réalisé: — hardware flow control: active

La led CTS sur l'arduino doit s'allumer lorsque la sortie RTS du pc est activé.

Écrire un programme sur l'arduino qui

1. configure la broche RTS en sortie
2. configure la broche CTS en entree

puis en boucle

1. met RTS à 0
2. attend 1 seconde
3. met RTS à 1
4. attend 1 seconde

Compiler et Téléverser ce programme sur l'arduino. La led RTS doit clignoter à la fréquence d'1/2 Hz.

Dans la console miniterm, activer le contrôle de flux matériel puis presser en continu une touche dans la console. Vérifier que la led RX de l'arduino ne clignote que quand la led RTS est active.

Presser une seule touche dans la console miniterm lorsque la led RTS de l'arduino est éteinte, vérifier que la led RX de l'arduino s'allume plus tard lorsque la led RTS de l'arduino s'allume. Quelles conclusions en tirer? Appeler un enseignant pour valider.

Afin d'illustrer l'intérêt du contrôle de flux et de la FIFO, exécuter ce programme de test TP14COM:

TP14COM.ino

const int rtsPin = 16;
const int ctsPin = 17;
 
#include <SoftwareSerial.h>
 
SoftwareSerial mySerial(5, 6); // uart soft avec les broches RX,TX
// http://arduino.cc/en/Reference/softwareSerial
 
//////////////////////////////////////////// 
void setup()
{
  pinMode(rtsPin, OUTPUT);      
  pinMode(ctsPin, INPUT);     
  mySerial.begin(1200);  // set the data rate for the SoftwareSerial port
  mySerial.println("Hello\r\n");
  digitalWrite(rtsPin, 0);//autorise envoi depuis le PC
}
//////////////////////////////////////////// 
void loop()
{
   int i,j; 
   if (mySerial.available()!=0) //si il y a au moins un caractère à recevoir
     {
     i=mySerial.read();       // lit le caractère reçu
     digitalWrite(rtsPin, 1); // interdit l'envoi depuis le pc le temps que l'on traite le caractère reçu
     delay(1000);             // attend une seconde, pour simuler un traitement long
     while (mySerial.available()!=0)  j=mySerial.read();   //vidage de la fifo de réception de l'uart soft, pour simuler l'absence de fifo
     mySerial.print("J'ai eu besoin d'une seconde pour traiter le caractère ");  
     mySerial.write(i);
     mySerial.println("\r\n");  
     digitalWrite(rtsPin, 0); //re autorise l'envoi depuis le pc
     }
}
 

Dans la console miniterm, saisir rapidement les touches “azertyuiop”, et observer le traitement correct de chacun des caractères émis par le PC.

Commenter la ligne suivante: digitalWrite(rtsPin, 1);

Dans la console miniterm, saisir rapidement les touches “azertyuiop”, et observer le changement.

La librairie de gestion de l'uart implémente en réalité une FIFO de 64 caractères en réception. Afin de la “désactiver”, on peut la vider de tout son contenu. Pour cela, commenter la ligne suivante: while (mySerial.available()!=0) j=mySerial.read();

Dans la console miniterm, saisir rapidement les touches “azertyuiop”, et observer le changement.

Quelles conclusions en tirer? Appeler un enseignant pour valider.