architecture et programmation des

systèmes embarqués

Chapitre 5

USART
Dr. ATTIA Brahim, brahim.attia@yahoo.fr
Maître assistant: Electronique & microélectronique 1
 USART (Universal Serial Asynchronous Receiver Transmitter)

 USART est un protocole de communication série utilisé pour transmettre / recevoir des
données en série à un débit en bauds spécifique.

 Plusieurs appareils tels que GPS, GSM, RFID, capteurs, etc. doivent communiquer avec le
microcontrôleur pour transmettre ou recevoir des informations.

 Pour communiquer avec le microcontrôleur, plusieurs protocoles de communication sont

utilisés tels que RS232, SPI, I2C, CAN ,LIN, USB etc.

 Avec l'aide d'USART, nous pouvons envoyer / recevoir des données vers un ordinateur ou
d'autres appareils.

 USART est également utilisé pour interfacer le microcontrôleur avec divers modules comme
Wi-Fi (ESP8266), Bluetooth, GPS, GSM, etc.

2
3
4
 Communication s´erie USART
 USART est l’abrévation pour Universal Synchronous and Asynchronous serial Receiver and
Transmitter, c’est un système de communication point-à-point très flexible.

 Les données sont transmises par trames de 7 `a 13 bits.

 La trame a le format suivant :

 Les éléments entre crochets sont facultatifs, leur présence est définie par le développeur.

 Le bit de parité permet de vérifier rapidement s’il y a eu une erreur de transmission mais n’est
pas fiable à 100%.

5
 Communication série USART
L’USART se décompose en trois parties :
L’émetteur :
 Il se charge d’émettre sur la patte TXDn, à la fréquence configurée, la trame selon la
valeur stockée dans le registre UDR;
 il s’occupe donc automatiquement de la génération des bits Start, Stop et éventuellement
Parity.
 Des interruptions peuvent être déclenchées lorsque la transmission est terminée.

Le récepteur :
 dès détection sur la patte RXDn d’un bit Start valide (c’est-à-dire à 0), chaque bit de la
trame est alors échantillonné selon la fréquence configurée ou selon l’horloge sur XCK,
et stocké dans un registre temporaire jusqu’à réception de la trame complète.

 Ensuite, la valeur reçue est déplacée dans le registre UDR accessible par le programme.

 Une interruption peut être déclenchée lors de la fin de réception pour prévenir qu’une
trame est arrivée.

 Si le programme n’a pas lu une trame lorsqu’une deuxième trame arrive, la première
trame est perdue.
 Si la transmission s’est mal déroulée, par exemple si la trame est non conforme, si le bit
de parité n’est pas correct ou si des données reçues n’ont pas été lues, divers drapeaux
6
passent à 1 et les données erronées sont effacées.
 Communication série USART
Le générateur d’horloge :
 lors d’une utilisation en mode synchrone, un générateur est déclaré maître et l’autre
esclave.

 Le maître génère le signal d’horloge selon le débit souhaité et l’envoit sur la patte XCK
du microcontrôleur.

 L’horloge esclave reçoit ce signal d’horloge sur sa patte XCK et l’utilise pour
échantilloner les trames ou les émettre au bon rythme.

 En mode asynchrone, l’USART en réception se charge de synchroniser son horloge sur la

trame arrivante.

 La configuration doit être faite avant toute tentative d’envoi de données et ne devra pas être
changée tant que des données restent à émettre/recevoir.

 Il faut bien veiller à ce que la configuration soit toujours identique sur les deux
microcontrôleurs pour le format de la trame, le débit et qu’en mode synchrone les deux pattes
SCK soient reliées et qu’un USART soit en maître et l’autre en esclave.

7
8
9
 Initialiser, Configurer, Rompre

Serial.begin (Baudrate); //Initialiser l'interface avec la vitesse de transmission

Serial.begin (Baudrate, Config); // et configuration (par défaut: Serial_8N1)

Serial.setTimeout (Timeout_in_ms); // Timeout pour les fonctions de réception

int Count = Serial.available (); // Nombre d'octets dans le tampon de réception

int Count = Serial.availableForWrite (); // Nombre d'espaces libres dans le tampon d'envoi

Serial.end (); // Fin de la communication série

10
 Serial.begin (Baudrate); Serial.begin (Baudrate, Config);
Serial.begin (Baudrate); //Initialiser l'interface avec la vitesse de transmission

Serial.begin(Baudrate, config); //Initialiser l'interface avec la vitesse de transmission et

configuration (par défaut: Serial_8N1)
Baudrate:300,
Pas de bit de parité Parité paire (even) Parité impaire (odd) 600,
N 1 bit de stop 2 bits de stop 1 bit de stop 2 bits de stop 1 bit de stop 2 bits de stop
1200,
2400,
5 SERIAL_5N1 SERIAL_5N2 SERIAL_5E1 SERIAL_5E2 SERIAL_5O1 SERIAL_5O2
4800,
6 SERIAL_6N1 SERIAL_6N2 SERIAL_6E1 SERIAL_6E2 SERIAL_6O1 SERIAL_6O2 9600,
7 SERIAL_7N1 SERIAL_7N2 SERIAL_7E1 SERIAL_7E2 SERIAL_7O1 SERIAL_7O2
14400,
19200,
8 SERIAL_8N1 SERIAL_8N2 SERIAL_8E1 SERIAL_8E2 SERIAL_8O1 SERIAL_8O2
28800,
38400,
57600,
115200

11
Serial.begin (Baudrate);

12
 Serial.setTimeout (Timeout_in_ms);

Description:
 Cette fonction fixe le délai maximum en millisecondes à attendre pour la lecture de flux de
données.
 La valeur par défaut est 1000 millisecondes (=1 seconde).

13
Serial.setTimeout (Timeout_in_ms);

14
Serial.setTimeout (Timeout_in_ms);

15
Serial.setTimeout (Timeout_in_ms);

16
 Serial.available ();

int Count = Serial.available (); // Nombre d'octets dans le tampon de réception

Description:
Donne le nombre d’octets (caractères) disponible pour la lecture dans la file d’attente (buffer) du
port série.
Valeur renvoyées:
Le nombre d’octet disponible pour lecture dans la fille d’attente (buffer) du port série.
Il retourne 0 si aucun caractère n’est disponible.
Si une donnée est arrivée Serial.available() sera supérieur à 0.
La file d’attente du buffer peut recevoir jusqu’ à 128 octets.

17
Serial.available ();

18
Serial.available ();

19
 Serial.availableForWrite ();

int Count = Serial.availableForWrite (); // fournit le Nombre d'espaces libres dans le tampon
//d'envoi sans blocage de l’opération d’écriture.
Description:
fournit le Nombre d'espaces libres dans le tampon d'envoi sans blocage de l’opération d’écriture
Valeur renvoyées:
Le nombre d’octets disponible pour l’opération d’écriture.

20
 Serial.end()

Description:
Désactive la communication série, permettant aux broches RX et TX d'être utilisées pour l'entrée
et la sortie générales.
Pour réactiver la communication série, appelez Serial.begin ().

21
 Les données de sortie

Serial.print (Value); // Affiche la valeur ou la chaîne de caractères sous forme de chaîne

Serial.println (Value); // Sortie suivie d'un saut de ligne

Serial.print (Value, Format); // Sortie avec / sans saut de ligne dans le ...
Serial.println (Value, Format); // format HEX, BIN, ...

Serial.write (Value); // Sortie d'un caractère binaire(uint8_t)

Serial.write (Buffer, Length); // Sortie d'une zone mémoire

22
 Serial.print (Value); Serial.println (Value);

Serial.print(value)
•value : character, string, number to be printed.
•This function is used to print data to a serial port in a form that is human readable (character,
strings, numbers).
•Example Serial.print(“Hi 1234”)
Prints Hi 1234 on the serial monitor.

Serial.println(value)
•value : character, string, number to be printed.
•This function is used to print data to a serial port in a form that is human readable (character,
strings, numbers) followed by a carriage return (\r) and a new line character (\n).

23
Serial.print (Value); Serial.println (Value);

24
Serial.print (Value); Serial.println (Value);

25
 Serial.print (Value, Format); Serial.println (Value, Format);

Serial.print (data, format type (optional))

It sends ASCII character on serial port so human can read it easily. This function converts the
data to ascii character and then send (print) it.
e.g. Serial.print (123);
Serial.print (“123”);
Serial.print (12, HEX)

Serial.println (data, format type (optional))

It sends ASCII character on serial port followed by carriage return.

26
Serial.print (Value, Format); Serial.println (Value, Format);

27
Serial.print (Value, Format); Serial.println (Value, Format);

28
Serial.print (Value, Format); Serial.println (Value, Format);

29
Serial.print (Value, Format); Serial.println (Value, Format);

30
 Serial.write (Value); Serial.write (Buffer, Length);

Serial.write(value), Serial.write(string), Serial.write(buff, length)

•value : value to be sent as a single byte.
•string : string to be sent as a series of bytes.
•buff : array of data to be sent as bytes.
•length : number of bytes to be sent.
•This function writes data in binary form to the serial port. Data is sent in form of bytes or
series of bytes.
Returns
write() will return the number of bytes written, though reading that number is optional. Data
type: size_t.

•Example Serial.write(100)
Serial.write(“Hello”)
Serial.write()
This function writes binary data to the serial port. It returns number of byte written.
e.g. Serial.write (65); // it writes actual byte to serial port

31
 Serial.write (Value); Serial.write (Buffer, Length);
 It sends the binary data to the serial port in Arduino.
 The data through Serial.write is sent as a series of bytes or a single byte.
 The data type is size_t.
 The Serial.write( ) function will return the number of written bytes.
 If we want to send the digits of numbers represented by the characters, we need to use the
Serial.print( ) function instead of Serial.write( ).

32
Serial.write (Value); Serial.write (Buffer, Length);

33
 Lecture des données

int Value = Serial.read (); // lire les caractères (-1: si rien n'est reçu)

int Value = Serial.readBytes (Buffer, Length); // Nombre de caractères reçus (voir timeout)
String Value = Serial.readString (); // lire dans la chaîne (terminé par une nouvelle ligne)

float Value = Serial.parseFloat (SKIP_WHITESPACE); // Lire en nombre à virgule flottante

long Value = Serial.parseInt (SKIP_WHITESPACE); // Lecture en valeur entière de 32 bits

34
 Serial.read();

Serial.read()
•This function returns a character that was received on the Rx pin of Arduino.
•Example char read_byte
read_byte = Serial.read()
Byte of data read is stored in read_byte.

Serial.read();
This function is used to read data serially.
e.g. received_data = Serial.read()

35
 Serial.read();

 The above code clearly explains that the Serial.available( ) is used to get the available number
of bytes if it is greater than 0.

 The Serial.read( ) function will read the data from the data byte and print a message if the data
is received.

 The data is sent from the serial monitor to the Arduino.

36
 Serial.read();
 Lecture des données en série à partir du PC

 Affichage des données sur le moniteur série

 Ici, nous transmettrons les données en série à partir du PC et les lirons en utilisant Arduino.

 Après la lecture, affichez ces données sur le moniteur série (PC).

37
 Serial.read();
Contrôle LED ON-OFF à partir du PC en utilisant Arduino
 Construisons une petite application dans laquelle nous contrôlerons la led en envoyant une
commande série à partir du PC.

38
 Serial.readString ()

Serial.readString()
This function is used to read the received string.
e.g. String received_data = Serial.readString()
 It reads the incoming serial data from the serial buffer in the string. The String data type is
used here.

 The above code clearly explains that the Serial.readString( ) is used to read the serial data
into the string.

 The string specified here is b.

 The data in the Serial function is read as a string in the above code. 39
 Serial.readString ()

Lire la chaîne transmise à partir du PC

 Écrivons un programme pour lire la chaîne reçue du PC et l’afficher sur le moniteur série.

40
 Serial.readString ()

 How serial data is read by Serial.readString( ) and Serial.read( )?

 The Serial.read( ) function reads the data in terms of bytes, while the
Serial.readString( ) reads the data in the term of string.

41
 Serial.readBytes (Buffer, Length);
int readBytes (* buf, len)
Reads bytes arriving in the serial port and writes them to the buffer. Stops after receiving a
specified number of bytes or in the case of a timeout. Returns the number of bytes received. The
timeout is set by the setTimeout() function.
Description
Serial.readBytes() reads characters from the serial port into a buffer. The function terminates if
the determined length has been read, or it times out (see Serial.setTimeout()).
Serial.readBytes() returns the number of characters placed in the buffer. A 0 means no valid data
was found.
Syntax
Serial.readBytes(buffer, length)
Parameters
buffer: the buffer to store the bytes in (char[] or byte[])
length : the number of bytes to read (int)
Returns
byte

Serial.readBytesUntil() – reads characters from the serial buffer into an array. It terminates if the
determined length has been read, if there is a timeout, or if the terminator character is detected.
The terminator itself is not returned in the buffer. This method has this syntax:
Serial.readBytesUntil(terminator character, buffer, length)
42
43
44
 Table ASCII
 Écrire un programme qui Imprime les valeurs d'octets dans tous les formats possibles:

 comme valeurs binaires brutes

 sous forme décimale,
 hexadécimale,
 octale
 et binaire codée ASCII

45
Table ASCII

46
 Variateur (Dimmer)
 Démontre l'envoi de données de l'ordinateur à la carte Arduino, dans ce cas pour contrôler la
luminosité d'une LED.
 Les données sont envoyées en octets individuels, dont chacun varie de 0 à 255.
 Arduino lit ces octets et les utilise pour régler la luminosité de la LED.
 Le circuit:
 LED reliée de la broche numérique 9 à la terre.
 Connexion série à Processing, Max / MSP ou à une autre application série

47
 Graphique
 Un exemple simple de communication de la carte Arduino à l'ordinateur.
 La valeur de l'entrée analogique 0 est envoyée sur le port série.
 Nous appelons cette communication «série» parce que la connexion apparaît à la fois à
l'Arduino et à l'ordinateur comme un port série, même si elle peut en fait utiliser un câble
USB.
 Les octets sont envoyés l'un après l'autre (en série) de l'Arduino à l'ordinateur.
 Vous pouvez utiliser le moniteur série Arduino pour afficher les données envoyées, ou il peut
être lu par Processing, PD, Max / MSP ou tout autre programme capable de lire des données à
partir d'un port série.
 Le code de traitement ci-dessous représente les données reçues afin que vous puissiez voir la
valeur de l'entrée analogique changer au fil du temps.
 Le circuit: - tout capteur d'entrée analogique connecté à l'analogique sur la broche 0

48
 Test série multiple : Multiple Serial test
 Reçoit du port série principal, envoie aux autres.
 Reçoit du port série 1, envoie au port série principal (Serial 0).
 Cet exemple ne fonctionne qu'avec les cartes avec plus d'une série comme Arduino Mega,
Due, Zero etc.
 Le circuit:
 tout périphérique série connecté au port série 1
 Moniteur série ouvert sur le port série 0

49
 Pixel physique
 Un exemple d'utilisation de la carte Arduino pour recevoir des données de l'ordinateur.

 Dans dans ce cas, les cartes Arduino allument une LED quand elles reçoivent le personnage
'H' et éteint la LED lorsqu'elle reçoit le caractère 'L'.
 Les données peuvent être envoyées à partir du moniteur série Arduino ou d'un autre
programme comme Processing, Flash (via un proxy réseau série), PD ou Max / MSP.
 Le circuit: - LED connectée de la broche numérique 13 à la terre

50
 Lecture série d'une chaîne codée ASCII

 Ce programme illustre la fonction Serial parseInt ().

 Il recherche une chaîne ASCII de valeurs séparées par des virgules.

 Il les analyse en entiers et les utilise pour atténuer une LED RVB.

 Circuit: LED RVB à cathode commune câblée comme suit:

 anode rouge: broche numérique 3

 anode verte: broche numérique 5

 anode bleue: broche numérique 6

 cathode: GND

51
Lecture série d'une chaîne codée ASCII

52
 Appel série et réponse
 Ce programme envoie un ASCII A (octet de valeur 65) au démarrage et le répète jusqu'à ce
qu'il reçoive des données.

 Ensuite, il attend un octet dans le port série et envoie trois valeurs de capteur chaque fois qu'il
reçoit un octet.

 Le circuit:
 potentiomètres attachés aux entrées analogiques 0 et 1
 bouton-poussoir attaché aux E / S numériques 2

53
Lecture série d'une chaîne codée ASCII
Appel série et réponse

54
 Appel série et réponse en ASCI
 Ce programme envoie un ASCII A (octet de valeur 65) au démarrage et le répète jusqu'à ce
qu'il reçoive des données.
 Ensuite, il attend un octet dans le port série et envoie trois valeurs de capteur codées en ASCII,
séparées par des virgules, tronquées par un saut de ligne et un retour chariot, chaque fois qu'il
reçoit un octet.
 Le circuit:
 potentiomètres attachés aux entrées analogiques 0 et 1
 bouton-poussoir attaché aux E/S numériques 2

55
Appel série et réponse en ASCI

56