Chapitre 5Livre « Arduino sous le capot »

Les liaisons séries

Échanger des données avec un PC, des capteurs et d’autres circuits par UART, I²C, OneWire et SPI

Un microcontrôleur isolé ne sert pas à grand-chose. Il doit dialoguer avec un PC, lire des capteurs, commander un écran, écrire sur une carte mémoire. Pour économiser les broches et les fils, ces échanges se font presque toujours en série : les bits circulent l’un après l’autre sur un ou deux fils.

Ce chapitre présente les quatre liaisons séries que l’on rencontre sur Arduino : l’UART, héritière de la liaison RS232, pour dialoguer avec un PC ou un module ; le bus I²C, pour brancher plusieurs capteurs sur deux fils ; le bus OneWire, pour des capteurs de température sur un seul fil ; le bus SPI, rapide, pour les écrans et les cartes mémoire. Pour chacune, on étudie la trame, le logigramme d’un échange, les fonctions Arduino et un exemple complet.

Objectifs du chapitre

  • Utiliser le vocabulaire des liaisons séries : synchrone, asynchrone, débit, duplex, bus, maître.
  • Décrire une trame UART et relier deux équipements en UART ou en RS232.
  • Expliquer l’adressage, l’accusé de réception et les résistances de pull-up du bus I²C, et utiliser la bibliothèque Wire.
  • Lire un thermomètre DS18B20 sur un bus OneWire.
  • Expliquer l’échange SPI par registres à décalage et commander un 74HC595.
  • Choisir la liaison adaptée à une application.

Prérequis

Les entrées-sorties numériques et les masques (chapitre 3), les temporisations (chapitre 4) et la numération binaire et hexadécimale.

Plan du chapitre

  1. Partie I – Généralités
  2. 5.1Transmettre des données en série
  3. Partie II – UART / RS232
  4. 5.2La trame UART
  5. 5.3La liaison série sur Arduino
  6. Partie III – I²C
  7. 5.4Le bus I²C
  8. 5.5La bibliothèque Wire et un exemple
  9. Partie IV – OneWire
  10. 5.6Le bus OneWire
  11. Partie V – SPI
  12. 5.7Le bus SPI
  13. Partie VI – Synthèse et évaluation
  14. 5.8Choisir une liaison série
  15. 5.9À retenir et QCM
  16. 5.10Sources et références

Chapitre 5 · Partie I

Généralités

Avant d’étudier chaque liaison, on fixe le vocabulaire commun et l’on compare les quatre liaisons dans un même tableau.

Chapitre 5 · Section 5.1

Transmettre des données en série

Une liaison parallèle transmet un octet d’un coup sur huit fils ; une liaison série transmet ses bits l’un après l’autre sur un seul fil de données. Moins rapide à fréquence égale, elle demande beaucoup moins de broches et porte plus loin.

Figure 5.1 interactif – Liaison parallèle et liaison série, et le vocabulaire des liaisons séries.

5.1.1Parallèle ou série ?

En parallèle, huit fils transportent simultanément les huit bits d’un octet ; il faut en plus un fil pour indiquer quand lire. En série, un seul fil de données suffit : les bits passent l’un après l’autre (figure 5.1). Comme un microcontrôleur dispose de peu de broches, la liaison série est la solution retenue pour le relier à ses capteurs, écrans et modules. Elle a aussi l’avantage de mieux supporter les longs câbles, où les signaux de fils voisins arrivent décalés.

5.1.2Le vocabulaire

TermeSignification
SynchroneUn fil d’horloge indique quand lire chaque bit (I²C, SPI).
AsynchronePas d’horloge : émetteur et récepteur ont convenu du débit à l’avance (UART). OneWire se cale sur des durées fixes.
BaudNombre de symboles transmis par seconde. En UART, un symbole est un bit : 9 600 bauds = 9 600 bit/s, soit 960 octets/s (10 bits par octet en 8N1).
Full duplexÉmission et réception en même temps (UART, SPI).
Half duplexChacun son tour sur le même fil (I²C, OneWire).
Point à pointDeux équipements seulement (UART).
BusPlusieurs équipements partagent les fils : il faut les désigner par une adresse (I²C, OneWire) ou par un fil de sélection (SPI).
MaîtreL’équipement qui lance les échanges, en général le microcontrôleur ; les autres sont des esclaves.

5.1.3Quatre liaisons comparées

Les quatre liaisons séries de l’Arduino comparées.
Figure 5.2 – Les quatre liaisons séries de l’Arduino comparées.

Les quatre liaisons se distinguent d’abord par la façon dont l’émetteur et le récepteur se synchronisent. L’UART n’a pas de fil d’horloge : les deux équipements conviennent à l’avance d’un débit, et chaque trame commence par un bit de start sur lequel le récepteur se cale. L’I²C et le SPI transmettent au contraire une horloge (SCL, SCK), fournie par le maître : le récepteur lit chaque bit au rythme de cette horloge, même si le débit varie. Le OneWire n’utilise qu’un seul fil de données, sans horloge : chaque bit est codé par la durée d’une impulsion à 0, dans un créneau de durée fixe.

Elles diffèrent ensuite par le nombre d’équipements reliés. L’UART est une liaison point à point entre deux équipements, qui peuvent émettre en même temps (full duplex) puisque chacun a son propre fil d’émission. Les trois autres sont des bus : un maître dialogue avec plusieurs esclaves et doit désigner celui à qui il s’adresse. En I²C, il envoie une adresse de 7 bits : sur les 128 valeurs possibles, 16 sont réservées par la norme (0x00 à 0x07 et 0x78 à 0x7F), il en reste 112. En OneWire, chaque composant porte un identifiant unique de 64 bits gravé en usine. En SPI, le maître met à 0 le fil CS de l’esclave choisi, ce qui demande un fil de plus par esclave.

Le choix se fait enfin sur le débit et la distance. Le SPI est le plus rapide, jusqu’à 8 Mbit/s sur AVR, mais il ne fonctionne bien que sur de très courtes distances : entre composants d’une même carte ou avec un module placé à quelques centimètres. L’I²C, à 100 ou 400 kbit/s, relie avec deux fils seulement des composants proches les uns des autres. Le OneWire est lent, environ 16 kbit/s, mais fonctionne sur plusieurs dizaines de mètres. L’UART, simple et universel, sert surtout à dialoguer avec un PC ou un module : GPS, Bluetooth. La section 5.8 revient sur ce choix.

✎ Signaler une erreur dans cette section

Chapitre 5 · Partie II

UART / RS232

L’UART est la liaison série la plus ancienne et la plus simple : deux fils, pas d’horloge, un format convenu à l’avance. C’est elle qui relie la carte Arduino au moniteur série du PC.

Chapitre 5 · Section 5.2

La trame UART

Une liaison asynchrone n’a pas de fil d’horloge. Pour que le récepteur sache quand lire chaque bit, l’émetteur encadre chaque octet par des bits de start et de stop, et les deux côtés ont réglé au préalable le même débit.

Figure 5.3 interactif – Construction d’une trame UART : choisissez un caractère, un débit et un format.

5.2.1Le principe

L’UART envoie un octet bit après bit sur un seul fil, chaque bit occupant la ligne pendant une durée fixe, fixée par le débit. Comme le récepteur ne reçoit aucune horloge, la trame doit lui indiquer elle-même quand un octet commence et quand il se termine. Elle se compose ainsi :

  • Au repos, la ligne est à 1.
  • Un bit de start à 0 réveille le récepteur, qui lance son chronomètre.
  • Suivent les 8 bits de données, le bit de poids faible (LSB) en premier.
  • Une parité facultative permet de détecter une erreur sur un bit.
  • Un bit de stop à 1 termine la trame.

Les deux côtés doivent régler le même débit et le même format, par exemple 9 600 bauds en 8N1 : 8 bits de données, pas de parité (None), 1 bit de stop. C’est le format par défaut de Serial.begin(). À 9 600 bauds, un bit dure 1 / 9 600 ≈ 104 µs, et une trame de 10 bits environ 1,04 ms (figure 5.3).

Définition – UART

Universal Asynchronous Receiver Transmitter : circuit qui convertit un octet en trame série asynchrone et inversement. Celui de l’ATmega328P, appelé USART car il sait aussi fonctionner en mode synchrone, est piloté par la bibliothèque Serial.

5.2.2Le logigramme d’une trame

Figure 5.4 interactif – Logigramme de l’émission et de la réception d’une trame UART : scénarios « émettre », « recevoir », « parasite » et « erreur ».

L’émetteur maintient TX à 1 au repos. Quand un octet attend dans son tampon, il met TX à 0 pendant la durée d’un bit (start), envoie les huit bits en commençant par D0, éventuellement la parité, puis remet TX à 1 (stop).

Le récepteur surveille RX. Lorsqu’il passe à 0, il attend une demi-durée de bit pour se placer au milieu du bit de start, et vérifie que RX est toujours à 0 : sinon, c’était un parasite, qui est ignoré. Il lit ensuite huit fois RX, à intervalles d’un bit, donc toujours au milieu de chaque bit, là où le signal est le plus stable. Il lit enfin le stop : s’il ne vaut pas 1, il signale une erreur de trame, dont la cause habituelle est un débit différent des deux côtés (figure 5.4, scénario « erreur »).

ÉlémentRôle sur Arduino
Circuit USARTexécute tout ce logigramme, bit par bit, sans le programme
Serial.write(c)dépose l’octet dans le tampon d’émission
Interruption de réceptionrange chaque octet reçu dans un tampon de 64 octets
Serial.available(), read()lisent ce tampon

5.2.3Niveaux TTL et RS232

Le caractère « A » en niveaux TTL et en niveaux RS232, et le brochage du connecteur DB9.
Figure 5.5 – Le caractère « A » en niveaux TTL et en niveaux RS232, et le brochage du connecteur DB9.

Sur les broches de l’Arduino, les niveaux sont dits TTL : 1 = 5 V, 0 = 0 V. La norme RS232, utilisée par les anciens ports série des PC, transporte la même trame avec d’autres niveaux : un 1 est une tension de −3 à −15 V, un 0 une tension de +3 à +15 V. La logique est inversée et les tensions plus élevées permettent des câbles d’une quinzaine de mètres (figure 5.5).

Attention – Ne jamais relier directement

Un port RS232 envoie jusqu’à ±15 V : il détruit une broche d’Arduino. On passe par un convertisseur de niveaux comme le MAX232, qui, alimenté en 5 V, fabrique lui-même les ±10 V nécessaires.

Sur le connecteur DB9 du PC, les broches utiles sont 2 (RXD, réception), 3 (TXD, émission) et 5 (GND) ; les broches 7 et 8 (RTS, CTS) servent au contrôle de flux facultatif. Entre deux équipements, on relie le TX de l’un au RX de l’autre – c’est un câble croisé – et l’on met les masses en commun. Les PC actuels n’ont plus de port RS232 : un convertisseur USB-série (CH340, FT232 ou l’ATmega16U2 de la Uno) crée un port COM virtuel. Le protocole UART reste le même.

Exercices

1. Dessinez la trame 8N1 du caractère « C » (0x43). Combien de temps dure-t-elle à 115 200 bauds ?

0x43 = 0100 0011. La trame est : start 0, puis D0 à D7 = 1 1 0 0 0 0 1 0, puis stop 1. Elle compte 10 bits de 1 / 115 200 ≈ 8,68 µs, soit environ 86,8 µs.

2. Combien d’octets par seconde peut-on transmettre au maximum à 9 600 bauds en 8E1 ?

8E1 = 1 start + 8 données + 1 parité + 1 stop = 11 bits par octet. 9 600 / 11 ≈ 872 octets par seconde.

3. Pourquoi le récepteur lit-il chaque bit en son milieu ?

Les horloges de l’émetteur et du récepteur ne sont jamais parfaitement identiques, et les fronts du signal sont arrondis par le câble. En lisant au milieu du bit, on dispose d’une marge d’une demi-durée de bit de chaque côté : la lecture reste correcte malgré un petit écart de débit, jusqu’à quelques pour cent sur une trame.

✎ Signaler une erreur dans cette section

Chapitre 5 · Section 5.3

La liaison série sur Arduino

L’objet Serial et ses variantes donnent accès aux UART du microcontrôleur. Quelques fonctions suffisent pour envoyer du texte, lire des caractères et des nombres, ou relier deux cartes.

Les ports série des cartes Uno et Mega et les fonctions essentielles de Serial.
Figure 5.6 – Les ports série des cartes Uno et Mega et les fonctions essentielles de Serial.

5.3.1Les ports série

CarteObjetRXTX
Uno, NanoSerialD0D1
Mega 2560SerialD0D1
Serial1D19D18
Serial2D17D16
Serial3D15D14

Serial est relié au port USB par le convertisseur de la carte : D0 et D1 sont donc occupés pendant le téléversement et lorsque le moniteur série est utilisé. Sur la Uno, qui n’a qu’un port matériel, la bibliothèque SoftwareSerial crée un port série sur deux autres broches, par logiciel. Elle a ses limites : un seul port logiciel écoute à la fois, et le débit conseillé ne dépasse pas 57 600 bauds.

5.3.2Les fonctions essentielles

Serial.begin(9600);              // débit, format 8N1 par défaut
Serial.print("T = ");            // envoie du texte
Serial.println(23.5);            // valeur + retour à la ligne
Serial.write(65);                // envoie l’octet 65 ('A')
if (Serial.available() > 0) {    // octets reçus en attente ?
  char c = Serial.read();        // lit un octet
}
String ligne = Serial.readStringUntil('\n');
int n = Serial.parseInt();       // lit un nombre

print() convertit la valeur en caractères : Serial.print(65) envoie les deux octets « 6 » et « 5 ». write() envoie l’octet brut : Serial.write(65) envoie un seul octet, que le moniteur affiche « A ». Les octets reçus attendent dans un tampon de 64 octets jusqu’à leur lecture ; au-delà, les suivants sont perdus.

5.3.3Exemples d’applications

Piloter une LED depuis le moniteur série. Le programme lit les caractères tapés dans le moniteur et réagit à « 1 » et « 0 » :

const int LED = 13;
void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Tapez 1 (allumer) ou 0 (éteindre)");
}
void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '1') {
      digitalWrite(LED, HIGH);
      Serial.println("LED allumée");
    } else if (c == '0') {
      digitalWrite(LED, LOW);
      Serial.println("LED éteinte");
    }
  }
}

Relier deux cartes Mega. Le TX1 (D18) de l’émettrice est relié au RX1 (D19) de la réceptrice, et les masses sont communes. L’émettrice envoie la valeur d’un potentiomètre sous forme de texte ; la réceptrice la relit avec parseInt() et la transmet au PC :

// Émettrice
void setup() { Serial1.begin(9600); }
void loop() {
  Serial1.println(analogRead(A0));   // ex. "512\n"
  delay(200);
}
// Réceptrice
void setup() { Serial.begin(9600); Serial1.begin(9600); }
void loop() {
  if (Serial1.available()) {
    int v = Serial1.parseInt();      // lit le nombre
    Serial.println(v);               // vers le PC
  }
}

À retenir

En UART : même débit et même format des deux côtés, TX vers RX, masses communes. print() envoie du texte, write() des octets.

Exercices

1. Que reçoit le moniteur série après Serial.print(3.14159); ? Comment afficher quatre décimales ?

Par défaut, print() affiche deux décimales : « 3.14 ». Serial.print(3.14159, 4); affiche « 3.1416 ».

2. Un module GPS envoie ses données à 9 600 bauds. On veut l’utiliser sur une Uno tout en gardant le moniteur série. Que proposez-vous ?

Le port matériel Serial est réservé au PC. On crée un port logiciel pour le GPS : SoftwareSerial gps(8, 9); (RX sur D8, TX sur D9), puis gps.begin(9600);. 9 600 bauds est compatible avec SoftwareSerial. Sur une Mega, on utiliserait simplement Serial1.

✎ Signaler une erreur dans cette section

Chapitre 5 · Partie III

I²C

Le bus I²C relie plusieurs circuits sur deux fils seulement. Chaque esclave est désigné par une adresse et confirme chaque octet reçu : le maître sait toujours si l’échange s’est bien passé.

Chapitre 5 · Section 5.4

Le bus I²C

Conçu par Philips pour relier les circuits d’un téléviseur, le bus I²C (Inter-Integrated Circuit) est devenu le standard des capteurs, horloges et petits écrans. Microchip l’appelle TWI (Two-Wire Interface).

Le bus I²C : un maître, plusieurs esclaves et deux résistances de pull-up.
Figure 5.7 – Le bus I²C : un maître, plusieurs esclaves et deux résistances de pull-up.

5.4.1Un maître, plusieurs esclaves sur deux fils

Le bus comporte deux lignes : SDA pour les données et SCL pour l’horloge (figure 5.7).

  • Le maître, l’Arduino, produit l’horloge et lance chaque échange.
  • Chaque esclave a une adresse de 7 bits, fixée par le fabricant et parfois réglable par des cavaliers.
  • Les sorties sont à drain ouvert : un équipement peut mettre une ligne au niveau bas, jamais la forcer à 1. Deux résistances de pull-up, typiquement 4,7 kΩ, ramènent les lignes à 1 lorsque personne ne les tire vers le bas. Ainsi, deux équipements qui parlent en même temps ne créent jamais de court-circuit.
CarteSDASCLVitesse
Uno, NanoA4A5100 kHz par défaut, 400 kHz possible
Mega 2560D20D21

Attention

Deux modules à la même adresse sont en conflit et aucun des deux ne fonctionne. Les pull-up sont souvent déjà soudées sur les modules : avec trop de modules en parallèle, la résistance équivalente devient trop faible et les esclaves n’arrivent plus à tirer la ligne au niveau bas.

Définition – Sortie à drain ouvert

Sortie qui ne peut que relier la ligne à la masse ou la laisser libre. Le niveau haut est fourni par une résistance de pull-up extérieure. Plusieurs sorties à drain ouvert peuvent partager la même ligne sans risque.

5.4.2La trame I²C

Figure 5.8 interactif – Chronogramme d’une trame I²C : choisissez l’esclave et l’opération, puis suivez l’échange bit par bit.

Un échange se déroule ainsi (figure 5.8) :

  1. START : le maître fait passer SDA de 1 à 0 pendant que SCL est à 1. Cette transition, interdite en cours d’échange, signale le début d’une trame ;
  2. le maître envoie l’adresse sur 7 bits, bit de poids fort en premier, suivie du bit R/W : 0 pour écrire, 1 pour lire ;
  3. l’esclave qui reconnaît son adresse répond ACK en mettant SDA à 0 pendant le neuvième coup d’horloge. Si personne ne répond, la pull-up laisse SDA à 1 : c’est un NACK, et le maître sait que personne n’est à cette adresse ;
  4. les octets de données suivent, chacun confirmé par un ACK du récepteur. En lecture, c’est l’esclave qui pilote SDA, et le maître répond NACK au dernier octet pour dire « c’était le dernier » ;
  5. STOP : SDA passe de 0 à 1 pendant que SCL est à 1.

En dehors du START et du STOP, SDA ne change que lorsque SCL est à 0 ; le récepteur lit SDA pendant que SCL est à 1.

5.4.3Le logigramme d’un échange

Figure 5.9 interactif – Logigramme d’un échange I²C : écrire deux octets, lire deux octets, esclave absent.

La figure 5.9 suit ce déroulement pour trois scénarios et le met en correspondance avec les fonctions de la bibliothèque Wire :

FonctionSur le bus
beginTransmission(adr)rien : prépare l’envoi
write(octet)rien : met l’octet en tampon (32 au plus)
endTransmission()START, adresse + W, octets, STOP. Renvoie 0 si tout va bien, 2 ou 3 si un NACK arrive
requestFrom(adr, n)START, adresse + R, n octets (ACK… NACK), STOP

✎ Signaler une erreur dans cette section

Chapitre 5 · Section 5.5

La bibliothèque Wire et un exemple

La bibliothèque Wire, fournie avec l’IDE, fait du microcontrôleur un maître I²C. La plupart des modules I²C sont organisés en registres numérotés : on écrit le numéro du registre, puis on lit ou on écrit son contenu.

5.5.1Écrire puis lire un registre

Lire un registre demande deux échanges successifs : le maître écrit d’abord le numéro du registre qui l’intéresse, puis il relance une transmission en lecture pour récupérer son contenu. Le programme suivant lit ainsi, toutes les secondes, le registre 0x00 du module d’adresse 0x68 – les secondes d’une horloge DS3231 – et l’affiche dans le moniteur série :

#include <Wire.h>
const byte ADR = 0x68;                // adresse 7 bits
void setup() {
  Wire.begin();                       // Arduino = maître
  Serial.begin(9600);
}
void loop() {
  Wire.beginTransmission(ADR);        // START + adresse + W
  Wire.write(0x00);                   // n° du registre à lire
  Wire.endTransmission();             // envoi, puis STOP
  Wire.requestFrom(ADR, (byte)1);     // START + adresse + R
  if (Wire.available()) {
    byte v = Wire.read();             // octet reçu
    Serial.println(v, HEX);
  }
  delay(1000);
}

5.5.2Le scanner I²C

Ce petit programme essaie toutes les adresses utilisables et affiche celles qui répondent par un ACK. C’est le premier programme à lancer avec un nouveau module : l’adresse réelle diffère parfois de la documentation (0x27 ou 0x3F pour un écran LCD).

#include <Wire.h>
void setup() {
  Wire.begin();
  Serial.begin(9600);
  for (byte a = 8; a < 120; a++) {
    Wire.beginTransmission(a);
    if (Wire.endTransmission() == 0) {     // ACK reçu
      Serial.print("Module trouvé : 0x");
      Serial.println(a, HEX);
    }
  }
}
void loop() { }

Attention

Le tampon de Wire fait 32 octets : on ne peut pas transmettre plus de 32 octets en une transmission. Wire.setClock(400000); passe le bus à 400 kHz, si tous les esclaves le supportent.

5.5.3Exemple : une horloge sur écran LCD

Figure 5.10 interactif – Une horloge DS3231 (0x68) lue avec Wire et affichée sur un écran LCD I²C (0x27).

Deux esclaves partagent SDA et SCL : un module horloge temps réel DS3231 et un écran LCD de 2 lignes de 16 caractères ; seule l’adresse les distingue (figure 5.10).

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);   // adresse, 16 col., 2 lignes

byte bcd(byte v) { return (v >> 4) * 10 + (v & 0x0F); }

void setup() {
  Wire.begin();
  lcd.init();
  lcd.backlight();
  lcd.print("Heure DS3231");
}
void loop() {
  Wire.beginTransmission(0x68);
  Wire.write(0x00);                   // registre des secondes
  Wire.endTransmission();
  Wire.requestFrom(0x68, 3);          // secondes, minutes, heures
  byte s = bcd(Wire.read());
  byte m = bcd(Wire.read());
  byte h = bcd(Wire.read() & 0x3F);   // mode 24 h
  char txt[9];
  sprintf(txt, "%02d:%02d:%02d", h, m, s);
  lcd.setCursor(0, 1);
  lcd.print(txt);
  delay(500);
}

Le DS3231 code l’heure en BCD (Binary Coded Decimal) : chaque chiffre décimal occupe un quartet, si bien que 0x34 se lit « 3 » et « 4 ». La fonction bcd() sépare les deux chiffres avec un décalage et un masque (chapitre 3). La bibliothèque LiquidCrystal I2C est à installer depuis le gestionnaire de bibliothèques ; selon sa version, lcd.begin() remplace lcd.init().

Exercices

1. Le maître veut lire l’esclave d’adresse 0x68. Quel octet envoie-t-il juste après le START ?

L’adresse décalée d’un rang vers la gauche, suivie du bit R/W = 1 : (0x68 << 1) | 1 = 0xD1. Pour une écriture, ce serait 0xD0.

2. Le scanner I²C n’affiche rien alors qu’un écran est branché. Citez trois causes possibles.

SDA et SCL inversés ou branchés sur les mauvaises broches (A4/A5 sur Uno, D20/D21 sur Mega) ; masse ou alimentation du module non reliée ; absence de résistances de pull-up (module nu sans pull-up). On peut aussi soupçonner un module 3,3 V alimenté incorrectement.

3. Le registre des minutes du DS3231 contient 0x59. Que vaut bcd(0x59) ?

0x59 >> 4 = 5, 0x59 & 0x0F = 9 : 5 × 10 + 9 = 59 minutes.

✎ Signaler une erreur dans cette section

Chapitre 5 · Partie IV

OneWire

Le bus OneWire de Dallas (aujourd’hui Analog Devices) se contente d’un seul fil de données. Il est surtout connu par le thermomètre DS18B20, omniprésent dans les montages de mesure de température.

Chapitre 5 · Section 5.6

Le bus OneWire

Sans horloge et avec un seul fil, le bus OneWire repose entièrement sur des durées : le maître découpe le temps en créneaux, et la durée pendant laquelle la ligne reste basse code chaque bit.

Figure 5.11 interactif – Le bus OneWire et ses créneaux temporels : reset et présence, écriture et lecture d’un bit.

5.6.1Un seul fil de données

Le bus comprend un fil de données DQ, relié au 5 V par une résistance de pull-up de 4,7 kΩ, et la masse ; l’alimentation des capteurs peut même passer par DQ (mode parasite). Le maître fait tout : il découpe le temps en créneaux de durée fixe. Chaque composant possède un identifiant unique de 64 bits, gravé en usine : 8 bits de famille (0x28 pour le DS18B20), 48 bits de numéro de série et 8 bits de CRC pour vérifier la lecture.

5.6.2Les créneaux temporels

La figure 5.11 présente les cinq créneaux du protocole :

  • reset et présence : le maître tient DQ à 0 pendant 480 µs, puis relâche la ligne ; chaque esclave présent répond en tirant DQ à 0 pendant 60 à 240 µs ;
  • écrire un 1 : le maître met DQ à 0 pendant quelques microsecondes, puis le relâche pour le reste du créneau ;
  • écrire un 0 : le maître tient DQ à 0 pendant presque tout le créneau, environ 60 µs ;
  • lire un bit : le maître met DQ à 0 brièvement puis le relâche ; l’esclave laisse remonter la ligne pour un 1 ou la maintient basse pour un 0, et le maître lit DQ environ 15 µs après le début du créneau.

5.6.3Le logigramme d’une mesure

Figure 5.12 interactif – Logigramme d’une mesure de température : mesure normale, aucun capteur, erreur de CRC.

Une mesure avec un seul capteur sur le bus se déroule en deux échanges (figure 5.12) :

  1. reset et détection de présence ; s’il n’y a pas de réponse, aucun capteur n’est branché et l’on abandonne (la bibliothèque renvoie alors −127 °C) ;
  2. commande Skip ROM (0xCC) : le maître s’adresse à tous les capteurs sans envoyer d’identifiant, ce qui est possible puisqu’il n’y en a qu’un ; puis Convert T (0x44) : le capteur mesure, ce qui peut prendre jusqu’à 750 ms en résolution 12 bits ;
  3. nouveau reset, Skip ROM, puis Read Scratchpad (0xBE) : le maître lit les 9 octets de la mémoire du capteur, bit de poids faible d’abord, soit 72 créneaux de lecture ;
  4. le dernier octet est un CRC : s’il ne correspond pas aux autres, la lecture est fausse et l’on recommence. Sinon, la température est l’entier formé des octets 0 et 1, divisé par 16.

Plusieurs capteurs sur le bus

Skip ROM suivi de Convert T lance toutes les mesures d’un coup. Mais pour lire, il faut désigner un capteur avec Match ROM (0x55) suivi de son identifiant de 64 bits ; sinon, tous répondraient en même temps.

5.6.4Exemple : thermomètre DS18B20

Les échanges réalisés par la bibliothèque DallasTemperature, et les caractéristiques du DS18B20.
Figure 5.13 – Les échanges réalisés par la bibliothèque DallasTemperature, et les caractéristiques du DS18B20.

Le programme suivant affiche chaque seconde la température d’un DS18B20 relié à D2 :

#include <OneWire.h>
#include <DallasTemperature.h>
OneWire bus(2);                        // DQ sur D2
DallasTemperature sensors(&bus);

void setup() {
  Serial.begin(9600);
  sensors.begin();
  Serial.print("Capteurs trouvés : ");
  Serial.println(sensors.getDeviceCount());
}
void loop() {
  sensors.requestTemperatures();       // lance la mesure
  float t = sensors.getTempCByIndex(0);
  Serial.print(t);
  Serial.println(" °C");
  delay(1000);
}

Il s’appuie sur les bibliothèques OneWire et DallasTemperature, qui s’installent depuis le gestionnaire de bibliothèques. requestTemperatures() enchaîne reset, 0xCC et 0x44, puis attend la fin de la conversion ; getTempCByIndex(0) sélectionne le premier capteur, envoie 0xBE, lit le bloc et vérifie le CRC (figure 5.13). Le DS18B20 mesure de −55 à +125 °C, avec une précision de ±0,5 °C entre −10 et +85 °C et une résolution réglable de 9 à 12 bits. Il se câble en trois fils : GND, DQ (avec 4,7 kΩ vers le 5 V) et VDD.

Exercices

1. Les octets 0 et 1 du scratchpad valent 0x91 et 0x01. Quelle est la température ?

L’octet 1 est le poids fort : 0x0191 = 401. 401 / 16 = 25,0625 °C.

2. Pourquoi requestTemperatures() ralentit-il la boucle, et comment l’éviter ?

En résolution 12 bits, elle attend jusqu’à 750 ms la fin de la conversion. On peut appeler sensors.setWaitForConversion(false), lancer la mesure, faire autre chose, puis lire la température 750 ms plus tard avec une temporisation millis() (chapitre 4). Réduire la résolution à 9 bits ramène aussi la conversion à environ 94 ms.

✎ Signaler une erreur dans cette section

Chapitre 5 · Partie V

SPI

Le bus SPI sacrifie les adresses et les accusés de réception à la vitesse : avec quatre fils et un échange simultané dans les deux sens, il atteint plusieurs mégabits par seconde.

Chapitre 5 · Section 5.7

Le bus SPI

Le SPI (Serial Peripheral Interface), introduit par Motorola, relie un maître à des esclaves proches, sur la même carte. Il est le bus des écrans couleur, des cartes mémoire et des modules radio.

Le bus SPI : quatre fils et un fil de sélection par esclave.
Figure 5.14 – Le bus SPI : quatre fils et un fil de sélection par esclave.

5.7.1Quatre fils

Contrairement à l’I²C, qui fait passer les données dans les deux sens sur un seul fil, le SPI consacre un fil à chaque sens de transmission, un fil à l’horloge et un fil de sélection par esclave. Le maître peut ainsi émettre et recevoir en même temps, sans perdre de temps à désigner son interlocuteur par une adresse. Le bus comporte quatre signaux, en plus de la masse :

  • SCK : horloge, produite par le maître ;
  • MOSI (ou COPI) : données du maître vers l’esclave ;
  • MISO (ou CIPO) : données de l’esclave vers le maître ;
  • CS (ou SS) : sélection, active à 0. Un seul esclave est sélectionné à la fois ; les autres ignorent l’horloge et laissent MISO libre.

Il n’y a ni adresse ni accusé de réception : le protocole est simple et très rapide (figure 5.14).

CarteSCKMOSIMISOSS
Uno, NanoD13D11D12D10
Mega 2560D52D51D50D53

Attention

Laissez D10 (D53 sur la Mega) en sortie, même si le CS de l’esclave est câblé sur une autre broche : si cette broche est en entrée et passe à 0, le SPI de l’AVR bascule en mode esclave et cesse de fonctionner.

5.7.2Deux registres à décalage

Figure 5.15 interactif – L’échange SPI pas à pas : les registres du maître et de l’esclave forment un anneau et échangent leur contenu en huit fronts d’horloge.

Le maître et l’esclave contiennent chacun un registre à décalage de 8 bits. MOSI et MISO les relient en anneau : à chaque front d’horloge, chaque registre décale d’un rang, le bit qui sort de l’un entre dans l’autre. Après huit fronts, les deux octets ont été échangés (figure 5.15). Dans l’exemple de la figure, le maître envoie 0xA5 et reçoit 0x3C que l’esclave avait préparé : c’est ce que renvoie SPI.transfer(0xA5). Pour seulement lire, le maître envoie un octet sans importance, en général 0x00.

Le mode SPI fixe le niveau de repos de l’horloge (CPOL) et le front sur lequel les données sont lues (CPHA). La fiche technique de l’esclave indique son mode ; le mode 0 est le plus courant.

ModeCPOLCPHALecture
000front montant
101front descendant
210front descendant
311front montant

5.7.3Le logigramme d’un échange

Figure 5.16 interactif – Logigramme d’un échange SPI : écrire dans un 74HC595, lire un registre, esclave absent.

Au repos, CS est à 1. Le maître sélectionne l’esclave en mettant CS à 0, charge l’octet à envoyer dans le registre SPDR, produit huit fronts d’horloge, lit l’octet reçu dans SPDR, recommence pour chaque octet, puis libère l’esclave en remettant CS à 1 (figure 5.16). Par rapport à l’I²C, il n’y a ni adresse, ni START ni STOP (CS les remplace), ni ACK. Conséquence : un esclave absent n’est pas détecté. MISO reste à 1 et le maître lit 0xFF sans erreur ; c’est à l’application de vérifier la vraisemblance de la valeur reçue, par exemple l’identifiant attendu d’un capteur.

FonctionÉtape
SPI.beginTransaction(…)vitesse, ordre des bits, mode
digitalWrite(CS, LOW)sélection de l’esclave
v = SPI.transfer(octet)8 fronts, renvoie l’octet reçu
digitalWrite(CS, HIGH), SPI.endTransaction()libération

5.7.4Exemple : 8 LED avec un 74HC595

Figure 5.17 interactif – Un chenillard de huit LED commandé en SPI par un registre à décalage 74HC595.

Le 74HC595 est un registre à décalage qui transforme un octet reçu en série en huit sorties parallèles. Il se pilote naturellement en SPI : son entrée DS reçoit MOSI, son horloge SH_CP reçoit SCK, et le front montant de son entrée de verrou ST_CP recopie l’octet sur les sorties Q0 à Q7.

#include <SPI.h>
const int LATCH = 10;                  // ST_CP du 74HC595

void ecrire(byte motif) {
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  digitalWrite(LATCH, LOW);
  SPI.transfer(motif);                 // 8 bits sur MOSI
  digitalWrite(LATCH, HIGH);           // recopie vers Q0..Q7
  SPI.endTransaction();
}
void setup() {
  pinMode(LATCH, OUTPUT);
  SPI.begin();
}
void loop() {
  for (byte i = 0; i < 8; i++) {
    ecrire(1 << i);                    // une seule LED allumée
    delay(150);
  }
}
74HC595Arduino Uno
14 DS (données)D11 MOSI
11 SH_CP (horloge)D13 SCK
12 ST_CP (verrou)D10
13 OE / 10 MRGND / 5 V
Q0 à Q78 LED + 220 Ω

Pour aller plus loin

Plusieurs 74HC595 se montent en cascade, la sortie Q7′ de l’un attaquant l’entrée DS du suivant : on obtient 16, 24… sorties avec toujours trois broches. D’autres modules SPI courants : carte SD (bibliothèque SD), afficheur à LED MAX7219, radio nRF24L01.

Exercices

1. Combien de temps dure l’envoi d’un octet en SPI à 1 MHz ? Comparez avec l’UART à 115 200 bauds.

SPI : 8 fronts à 1 µs, soit 8 µs. UART à 115 200 bauds : 10 bits de 8,68 µs, soit 86,8 µs, plus de dix fois plus.

2. Modifiez loop() pour allumer les LED de Q0 à Q7 l’une après l’autre en les laissant allumées (barregraphe).
byte motif = 0;
for (byte i = 0; i < 8; i++) {
  motif |= (1 << i);    // ajoute la LED i
  ecrire(motif);
  delay(150);
}
3. Un capteur SPI renvoie toujours 0xFF. Quelle est la cause la plus probable ?

L’esclave ne répond pas : MISO reste au niveau haut. Il est mal alimenté, son CS n’est pas mis à 0 (mauvaise broche, oubli du digitalWrite), ou MISO n’est pas câblé. Le SPI n’ayant pas d’accusé de réception, seule la valeur reçue permet de le détecter.

✎ Signaler une erreur dans cette section

Chapitre 5 · Partie VI

Synthèse et évaluation

Choisir la liaison adaptée à une application, puis vérifier ses connaissances.

Chapitre 5 · Section 5.8

Choisir une liaison série

Chaque liaison a son domaine : le choix dépend de l’équipement à relier, du nombre de modules, de la distance et du débit nécessaire.

Quelle liaison pour quelle application, et les débits courants sur Arduino.
Figure 5.18 – Quelle liaison pour quelle application, et les débits courants sur Arduino.
  • UART (Serial) : dialoguer avec un PC, un module GPS ou Bluetooth, une autre carte Arduino ;
  • I²C (Wire) : plusieurs capteurs, une horloge, un écran texte sur la même carte, avec seulement deux broches ;
  • OneWire (DS18B20) : des capteurs de température éloignés, ou nombreux, sur un seul fil ;
  • SPI (SPI) : beaucoup de données, vite – écran couleur, carte SD, module radio.

Les débits courants s’étagent sur près de trois ordres de grandeur : 9 600 à 115 200 bit/s pour l’UART, 100 à 400 kbit/s pour l’I²C, jusqu’à 8 Mbit/s pour le SPI de l’AVR (figure 5.18).

✎ Signaler une erreur dans cette section

Chapitre 5 · Section 5.9

À retenir et QCM

Le tableau suivant résume les quatre liaisons. Le questionnaire de la figure 5.19 permet de vérifier que les notions du chapitre sont acquises.

LiaisonFilsFonctions clésPoint clé
UARTTX, RX, GNDSerial.begin(), print(), read()Asynchrone : même débit des deux côtés, TX vers RX
RS232TXD, RXD, GND (DB9)convertisseur MAX232Même trame que l’UART, en ±12 V et logique inversée
I²CSDA, SCL + pull-upWire.beginTransmission(), requestFrom()Adresse 7 bits, ACK, drain ouvert
OneWireDQ + pull-up 4,7 kΩOneWire, DallasTemperatureCréneaux de durée fixe, identifiant 64 bits
SPISCK, MOSI, MISO, CSSPI.transfer(), SPISettingsÉchange simultané, un CS par esclave, mode 0 à 3

Bonnes habitudes

  • Masse commune : Toujours relier les GND des équipements.
  • Niveaux : 5 V ou 3,3 V : vérifier avant de relier deux modules.
  • Pull-up : Obligatoires en I²C et OneWire, souvent déjà sur les modules.
  • Scanner : En I²C, lancer le scanner pour connaître l’adresse réelle.

5.9.1Se tester

Le QCM comporte vingt-cinq questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. En fin de questionnaire, chaque question manquée renvoie à la section qui donne les explications.

Figure 5.19 interactif – QCM d’évaluation du chapitre 5.

✎ Signaler une erreur dans cette section

Chapitre 5 · Section 5.10

Sources et références

Les spécifications des bus, les fiches techniques des composants et la documentation des bibliothèques Arduino permettent d’aller plus loin.

Référence Arduino

Fiches techniques et notes d’application

  • Analog Devices (Maxim), DS18B20 Programmable Resolution 1-Wire Digital Thermometer.
  • Maxim, Application Note 74 : lecture et écriture des iButtons, durées des créneaux 1-Wire.digitemp.com/docs/app74.pdf
  • NXP, UM10204 – I²C-bus specification and user manual.
  • Texas Instruments, MAX232 et SN74HC595.

Pour aller plus loin

✎ Signaler une erreur dans cette section