LA LIAISON SERIE
Les liaisons séries, en général, sont des moyens de transport d'informations (communication) entre divers systèmes numériques. On les oppose aux liaisons parallèles par le fait que les différents bits d'une donnée ne sont pas envoyés en même temps mais les uns après les autres, ce qui limite le nombre de fils de transmission. Elles sont appelées asynchrones car aucune horloge n'est transportée avec le signal de données. Le récepteur ne sait pas quand il reçoit des informations.
Toutes les liaisons communicantes (série, I2C, CAN, SPI, etc...) doivent respecter un protocole de transmission. Ce protocole devra être le même pour les deux éléments afin que la transmission fonctionne correctement.
​
Pour la liaison série, le protocole d'échange asynchrone est défini par l'envoi grâce à un UART (Universal Asynchronous Receiver Transmitter), pour chaque caractère émis, de :
-
un bit de Start.
-
les 5 à 8 bits de données (bit de poids faible en premier).
-
éventuellement, un bit de vérification de parité qui permet de déceler des erreurs de transmission des 8 bits de données sur la ligne.
-
un, un et demi, ou deux bits de Stop après.
​
Parité: le mot transmis peut-être suivi ou non d'un bit de parité qui sert à détecter les erreurs éventuelles de transmission. Il existe deux types de parité.
-
Parité paire : le bit ajouté à la donnée est positionné de telle façon que le nombre des états 1 soit pair sur l'ensemble des bits de données + bit de parité.
Ex : soit la donnée 11001011 contenant 5 état « 1 », le bit de parité paire est positionné à 1, ramenant ainsi le nombre de 1 à 6 donc pair.
-
Parité impaire : le bit ajouté à la donnée est positionné de telle façon que le nombre des états 1 soit impair sur l'ensemble des bits de données + bit de parité.
Ex : soit la donnée 11001011 contenant 5 état « 1 », le bit de parité paire est positionné à 0, laissant ainsi un nombre de 1 impair.
​
Dans la technologie Arduino, tout est simplifié au maximum et la trame est constituée de :
-
un bit de Start.
-
les 8 bit de données.
-
un bit de Stop.
Avec une liaison série, seuls deux composants peuvent communiquer avec un câble croisé. La sortie Tx de l'un doit être relié à l'entrée Rx de l'autre. Bien entendu, les deux éléments doivent avoir également une masse commune.
​
Lorsque l’on transmet des informations par une liaison série, on ne transmet que des 0 et des 1, soit un nombre. Dans le cas de ce type de liaison, on transmet les informations par paquet, soit 8 bits, donc un nombre compris entre 0 et 255.
En fait, on envoie des caractères codés en ASCII. Le tableau suivant nous donne le code ASCII de chaque caractère de l’alphabet.
Supposons que deux systèmes communiquent, et que le système A veuille envoyer le mot « Arduino » au système B. A va donc devoir envoyer 7 octets, chaque octet correspondant à une lettre, soit : 65, 114, 100, 117, 105, 110, 111 en décimal ou $41, $72, $64, $75, $69, $6E, $6F en hexadécimal.
La table ASCII de base (ci-dessus) ne contient que 128 caractères. Il existe une table dite étendue qui contient 255 caractères mais qui n’est pas prise en charge par Arduino. C’est pour cela que si l’on souhaite transmettre un mot avec un caractère accentué, Arduino va remplacer le caractère accentué par un autre caractère.
​
L'Arduino Uno possède une liaison série matérielle (Rx : broches numériques N°0 et Tx : broche numérique N°1) qui permet d'établir la communication avec l'ordinateur via le port USB. C'est cette liaison qui permet d'émettre ou de recevoir des messages depuis le moniteur série.
​
​
Pour initialiser la liaison série, il faut écrire l'instruction Serial.begin(bauds) dans le Setup du programme où Bauds représente la vitesse de transmission des données.
Les instructions utilisées avec Arduino pour échanger des informations sur la liaison série sont principalement :​
-
Serial.write() : envoi de l’octet compris entre les parenthèses.
-
Serial.print() : envoi tout ce qu’il y a entre les parenthèses sous forme d’octets donc en ASCII.
-
Serial.read() : lit l’octet reçu sur la liaison série.
-
Serial.avaible() : renvoie le nombre d'octets présents sur la liaison série.
​
Ces instructions appartiennent à la bibliothèque Serial() qui est installée de base dans l'IDE Arduino.
​
Remarque : Serial.println() fait la même chose que Serial.print() mais avec un retour à la ligne.
​
Exemple :
Si un programme comporte l’instruction Serial.write(48), la carte Arduino va envoyer l’octet 48 (00110000 en binaire) et de l’autre côté, nous recevrons donc l’octet 48. Libre au système de réception d’interpréter cette donnée comme il l’entend, soit en regardant la correspondance dans la table ASCII et donc de comprendre que ce qu’il a reçu est le caractère « 0 », soit en prenant ce nombre comme il est, soit 48.
Si un programme comporte l’instruction Serial.print(48), la carte Arduino va envoyer le code ASCII pour le « 4 » puis celui pour le « 8 ». Donc ici, contrairement à l’instruction Serial.write(), le programme va envoyer deux octets au lieu d’un seul, et d’autre part codés en ASCII. Il sera donc transmis 52 et 56.
La différence va se faire au niveau de la déclaration de la variable car il n’y a qu’une seule instruction pour la réception.
Si un programme comporte l’instruction nombre=Serial.read () avec nombre déclaré en byte, nombre sera égal à 48 et si nombre est déclaré en char, nombre sera égal aussi à 48. Si on fait afficher nombre sur un afficheur à cristaux liquides ou dans le moniteur Arduino, on aura 0 (48 est le code ASCII de 0) pour le premier cas et 48 pour le second cas.
​
De nombreux modules (GPS, XBee, etc) communiquent avec les cartes Arduino grâce à une liaison série et nous pouvons mettre en oeuvre une liaison série logicielle. Nous utilisons, à ce moment là, la bibliothèque SoftwareSerial() et la liaison série matérielle reste disponible pour le moniteur série. Les instructions de la bibliothèque SoftwareSerial() sont les mêmes que pour la bibliothèque Serial().
​
Exemple :
Nous souhaitons allumer à distance une led située sur une carte Arduino depuis un bouton poussoir situé sur une autre carte Arduino. Les deux Arduino communiquent grâce à deux modules XBee.
/* Bouton_serie est un programme qui permet de changer l'état d'une variable à chaque appui sur un bouton poussoir et d'envoyer le caractère sur la liaison série*/
#define bouton 4 // bouton sur la broche 4
boolean bp=0;
char octet;
​
//Création d'une liaison série sur les broches 2 et 3
#include <SoftwareSerial.h>
SoftwareSerial xbee(2, 3); // RX, TX
​
void setup()
{
xbee.begin(9600); // initialise connexion série XBee
pinMode (bouton,INPUT); // broche bouton configurée en entrée
}
​
void loop()
{
if (digitalRead(bouton)==HIGH) // si appui
{
delay(200);
bp=!bp; // changement d'état
}
if (bp==LOW)
{
octet='0';
}
else
{
octet='1';
}
xbee.print(octet);
delay(500);
}
/* Led_bouton_serie est un programme associé à Bouton_serie*/
#define led 5 // bouton sur la broche 5
char octet; // variable de stockage des valeurs reçues sur le port Série (ASCII)
​
// Création d'une liaison série sur les broches 2 et 3
#include <SoftwareSerial.h>
SoftwareSerial xbee(2, 3); // RX, TX
​
void setup()
{
xbee.begin(9600); // initialise connexion série XBee
pinMode (led,OUTPUT); // broche led configurée en sortie
}
​
void loop()
{
while (xbee.available()==0); // attente d'un octet en réception
octet=xbee.read(); // lit le 1er octet reçu et le met dans la variable
if (octet=='0')
{
digitalWrite(led,LOW); // extinction de la led
}
if (octet=='1')
{
digitalWrite(led,HIGH); // allumage de la led
}
}