Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
TP5 – Transmission de données
Il existe plusieurs façons de transmettre des données avec Arduino. Les acronymes comme UART,
SPI, I2C… sont tous des protocoles supportés par Arduino. Dans cette séance, le mystère de tous ces
acronymes sera levé. Ensuite des applications à base de ces protocoles seront réalisées.
A. La transmission UART
Toutes les cartes Arduino disposent d’au moins d’un port série. Pour l’Arduino UNO, ses ports UART
se trouvent aux broches numériques pin 0 (RX0) et pin 1 (TX0).
La carte Arduino UNO ne disposant qu’une seule interface physique pour la communication série, par
conséquent ses possibilités de communication demeurent très limitées. La bibliothèque SoftwareSerial
a pour rôle de créer des interfaces série logiciel avec les mêmes possibilités que celles physiques.
1. Echange de données entre deux cartes Ardunio
Pour faire communiquer deux cartes Arduino en mode UART, vous devez réaliser le montage ci-dessous
où l’une des cartes sera considérée comme émetteur et l’autre comme récepteur.
L’émetteur devra envoyer toutes les 2 secondes le message "ping" et le récepteur devra l’afficher.
Modifier le programme au niveau des deux cartes afin que la seconde renvoie le message "pong"
lorsqu’il reçoit le message "ping".
Bout de code montrant l’utilisation de la bibliothèque SoftwareSerial
(1) Paramétrage
#include <SoftwareSerial.h>
// Créer un nouveau objet SoftwareSerial nommé mySerial
SoftwareSerial mySerial(10, 11); // pin10 -> RX, pin11 ->TX
(2) Initialisation dans la fonction setup()
// Initialisation débit transmission à 9600 bauds
[Link](9600);
(3) Envoi et réception de messages texte dans la fonction loop()
// Envoyer un message texte
[Link]("ping");
// Vérifier si des données sont disponibles puis lire le message texte
if ([Link]()) {
String msg = [Link]();
}
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
2. Commander des LED à partir d’une autre carte Arduino
Réaliser un montage avec deux boutons poussoir sur une première carte Arduino. Dans la seconde carte
Arduino réaliser cette fois ci un montage avec deux LED rouge et verte. Relier les interfaces UART
logicielles des deux cartes.
Ecrire un programme capable d’allumer la LED verte ou rouge selon le bouton appuyé sur l’autre carte.
Bout de code Arduino
(4) Envoi et réception de données numériques dans la fonction loop()
// Envoyer une donnée numérique
[Link](1);
// Vérifier si des données sont disponibles puis lire le nombre
if ([Link]()) {
int nombre = [Link]();
}
B. La transmission SPI
La carte Arduino UNO supporte la liaison SPI et sa programmation se fait via une bibliothèque SPI.
Pour l’UNO on peut utiliser les broches 11 (MOSI), 12 (MISO), 13 (SCK) et 10 (SS).
La bibliothèque SPI permet de communiquer avec des périphériques SPI, la carte Arduino étant toujours
configurée en tant que composant maître.
• Pratique
Relier deux cartes Arduino via leur interfaces SPI. L’une des cartes sera considérée comme le maitre et
l’autre comme l’esclave. Ecrire un programme qui permet au mestre d’envoyer le message "ping" à
l’esclave ; et un autre programme qui permet à l’esclave de lire les messages qui lui sont envoyés.
Programme du maitre
#include <SPI.h>
char str[] = "ping";
void setup() {
[Link](9600);
[Link]();
[Link](SPI_CLOCK_DIV8); // Freq CLK (16MHz/8=2MHz)
[Link]("Master");
}
void loop (void) {
digitalWrite(SS, LOW); // Activer l'interface SS
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
// Envoyer le message
for(int i=0; i<sizeof(str); i++){
[Link](str[i]);
digitalWrite(SS, HIGH); // Désactiver l'interface SS
}
delay(2000);
}
Programme de l’esclave
#include <SPI.h>
char str[50];
volatile byte i;
volatile bool pin;
void setup(){
[Link] (9600);
[Link]("Slave");
pinMode(MISO, OUTPUT);
SPCR |= _BV(SPE); // turn on SPI in slave mode
i = 0;
pin = false;
[Link]();
}
void loop(){
static int count;
if (pin) {
pin = false; //reset the pin
if(count++ < 5){
[Link](count);
[Link](" : ");
[Link](str);
if(count==5) {
delay(1000);
[Link]("The end data");
}
}
delay(1000);
i= 0; //reset button to zero
}
}
// Interrupt function
ISR(SPI_STC_vect) {
// read byte from SPI Data Register
char c = SPDR;
if (i < sizeof(str)) {
str[i++] = c;
// Check for the end of the word
if ( (c == '\r') || (c == '\n') || (c=='\0') )
pin = true;
}
}
C. La transmission I2C
La carte Arduino UNO possède une liaison I2C (SDA : broche analogique A4 et SCL : broche
analogique A5) et une bibliothèque Wire permet de gérer les échanges d'informations entre la carte
Arduino et les circuits I2C connectés. Cette bibliothèque est installée de base dans l'IDE Arduino.
Le protocole I2C est une méthode qui permet de connecter plusieurs cartes Maîtres et plusieurs cartes
Esclaves et de faire communiquer jusqu’à 128 à courtes distances. Il peut être pratique, notamment dans
des projets de domotique, de communiquer entre plusieurs appareils.
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
• Pratique
Ecrire un programme qui permet au maitre de sélectionner un esclave puis de l’envoyer une requête puis
des données.
Ecrire aussi un autre programme permettant à l’esclave de répondre aux requêtes et aussi de lire les
données qui lui sont envoyées.
Programme du maitre
#include <Wire.h>
#define SLAVE1_ADDRESS 11
#define PAYLOAD_SIZE 4
void setup() {
[Link]();
[Link](9600);
[Link]("Master");
}
void loop() {
// Envoyer une requête à l'esclave
[Link](SLAVE1_ADDRESS, PAYLOAD_SIZE);
if([Link]() == PAYLOAD_SIZE){
int data = [Link]();
[Link]("Recieved value : ");
[Link](data);
}
delay(1000);
// Envoyer des données (ex: 12) à l'esclave
[Link](SLAVE1_ADDRESS);
[Link](12);
[Link]("Sending value : ");
[Link](12);
[Link]();
delay(1000);
}
Programme de l’esclave
#include <Wire.h>
#define SLAVE_ADDRESS 11
#define PAYLOAD_SIZE 4
void setup()
{
[Link](SLAVE_ADDRESS);
[Link](9600);
[Link]("Slave 1");
delay(1000);
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
[Link](requestEvents);
[Link](receiveEvents);
}
void loop(){
}
void requestEvents()
{
[Link]("Recieved request");
int value = 27;
// Sending value
[Link](value);
}
void receiveEvents(int numBytes)
{
[Link]("Received (bytes) : ");
[Link](numBytes);
int data = [Link]();
[Link]("Data : ");
[Link](data);
}
Scanner I2C
Un bon test pour savoir si vos appareils communiquent bien entre eux est d’utiliser scanner qui retourne
les adresses de tous les périphériques (esclaves) présents sur le réseau I2C.
Ajouter deux autres esclaves avec des adresses différentes dans le réseau I2C puis tester sur la carte
master ce programme de scan de périphériques I2C (esclaves).
#include <Wire.h>
void setup() {
[Link]();
[Link](9600);
[Link]("Master");
}
void loop() {
byte error, address;
int nDevices = 0;
[Link]("Scanning...");
for (address = 1; address < 127; address++) {
[Link](address);
error = [Link]();
if (error == 0) {
[Link]("I2C device found at address 0x");
printHex(address);
nDevices++;
}
else if (error == 4) {
[Link]("Unknown error at address 0x");
printHex(address);
}
}
if (nDevices == 0){
[Link]("No I2C devices found");
}
else{
[Link]("Done!");
}
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
delay(5000);
}
void printHex(int number) {
[Link](number < 16 ? " 0" : " ");
[Link](number, HEX);
}
D. Application UART : envoi de SMS avec un modem GSM
Un modem GSM est un modem sans fil fonctionnant sur le réseau GSM. Les commandes AT
permettent la gestion complète du modem (vérifier et changer les réglages du modem, envoie
et réception d’appel et SMS…). Ces commandes sont définies dans la norme GSM 07.07. Les
deux AT (ATtention) sont toujours présents pour commencer une ligne de commande sous
forme de texte et doivent se terminer par un retour chariot (en ASCII : 0x0D).
Commande AT Description
ATI Information sur le modem (fabriquant, model, IMEI…)
ATE0 Désactiver le mode echo
ATE1 Activer le mode echo
AT+CMGF Sélectionner le format du message
AT+CMGS Envoyer un SMS
AT+CMGR Lire un SMS
AT+CSCA Sélection de l’adresse du SMSC (programmé par l’opérateur)
AT+CPIN Saisie du code PIN (utile si la carte SIM est verrouillée)
Les étapes d’envoi d’un SMS en commandes AT
L’envoi de SMS via un microcontrôleur se résume simplement par l’envoie de commandes AT
via l’interface USART. Le processus s’effectue comme suit :
AT
Le rôle de cette commande est de tester le microcontrôleur et d’attendre la réponse du modem
qui doit être : "OK".
ATE0
Cette commande désactive l’echo du modem GSM de sorte que les caractères tapés par
l'utilisateur ne soient pas renvoyés par le modem.
AT+CMGF=1
Sélection du format des messages : 0 (mode PDU, caractères hexadécimal), 1 (mode Texte,
alphanumériques).
AT+CMGS="77xxxxxxxx" + message texte
Cette commande sert à préciser le numéro de téléphone du destinataire (ici 77xxxxxxx) suivi
du message à envoyer. Lorsque le modem reçoit la commande AT+CMGS="77xxxxxxx ", il
répond avec le caractère ">" qui est synonyme que le message peur être saisi. L’envoie du
message se fait en appuyant sur CTRL+Z (en ASCII : 0x1A).
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
Le module SIM800L v2
Le module GSM/GPRS SIM800L V2.0 est un module GSM/GPRS QUAD-BANDE compatible avec
Arduino. Les avantages de ces modules sont les niveaux série VCC et TTL qui ont une tension de 5V.
• Pratique
Ecrire un programme capable d’envoyer le message "Bonjour le monde !" par SMS.
Ensuite, brancher un capteur de fumée MQ2 sur la carte Arduino et modifier le programme afin
d’envoyer une alerte SMS en cas de détection de fumée.
E. Application SPI : RFID
RFID est l’acronyme de Radio Frequency Identification, ce qui donne en français « identification par
radiofréquence ». C’est une technologie utilisant les ondes radio haute fréquence pour transmettre et
mémoriser des données dans le but d’identifier de manière unique les objets, les animaux ou les
personnes. La RFID a déjà fait ses preuves et permettant d’apporter de nombreuses solutions pour les
entreprises : paiement sans contact, gestion des actifs, protection des actifs…
Comment fonctionne la technologie RFID ?
Chaque système RFID est composé de trois éléments :
̶ Une antenne de balayage,
̶ Un émetteur-récepteur
̶ Un transpondeur (le RFID) : contient un identifiant unique appelé UID
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
L’antenne de balayage et l’émetteur-récepteur forment le lecteur RFID, ou interrogateur RFID. Celui-
ci peut être fixe ou mobile et connecté au réseau de communication. Le transpondeur (étiquette ou tag)
est représenté par la puce RFID et s’active grâce à l’énergie dégagée par les ondes radio qu’émet le
lecteur. Ce dernier interroge le transpondeur qui, à son tour, renvoie les données réclamées.
Le module RFID MFRC522
Le module MFRC522 est un circuit intégré de lecture/écriture hautement intégré pour la communication
sans contact à 13,56MHz. Le récepteur fourni une implémentation robuste et efficace de démodulation
et décodage du signal selon la norme ISO/IEC 14443A/MIFARE. Le MFRC522 supporte les
communications sans contact utilisant le système de transfert haut débit MIFARE à 848 kbit/s en flux
montant et descendant. Le protocole SPI est utilisé comme interface de communication du module.
Installer la bibliothèque MFRC522 de GithubCommunity
La bibliothèque MFRC522 est développée et maintenue par GithubCommunity. Elle permet de lire ou
d’écrire sur une carte ou un tag RFID en utilisant l'interface ISO/IEC 14443A/MIFARE.
• Pratique
Ecrire un programme capable de lire l’UID d’une étiquette RFID puis de l’afficher.
Implémentation d’une application domotique
L’application à mettre en place permettra de pouvoir identifier les utilisateurs en fonction des cartes
RFID présentées. Ainsi :
Si la carte RFID est reconnue, c’est-à-dire son UID correspond à celui que vous avez relevé
précédemment :
̶ Allumer une LED verte
̶ Allumer une lampe (LED blanche)
̶ Ouvrir la porte (rotation d’un servomoteur à 90°)
Si une carte RFID n’est pas reconnue :
̶ Allumer une LED rouge
̶ Activer le buzzer
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
NB : attention le module fonctionne avec une tension de 3,3V.
Programme lecture UID
Après avoir téléversé le programme, mettre à proximité du lecteur une carte RFID puis relever l’UID
affiché sur le moniteur série.
#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
byte nuidPICC[4];
MFRC522 rfid(SS_PIN, RST_PIN);
void setup() {
[Link](9600);
// Initialisation
[Link]();
rfid.PCD_Init();
[Link]("Scan RFID NUID...");
}
void loop(){
readRFID();
delay(200);
}
void readRFID()
{
// Recherche d'une nouvelle carte
if (!rfid.PICC_IsNewCardPresent()){
return;
}
// Véfifier si le NUID est lu
if (!rfid.PICC_ReadCardSerial()){
return;
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
Arduino TP5 – Transmission de données | Dr Ousmane SADIO
_______________________________________________________________________________________________________________
}
if([Link][0] != nuidPICC[0] ||
[Link][1] != nuidPICC[1] ||
[Link][2] != nuidPICC[2] ||
[Link][3] != nuidPICC[3] ) {
[Link](F("Nouvelle carte detectee."));
// Stocker le NUID dans le tableau nuidPICC
for (byte i = 0; i < 4; i++) {
nuidPICC[i] = [Link][i];
}
[Link](F("RFID UID: "));
printDec([Link], [Link]);
[Link]();
}
//Mettre en halte le tag
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();
}
void printDec(byte *buffer, byte bufferSize) {
for (byte i = 0; i < bufferSize; i++) {
[Link](buffer[i] < 0x10 ? " 0" : " ");
[Link](buffer[i], DEC);
}
}
F. Application I2C : collecte de données de capteurs
Réaliser un réseau I2C avec trois cartes Arduino. Une carte servira de maitre (collecteur), une carte
esclave avec comme adresse 11 servira à mesurer la température avec DHT11, une autre carte esclave
avec comme adresse 12 servira à mesurer la luminosité.
Ecrire un programme sur le master servant collecter les données de capteurs. Il faudra créer un tableau
contenant l’adresse de l’ensemble des esclaves puis le parcourir afin d’envoyer des requêtes aux
esclaves.
______________________________________________________________________________
UVS 2021 – 2022 | Licence 2 Robotique
