Communication par nRF24L01 entre deux MSP430 Launchpads

Puisque ma dernière utilisation d'un MSP430 Launchpad date de bien longtemps, et que ma dernière utilisation d'un module émetteur-récepteur nRF24L01 date d'encore plus longtemps encore, ce petit tuto portera sur la communication entre deux MSP430 Launchpads au moyen de modules nRF24L01, en utilisant l'IDE Energia.

Matériel:

Il vous faut deux cartes MSP430 Launchpad et deux modules nRF24L01.  Lors des tests décrits ici, chaque Launchpad était branché par USB à son propre ordinateur (qui se trouvaient dans la même maison, mais pas sur le même étage).

La bibliothèque Enrf24

La bibliothèque Enrf24, developpée par Spirilis, est d'une étonnante simplicité d'utilisation.  Notre première étape consiste donc à télécharger et installer cette bibliothèque.

Branchements du module nRF24L01 au MSP430 Launchpad

Je connais deux modèles différents de modules nRF24L01:  les modules verts, comportant 10 connecteurs clairement identifiés, et les modules noirs, comportant 8 connecteurs qui ne sont pas du tout identifiés!

La photo ci-contre devrait vous aider à identifer correctement les connections, surtout si vous utilisez le modèle noir.

Les modules nRF24L01 communiquent par le protocole SPI, à un niveau logique de 3,3 V, tout comme les cartes Launchpad.  Nous n'aurons donc pas à nous préoccuper de convertir le niveau logique comme nous l'aurions fait avec une carte Arduino fonctionnant sous 5 V:  un problème de moins.

Notez que le schéma ci-dessous est pour le modèle d'entrée de gamme MSP-EXP430G2.  Si vous utilisez une autre carte de la famille Launchpad, il se peut que les pins réservées à la communication SPI soient différentes (je sais que les pins MOSI et MISO sont parfois inversées).  Dans le doute, vous pouvez vous référer aux schémas de brochage publiés sur le site d'Energia.

Les connexions sont les suivantes:

GND du nRF24L01 --- GND du Launchpad
Vcc du nRF24L01 --- Vcc du Launchpad
SCK du nRF24L01 --- P1.5 du Launchpad
MOSI du nRF24L01 --- P1.7 du Launchpad
MISO du nRF24L01 --- P1.6 du Launchpad
CE du nRF24L01 --- P2.0 du Launchpad*
CSN du nRF24L01 --- P2.1 du Launchpad*
IRQ du nRF24L01 --- P2.2 du Launchpad*

* Nous spécifions les pins CE, CSN et IRQ dans le sketch.  Il est donc possible de les brancher ailleurs à la condition de modifier le sketch en conséquence.

Les connexions sont identiques pour les deux Launchpad, peu importe qu'il s'agisse de l'émetteur ou du récepteur (notez bien que chaque module nRF24L01 peut à la fois envoyer et recevoir des données).

Une première paire de sketches

Dans ce premier exemple, notre Launchpad émetteur va émettre des nombres entier croissant au rythme de 1 par seconde, alors que le Launchpad émetteur va afficher ce qu'il reçoit dans le moniteur série.

Cette paire de sketch est particulièrement utile pour effectuer un premier test.  D'une part, il ne nécessite aucun composant supplémentaire dans notre circuit et, d'autre part, puisque chaque message est numéroté, nous aurons la preuve que tous les messages émis sont bel et bien reçus.

Sketch de l'émetteur:

	/***********************************************************************
	Compteur - Émetteur
	Sketch pour émission d'un message avec un module NRF24L01 branché à
	un MSP430 Launchpad.
	À chaque seconde, l'émetteur envoie un nombre entier, dont la valeur
	augmente d'une unité à chaque envoi.
	http://electroniqueamateur.blogspot.ca/2017/02/communication-par-nrf24l01-entre-deux_6.html
	************************************************************************/
	// Quelques bibliothèques sont nécessaires...
	#include <SPI.h>
	#include <Enrf24.h>
	#include <nRF24L01.h>
	#include <string.h>
	Enrf24 radio(P2_0, P2_1, P2_2); // P2.0 = CE, P2.1 = CSN, P2.2 = IRQ
	const uint8_t txaddr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x01 };
	char message[33]; // le message qui sera envoyé par le nRF24L01
	int nombre = 0; // la valeur qui augmentera d'une unité à chaque transmission
	void setup() {
	Serial.begin(9600); // pour faciliter le débogage
	SPI.begin();
	SPI.setDataMode(SPI_MODE0);
	SPI.setBitOrder(MSBFIRST);
	radio.begin();
	radio.setTXaddress((void*)txaddr);
	delay(100);
	Serial.println("Pret a envoyer les donnees");
	}
	void loop() {
	nombre++;
	// Conversion du int en tableau de chars
	itoa(nombre, message, 10); // 10 car décimal
	// Affichage au moniteur série (pour débogage):
	Serial.print("Envoi du message: ");
	Serial.println(message);
	// envoi du message:
	radio.print(message);
	radio.flush();
	// on se repose un peu...
	delay(1000);
	}

view raw compteur_emetteur.ino hosted with ❤ by GitHub

Sketch du récepteur:

	/*************************************************************************
	* Compteur - Récepteur
	*
	* Sketch pour réception d'un message avec un module NRF24L01 branché à
	* un MSP430 Launchpad.
	* Ce sketch dand le moniteur série le message qui a été reçu par le nRF24L01
	*
	* http://electroniqueamateur.blogspot.ca/2017/02/communication-par-nrf24l01-entre-deux_6.html
	**************************************************************************/
	// Inclusion des bibliothèquees nécessaires:
	#include <SPI.h>
	#include <Enrf24.h>
	#include <nRF24L01.h>
	#include <string.h>
	Enrf24 radio(P2_0, P2_1, P2_2); // P2.0 = CE, P2.1 = CSN, P2.2 = IRQ
	const uint8_t rxaddr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x01 };
	void setup() {
	Serial.begin(9600);
	SPI.begin();
	SPI.setDataMode(SPI_MODE0);
	SPI.setBitOrder(MSBFIRST);
	radio.begin();
	radio.setRXaddress((void*)rxaddr);
	radio.enableRX(); // Début de la réception
	delay(100);
	Serial.println("Pret a recevoir les donnees");
	}
	void loop() {
	char message[33];
	while (!radio.available(true))
	;
	if (radio.read(message)) {
	Serial.print("Message recu: ");
	Serial.println(message);
	}
	}

view raw compteur_recepteur.ino hosted with ❤ by GitHub

Si tout fonctionne correctement, vous devriez voir une liste de messages numérotés en ordre croissant dans le moniteur série d'Energia (associé au récepteur).

Un deuxième exemple

Dans ce deuxième exemple, un bouton relié au Launchpad émetteur permettra de contrôler l'état de deux LEDs branchées au Launchpad récepteur.

Le Launchpad émetteur est donc muni d'un bouton poussoir associé à une résistance de tirage (pull-down) de 10 kΩ.  (J'ai aussi ajouté un condensateur de 100 nF en parallèle avec le bouton afin d'atténuer les rebonds; il est optionnel).  Le bouton est branché à la broche P1.0.

Le Launchpad récepteur, quant à lui, est relié à deux LEDs associées à une résistance de protection.  Au début, j'avais envisagé d'utiliser simplement les deux LEDs intégrées à la carte, mais l'une d'entre elles est associée à la pin P1.6, qui est déjà utilisée par notre module nRF24L01.  Une première LED est branchée à la broche P1.0, alors que l'autre est branchée à la broche 1.4.

Circuit de l'émetteur

Circuit du récepteur

Sketch de l'émetteur

	/***********************************************************************
	Émetteur - Bouton
	Sketch pour émission d'un message avec un module nRF24L01 branché à
	un MSP430 Launchpad.
	Les messages 1, 2 , 3 et 4 sont successivement envoyés lorsqu'on
	appuie sur un bouton poussoir branché à la pin P1.0
	http://electroniqueamateur.blogspot.ca/2017/02/communication-par-nrf24l01-entre-deux_6.html
	**************************************************************************/
	// Inclusion des bibliothèques nécessaires:
	#include <SPI.h>
	#include <Enrf24.h>
	#include <nRF24L01.h>
	#include <string.h>
	// Bouton branché à la pin P1_0
	#define pinBouton P1_0
	int compteur = 0; // augmente de 1 chaque fois qu'on appuie sur le bouton
	int bouton = 0; // état précédent du bouton
	Enrf24 radio(P2_0, P2_1, P2_2); // P2.0=CE, P2.1=CSN, P2.2=IRQ
	const uint8_t txaddr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x01 };
	char message[33]; // message envoyé par le nRF24L01
	void setup() {
	Serial.begin(9600); // pour faciliter le débogage
	SPI.begin();
	SPI.setDataMode(SPI_MODE0);
	SPI.setBitOrder(MSBFIRST);
	radio.begin();
	radio.setTXaddress((void*)txaddr);
	delay(100);
	Serial.println("Pret a envoyer les donnees.");
	}
	void loop() {
	if (digitalRead(pinBouton)) { // bouton enfoncé
	if (!bouton) { // il ne l'était pas auparavant
	compteur = compteur + 1;
	if (compteur > 4) {
	compteur = 1;
	}
	// Conversion du int en chaîne de caractères
	itoa(compteur, message, 10); // 10 car décimal
	Serial.print("Envoi du message: ");
	Serial.println(message);
	radio.print(message);
	radio.flush();
	bouton = 1;
	}
	}
	else {
	bouton = 0;
	}
	}

view raw emetteur_bouton.ino hosted with ❤ by GitHub

Sketch du récepteur

	/***********************************************************************
	Récepteur - LEDs
	Sketch pour réception d'un message avec un module nRF24L01 branché à
	un MSP430 Launchpad.
	L'état de deux LEDs (branchées respectivement aux pins P1_0 et P1_4)
	dépend du contenu du message reçu.
	http://electroniqueamateur.blogspot.ca/2017/02/communication-par-nrf24l01-entre-deux_6.html
	**************************************************************************/
	#include <SPI.h>
	#include <Enrf24.h>
	#include <nRF24L01.h>
	#include <string.h>
	Enrf24 radio(P2_0, P2_1, P2_2);
	const uint8_t rxaddr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0x01 };
	void setup() {
	Serial.begin(9600);
	SPI.begin();
	SPI.setDataMode(SPI_MODE0);
	SPI.setBitOrder(MSBFIRST);
	radio.begin();
	radio.setRXaddress((void*)rxaddr);
	pinMode(P1_0, OUTPUT); // LED 1
	pinMode(P1_4, OUTPUT); // LED 2
	radio.enableRX();
	Serial.println("Pret a recevoir les messages");
	}
	void loop() {
	char message[33];
	int valeur;
	while (!radio.available(true))
	;
	if (radio.read(message)) {
	Serial.print("Message recu: ");
	Serial.println(message);
	// conversion de la chaîne de caractères en nombre entier:
	valeur = atoi(message);
	// l'état des 2 LEDs dépend du message reçu:
	if (valeur == 1) {
	digitalWrite(P1_0, HIGH);
	digitalWrite(P1_4, LOW);
	}
	if (valeur == 2) {
	digitalWrite(P1_0, LOW);
	digitalWrite(P1_4, HIGH);
	}
	if (valeur == 3) {
	digitalWrite(P1_0, HIGH);
	digitalWrite(P1_4, HIGH);
	}
	if (valeur == 4) {
	digitalWrite(P1_0, LOW);
	digitalWrite(P1_4, LOW);
	}
	}
	}

view raw recepteur_LEDs.ino hosted with ❤ by GitHub

Lorsqu'on appuie sur le bouton une première fois, le message "1" est envoyé et une des LEDs branchée au récepteur s'allume.

Un deuxième appuie sur le bouton (message "2"):  c'est l'autre LED qui s'allume.

Troisième appui sur le bouotn (message "3"):  les deux LEDs sont allumées.

Quatrième appui sur le bouton (message "4"): les deux LEDs sont éteintes.


(Source d'inspiration:  une discussion concernant la bibliothèque Enrf24, sur le forum 43oh.)


Yves Pelletier   (Twitter, Facebook)