Lors de mes premiers essais de transmission radio je ne transmettais qu’une variable à savoir la valeur du potentiomètre.

Pour la télécommande finale il me faut transmettre aussi l’arrêt d’urgence et la commande de l’éclairage. J’ai une petit peu galéré à comprendre comment il fallait faire pour transmettre plusieurs variables, je vais donc essayer de fournir une explication dans cet article.

Transmission d’une seule variable :

Dans le code de l’émetteur il faut commencer par déclarer la librairie:

#include "NRFLite.h"

Puis déclarer les variables et les constantes:

const static uint8_t RADIO_ID = 1;             // Identifiant de l'émetteur
const static uint8_t DESTINATION_RADIO_ID = 0; // Identifiant du récepteur
const static uint8_t PIN_RADIO_CE = 9;   // pin de connexion module RF
const static uint8_t PIN_RADIO_CSN = 10; // pin de connecxion module RF

NRFLite _radio;

int valeur = 0; // variable ou on stock la valeur du potentiometre

Dans le void setup () qui n’est exécuté qu’une fois on initialise la communication radio et on vérifie que l’arduino peut communiquer avec le module nRF24L01, si ce n’est pas le cas alors on affiche un message dans la console.

   if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
    {
        Serial.println("Cannot communicate with radio");
        while (1);
    }

Le premier paramètre du radio.init : RADIO_ID correspond à “l’adresse” de l’émetteur, les 2 suivants aux pins de communication entre le module et l’arduino

Dans la boucle principale on récupère notre variable 

 valeur = analogRead(A2); // on lit les données pin A2

Puis on lance la communication radio et on en profite pour afficher dans la console si l’envoie est réussi ou non :

if (_radio.send(DESTINATION_RADIO_ID, &valeur, sizeof(valeur)))
    {
        Serial.println(" ...Succes");
    }
    else
    {
        Serial.println(" ...Echec");

On voit qu’on envoie avec la commande : radio.send


Le premier paramètre renseigne à quel récepteur on envoie le paquet. Ici on utilise la variable DESTINATION_RADIO_ID. Dans les premiers essais cette variable est définit en dur dans le code. mais sur la télécommande TT2J elle est modifiable via l’encodeur rotatif pour pouvoir dialoguer avec plusieurs récepteurs et donc loco.

Les deuxième et troisième paramètres sont la donnée envoyée.

On pourrait simplifier le code en enlevant les conditions if avec les serial print. Petit exemple sur ce site.

La partie réception est similaire pour la déclaration de la librairie, des variables, du setup. 

#include "NRFLite.h"

const static uint8_t RADIO_ID = 0;       // Identifiant du récepteur
const static uint8_t PIN_RADIO_CE = 9;  
const static uint8_t PIN_RADIO_CSN = 10;

NRFLite _radio;
int valeur = 0; // variable reception potentiometre

......

.....

  if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
    {
        Serial.println("Cannot communicate with radio");
        while (1);

Dans la boucle principale c’est relativement simple car on crée une boucle while et si il y a des données en attente on les réceptionnes:

 while (_radio.hasData()) // Attente de réception d'un caractère
    {
        _radio.readData(&valeur); // lecture variable valeur

Transmission de plusieurs variables :

Afin de transmettre plusieurs variables il faut les inclure dans une structure comprenant chaque variable, puis on transfert la structure. Le code suivant est plus compliqué et avec des nouvelles pin déclarées car il correspond à la télécommande TT2J avec l’arduino mega.

On commence par déclarer la bibliothèque, les constantes et variables:

#include "NRFLite.h"  // biblio pour la transmission radio


// ************** Constante et Variable pour la transmission radio **********************
int DESTINATION_RADIO_ID = LOCO_ADD_Value;  // Identifiant du récepteur qui corerspondra au LOCO ADDRESS
const static uint8_t RADIO_ID = 1;          // Identifiant de l'émetteur
const static uint8_t PIN_RADIO_CE = 48;     // test en 48 au lieu de 9
const static uint8_t PIN_RADIO_CSN = 49;    //test en 49 au lieu de 10

NRFLite _radio;

int POT_Value = 0;  // variable ou on stock la POT_Value du potentiometre
int bpAru = 0;      // variable pour le bouton d'arret d'urgence
int bpAruMem = 0;   // variable pour la memoire du bouton arret d'urgence
int ARU = 0;        // variable pour l'etat de l'arret d'urgence à transmettre
int LAMPE = LIGHT_Value;                    // variable pour envoyer les donnees d eclairage

On va ensuite créer une structure appelée RadioPacket dans notre cas et qui comprendra 3 variables de type INT : 

// ************** Création de la structure contenant les variables à envoyer **************

struct RadioPacket {
  int POT_Value;
  int ARU;
  int LAMPE;
};

On doit ensuite associer cette structure à une variable ici _radioData

RadioPacket _radioData;  // declaration de la variable associée a la structure

Dans le setup on initialise la communication comme avant

  if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN)) {
    Serial.println("Cannot communicate with radio");
    while (1);
  }

Dans la boucle principale ou dans une fonction appelée dans la boucle principale (mon exemple) il faut maintenant inscrire les données dans la structure. 

// *******************ENREGISTREMENT DES VARIABELS DANS LA STRUCTURE *************

void creationSTRUCTURE() {
  _radioData.POT_Value = POT_Value;
  _radioData.ARU = ARU;
  _radioData.LAMPE = LAMPE;
}

On termine par la transmission des données de la même manière qu’avant mais cette fois aussi dans une fonction

// ******************* TRANSMISSION DES DONNEES **********************************

void transmissionRADIO() {

  if (_radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData)))  // on envoit la structure precedement rempli a l'adresse selectionnee
  {
    Serial.println(" ...Succes");
  } else {
    Serial.println(" ...Echec");
  }

  //delay(500);

Pour la partie réception l’idée est donc la même il faut définir la même structure et on recevra la variable _radioData et on inscrira chaque chaque donnée de la structure dans la variable associée.

#include "NRFLite.h"

const static uint8_t RADIO_ID = 0;       // Identifiant du récepteur
const static uint8_t PIN_RADIO_CE = 9;  
const static uint8_t PIN_RADIO_CSN = 10;

NRFLite _radio;
int POT_Value = 0; // variable reception potentiometre
int ARU = 0; // variable arret d urence
int LAMPE = 0; // variable éclairage

//creation du paquet contenant les variables a recevoir

struct RadioPacket
{
  int POT_Value;
  int ARU;
  int LAMPE;
};

RadioPacket _radioData; // declaration de la variable associée a la structure

Dans le setup on initialise la communication radio

if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))
    {
        Serial.println("Cannot communicate with radio");
        while (1);
    }

Dans le loop on crée la boucle while et si il y a des données, alors on les réceptionnes et on écrit les données de la structure dans les variables

while (_radio.hasData()) // Attente de réception d'un caractère
    {
        _radio.readData(&_radioData); // lecture variable radioData comprenant la structure des 3 variables POT_Value ARU et LAMPE

        ARU = _radioData.ARU; // recuperation des variables dans la structure recue dans la variable radioData
        POT_Value = _radioData.POT_Value;
        LAMPE = _radioData.LAMPE;

On peut ensuite poursuivre le programme en utilisant les 3 variables réceptionnées.

Voila j’espère que ce petit article est assez clair pour expliquer cette partie du code concernant la transmission des données par module nRF24L01.