commande de plusieurs servo moteurs avec module nRF24L01

bonsoir à tous ,

je viens de mettre sur l'envoie de donner via 2 modules NRF24L01 à l'aide de 2 carte Arduino Uno .
j'ai suivi un premier Tuto pour le câblage des modules , et qq ligne de code afin de contrôler un servo moteur via un potentiomètre . ça fonctionne tres bien ...

Cependant , je voudrais evidement aller plus loin dans l'interprétation des valeurs analogiques ( venant de potentiomètre / valeur DMX / BP .... ) envoyer par la carte arduino ''émettrice'' puis interprété par la carte ''receptrice'' .
Avec les codes suivant , j'arrive à controler un seul servo , mais j'ai commencer à bidouiller le code pour rajouter des servos , controler via diff valeurs venant de l'arduino Émettrice , et là ça coince !

je n'ai pas encore totalement saisie la logique des variables à déclarer dans une transmission sans fil avec
ces modules hf .....et d'ailleurs est ce possible ?
Merci d'avance pour votre aide

Code Emetteur :

/*

Radio    Arduino
CE    -> 9
CSN   -> 10 (Hardware SPI SS)
MOSI  -> 11 (Hardware SPI MOSI)
MISO  -> 12 (Hardware SPI MISO)
SCK   -> 13 (Hardware SPI SCK)
IRQ   -> Rien
VCC   -> En dessous de 3.6 volts
GND   -> GND


Potentiomètre Arduino
Pin de droite -> 5V
Pin du millieu -> A0
Pin de gauche -> GND
*/


#include <SPI.h>
#include <NRFLite.h>

const static uint8_t RADIO_ID = 1;             // Numéro d'indentification de notre module émetteur
const static uint8_t DESTINATION_RADIO_ID = 0; // Numéro d'identification du module récepteur (A qui notre émetteur transmet)
const static uint8_t PIN_RADIO_CE = 9;//déclaration du pin CE
const static uint8_t PIN_RADIO_CSN = 10;//déclaration du pin CSN

int Valeur;//variable qui contient la valeur transmise

struct RadioPacket // Packet de données envoyé,
//uint8_t=variable sur 8 bit, uint32_t=variable sur 32 bit
{
    uint32_t Valeur;//variable Valeur codée sur 32 bit
};

NRFLite _radio; //Déclaration du module NRF
RadioPacket _radioData;//Déclaration du packet de données

void setup()
{
    Serial.begin(115200);//On ouvre la laison série avec le PC à 115200 baud

       
    if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))//si l'initialisation du module n'est pas finie
    {
        Serial.println("L'arduino ne peut pas communiquer avec le module ");
        while (1); // Attend
    }
    Serial.println("Setup fini");
    
}

void loop()
{
     _radioData.Valeur=analogRead(A0);//lecture de la valeur du potentiometre
     //donne une valeur entre 0 et 1023
     _radioData.Valeur = map(_radioData.Valeur, 0, 1023, 0, 180);//produit en croix pour avoir une valeur d'angle pour le servo entre 0° et 180°
    
    Serial.println(_radioData.Valeur);//Affiche la valeur envoyée
    
  if (_radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData))) //Si le module récepteur confirme qu'il a bien recu le message
    {
        Serial.println("...Bien arrivé");
    }
    
    else
    {
        Serial.println("...erreur");
    }

    delay(10);//pause de 10 milli secondes
    
    /*
    Par défaut la commande _radio.send transmet les données puis attend pour un accusé de réception
    
    Il est possible de changer cette condition avec ces commandes :
    
    _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::NO_ACK)//pas d'accusé de réception
    _radio.send(DESTINATION_RADIO_ID, &_radioData, sizeof(_radioData), NRFLite::REQUIRE_ACK) // par défaut , accusé de réception
    */
}

code récepteur :

/*

Radio    Arduino
CE    -> 9
CSN   -> 10 (Hardware SPI SS)
MOSI  -> 11 (Hardware SPI MOSI)
MISO  -> 12 (Hardware SPI MISO)
SCK   -> 13 (Hardware SPI SCK)
IRQ   -> Rien
VCC   -> En dessous de 3.6 volts
GND   -> GND

Servo  Arduino
GND -> GND (noir ou marron)
5V -> 5V (rouge)
Signal -> 6 (orange ou blanc)

*/
#include<Servo.h>
#include <SPI.h>
#include <NRFLite.h>

Servo myServo;//déclaration du servomoteur


const static uint8_t RADIO_ID = 0;       // Numéro d'indentification de notre module récepteur
const static uint8_t PIN_RADIO_CE = 9; //déclaration du pin CE
const static uint8_t PIN_RADIO_CSN = 10;//déclaration du pin CSN

struct RadioPacket // Packet de données envoyé,
//uint8_t = variable sur 8 bit, uint16_t=variable sur 16 bit, uint32_t=variable sur 32 bit
{
    uint32_t Valeur;//variable Valeur codée sur 32 bit
};

NRFLite _radio; //Déclaration du module NRF
RadioPacket _radioData;//Déclaration du packet de données

void setup()
{
    Serial.begin(115200);//On ouvre la laison série avec le PC à 115200 baud

    myServo.attach(6);//Déclaration du pin du servomoteur

    if (!_radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN))//si l'initialisation du module n'est pas finie
    {
        Serial.println("L'arduino ne peut pas communiquer avec le module ");
        while (1); // Attend
    }
    Serial.println("Setup fini");
    
    /*
    Par défaut la vitesse est de 2mb/s sur la channel 100/125
    L'émetteur et le recepteur doivent etre sur la même channel et avoir la même vitesse pour bien communiquer
    
    Il est possible de changer ces paramtres avec les commandes:    
    
    _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE250KBPS, 0)//250kB/s channel 0
    _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE1MBPS, 75)//1 MB/s channel 75
    _radio.init(RADIO_ID, PIN_RADIO_CE, PIN_RADIO_CSN, NRFLite::BITRATE2MBPS, 100) // par défaut
    */
}

void loop()
{
    while (_radio.hasData())//Tant que le module NRF a des données
    {
        _radio.readData(&_radioData); // lecture des nouvelles données 

        myServo.write(_radioData.Valeur);//Le servo prend la valeur recue
        Serial.println(_radioData.Valeur);//afficher sur lepc la valeur recue
        
    }
}