Composants utilisés
- 2x Modules de transmission Nrf24L01 (sur 2.4 GHz, vendus par paire)
- 2x cartes Arduino Uno
- Câbles de branchements mâle/femelle Dupont
- 2 plaquettes d'essais (prototype shield pour Arduino)
- 2 x 4 résistances de 10 kΩ
Principe de fonctionnement
Les modules nRF24L01 sont des émetteurs / récepteurs qui utilisent la bande de fréquence 2.4 Ghz comme le radio modélisme, d'utilisation libre sans licence. Ils comportent une antenne intégrée.
Le protocole de transmission ShockBurst permet de garantir une transmission fiable sans s'occuper des détails.
Une modulation GFSK avec 125 canaux, des sauts de fréquence, couplés à un dispositif intégré de détection d'erreur CRC, un adressage des messages,... permettent un anti-parasitage très efficace.
Transmission
La vitesse de fonctionnement maximale est de 2 Mbps, avec une faible consommation électrique.
La distance de transmission est relativement élevée et permet le pilotage de robots, la transmission à distance de données (alarmes, mesures de capteurs de station météo, jeux, jouets, périphériques d'ordinateurs...).
Le module avec antenne incorporée (visible en zigzag sur le circuit) peut transmettre à environ 100 mètres (transmission 1 mW), en terrain dégagé et avec une transmission sur 250 KHz.
Augmenter la vitesse réduit la portée de transmission.
Pour de la plus longue portée (1 km) il existe des module analogues mais amplifiés et avec une plus grande antenne supplémentaire à brancher dessus.
Les modules sont identiques et vendus par paires. Les échanges de données entre modules sont bi-directionnels.
Branchements
Les modules fonctionnent en 3.3V, les entrées tolèrent 5V. J'ai ici monté des résistances de 10 kΩ en série pour adapter les niveaux.
Câblage du module, 8 broches --> Carte Arduino
Schéma vu de dessous et photo vue de dessus :
.
1 GND --> masse marron
2 VCC --> 3.3V (et pas 5V !) rouge
3 CE (Pin controls RX / TX) --> résistance 10 kΩ --> digital pin8 vert
4 CSN (Chip select) --> résistance 10 kΩ --> digital pin7 bleu
5 SCK --> résistance 10 kΩ --> digital pin13 blanc
6 MOSI --> résistance 10 kΩ --> digital pin11 noir
7 MISO --> digital pin12 jaune
8 IRQ --> non utilisé orange
Sur une carte Arduino Uno, rappelons le brochage :
MISO -> pin12
MOSI -> pin11
SCK -> pin13
Programmation
Télécharger et installer la librairie MIRF
http://playground.arduino.cc/Interfacin ... e/Nrf24L01
et la librairie RF24 ici
https://github.com/maniacbug/RF24
Installer tous ces deux fichiers RF24.cpp et RF24.h
dans un nouveau dossier librairies/RF24.
https://github.com/maniacbug/RF24/blob/master/RF24.cpp
https://github.com/maniacbug/RF24/blob/master/RF24.h
https://github.com/maniacbug/RF24/blob/ ... nRF24L01.h
printf.h
Exemple de fonctionnement
On utilise 2 modules en ping (émetteur) / pong (récepteur), identiques et avec exactement le même montage.
Le premier module envoie un message (codé ici sur 4 octets, qui sont aléatoires dans cet exemple) au second module, qui lui renvoie ensuite la valeur reçue.
Le premier module compare ce qu'il a envoyé avec le message de retour pour s'assurer de la bonne transmission du message.
Le client (module 1)
- Code: Tout sélectionner
//=== exemple de code CLIENT nRF24L01
// communication 2.4 Ghz bi directionnelle
// avec vérification de message bien reçu
//
// tiptopboards.com 25 08 2013
// Adaptation d'après skyduino
//=============================================
#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>
void setup(){
Serial.begin(9600);
Mirf.cePin = 8; // CE sur D8
Mirf.csnPin = 7; // CSN sur D7
Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
Mirf.init(); // Tout est bon ? Ok
Mirf.channel = 0; // On va utiliser le canal 0 pour communiquer (128 canaux disponible, de 0 à 127)
Mirf.payload = sizeof(unsigned long); // = 4, ici il faut déclarer la taille du "payload" soit du message qu'on va transmettre, au max 32 octets
Mirf.config(); // Tout est bon ? Ok let's go !
Mirf.setTADDR((byte *)"nrf02"); // Le 1er module va envoyer ses info au 2eme module
Mirf.setRADDR((byte *)"nrf01"); // On définit ici l'adresse du 1er module
Serial.println("Client");
}
void loop(){
byte data_envoi[Mirf.payload]; // Tableau de 4 octets qui va stocker le message à envoyer
byte data_retour[Mirf.payload]; // Tableau de 4 octets qui va stocker le message recu
data_envoi[0]=random(125); //Data à envoyer
data_envoi[1]=random(125);
data_envoi[2]=random(125);
data_envoi[3]=random(125);
Mirf.send(data_envoi); // Envoi des 4 octets
while(Mirf.isSending()); // On attend tant que le message n'a pas été envoyé
Serial.print("Envoi ");
afficher_4_octets(data_envoi);
delay(1); //breve attente (sinon ne passe pas !)
Mirf.getData(data_retour); // on récupère le message retourné
Serial.print("Retour ");
afficher_4_octets(data_retour);
Serial.print(" ");
//Comparer les deux
int ok = comparer_4_octets(data_envoi, data_retour);
Serial.print (ok);
Serial.println(" erreurs");
//delay(5); //Paquet suivant
}
//Fonction affichage de contrôle
void afficher_4_octets(byte data[4])
{
for (int i=0;i<4;i++)
{Serial.print(data[i]);
Serial.print(" ");
}
}
//Fonction de validation aller-retour
int comparer_4_octets(byte aller[4], byte retour[4])
{
unsigned long entree = aller[0]+aller[1]*256+aller[2]*65536+aller[3]*16777216;
unsigned long sortie = retour[0]+retour[1]*256+retour[2]*65536+retour[3]*16777216;
//Serial.print(entree);
//Serial.print(" et ");
//Serial.println(sortie);
if (entree==sortie) { return 0;} //pas de décalage
else {return 1;} //1 erreur
}
Le serveur (module 2)
- Code: Tout sélectionner
//=== exemple de code SERVEUR nRF24L01
// communication 2.4 Ghz bi directionnelle
// avec vérification de message bien reçu
//
// tiptopboards.com 25 08 2013
// Adaptation d'après skyduino
f//=======================================
#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>
void setup(){
Serial.begin(9600);
Mirf.cePin = 8; // CE sur D8
Mirf.csnPin = 7; // CSN sur D7
Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
Mirf.init(); // Tout est bon ? Ok let's go !
Mirf.channel = 0; // On va utiliser le canal 0 pour communiquer (128 canaux disponible, de 0 à 127)
Mirf.payload = sizeof(unsigned long); // = 4, ici il faut déclarer la taille du "payload" soit du message qu'on va transmettre, au max 32 octets
Mirf.config(); // Tout est bon ? Ok let's go !
Mirf.setTADDR((byte *)"nrf01"); // Le 2eme module va envoyer ses info au 1er module
Mirf.setRADDR((byte *)"nrf02"); // On définit ici l'adresse du 2eme module
Serial.println("Serveur");
}
void loop(){
byte data_recu[Mirf.payload]; // Tableau de byte qui va stocker le message recu
if(!Mirf.isSending() && Mirf.dataReady())
{ // Si un message a été recu et qu'un autre n'est pas en cours d'emission
Serial.print("Recu ");
Mirf.getData(data_recu); // on récupère le message
//Affichage de contrôle
afficher_4_octets(data_recu);
//Serial.print(" ");
Mirf.send(data_recu); // Et on le renvoie tel quel
Serial.println("Renvoye");
}
}
//Fonction affichage de contrôle
void afficher_4_octets(byte data[4])
{
for (int i=0;i<4;i++)
{Serial.print(data[i]);
Serial.print(" ");
}
}
http://arduino-info.wikispaces.com/nRF2 ... 4-Examples
Dans le code, on définit les broches de transmission, la taille des messages (32 octets max), puis on choisit un canal de transmission (0-127) et un "sous canal" grâce aux adresses (sur 5 octets) attribuées aux modules qui doivent communiquer entre eux.
Il y a donc un nombre considérable de combinaisons qui permet d'éviter tout brouillage entre réseaux proches.
Références
Un bon tutoriel sur Skyduino pour mesurer la durée de transmission (en français)
http://skyduino.wordpress.com/2012/01/2 ... -nrf24l01/
Le playground Arduino Nrf24L01 avec la librairie MIRF
http://playground.arduino.cc/Interfacin ... e/Nrf24L01
ou ici la bibliothèque MIRF
https://github.com/aaronds/arduino-nrf24l01
Tutoriel avec la librairie RF24 (en anglais)
http://arduino-info.wikispaces.com/Nrf2 ... 4GHz-HowTo
http://arduino-info.wikispaces.com/nRF2 ... 4-Examples
Datasheet de la puce nRF24L01
http://www.nordicsemi.com/eng/Products/ ... /nRF24L01P
http://yourduino.com/docs/nRF24L01_Prod ... 2_0%20.pdf