servomoteur NRF24L01

Bonjour à tous, j'ai un projet en cours qui consiste à commander 12 servomoteur à distance.

J'utilise 2 Arduino Mega, 2 NRF24L01, 12 boutons poussoirs (à terme cela deviendra une télécommande).
Pour l'instant mes boutons poussoirs sont installés sur une plaque d'essais, protégés par une résistance et reliés aux broches 2 à 13 de l'Arduino émetteur.

Le mouvement attendu est j'appuie sur le bouton 1, le servo 1 s'ouvre, je relâche le bouton 1, le servo 1 se referme, ainsi de suite jusqu'au servo 12.

Mon problème n'est pas sur le mouvement des servos ni sur la communication des nrf24l01, mais dans l'envoi du message, je ne sais pas sous quel format envoyer... je m'explique:

Emmetteur:

J'appuie sur le bouton 1, le message "1" s'envoie
J'appuie sur le bouton 2, le message "2" s'envoie
Ainsi de suite jusqu'au bouton 12

Récepteur:

Si le message est "1", le servo 1 s'ouvre, sinon il reste à son état initial
Si le message est "2", le servo 2 s'ouvre, sinon il reste à son état initial
Ainsi de suite jusqu'au servo 12

je n'arrive pas à traduire ça en code, est ce que quelqu'un aurait une solution?

Si le message est "1", le servo 1 s'ouvre, sinon il reste à son état initial

Bonjour,

le "sinon il reste à son état initial" n'est pas nécessaire

si le retour à létat initial des servos doit être commandé par le relâchement du bouton, il faut compléter la liste de tes messages

pour tester la liaison des nrf24l01+, quels messages as-tu envoyés (et vérifié la réception) ?

voici le code de mon emetteur:

//
#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>



int val[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};    // État des boutons
int old_val[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // État précédent des boutons
int state[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // État de la LED
byte message;  // ce qui sera envoyé à  l'autre Arduino

void setup(){
  Mirf.cePin = 47; // CE branché sur 8 
  Mirf.csnPin = 49; // CSN branché sur 9
  Mirf.spi = &MirfHardwareSpi; 
  Mirf.init(); 
  
  Mirf.channel = 65;
  Mirf.payload = sizeof(byte); // taille de ce qu'on va envoyer
  Mirf.config(); 
  
  Mirf.setTADDR((byte *)"nrf02"); // on baptise les deux modules
  Mirf.setRADDR((byte *)"nrf01"); 
  
  
  // configuration des entrées numériques associées aux boutons:

  for (int i=0; i <= 11; i++){
    pinMode(BOUTON+i, INPUT);
  } 

}

void loop(){

   for (int i=0; i <= 11; i++){

    val[i] = digitalRead(BOUTON+i); 

    // Y a-t-il eu un changement?
    if ((val[i] == HIGH) && (old_val[i] == LOW)){
      state[i] = 1 - state[i];
      delay(10);
    }
    
    old_val[i] = val[i]; 
    
  } 

 // mise à  jour du message à  envoyer à l'autre Arduino:
 message = B00000000;
 if (state[0]){
   message = message + B00000001;
 }
  if (state[1]){
   message = message + B00000010;
 }
   if (state[2]){
   message = message + B00000011;
 }
   if (state[3]){
   message = message + B00000100;
 }
   if (state[4]){
   message = message + B00000101;
 }
   if (state[5]){
   message = message + B00000110;
 }
   if (state[6]){
   message = message + B00000111;
 }
   if (state[7]){
   message = message + B00001000;
 }  
   if (state[8]){
   message = message + B00001001;
 }
   if (state[9]){
   message = message + B00001010;
 }
   if (state[10]){
   message = message + B00001011;
 }
   if (state[11]){
   message = message + B00001100;

 }
 
 // on peut maintenant envoyer le message
 
  Mirf.send((byte *)&message); 
  
  while(Mirf.isSending()); // On attend aussi longtemps que le message n'a pas été envoyé
 
}

Et le code de mon récepteur:

/
#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>
#include <Servo.h>

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
Servo servo6;
Servo servo7;
Servo servo8;
Servo servo9;
Servo servo10;
Servo servo11;
Servo servo12;

byte message;


void setup(){

  Mirf.cePin = 47; // CE branché sur 8
  Mirf.csnPin = 49; // CSN branché sur 9
  Mirf.spi = &MirfHardwareSpi; 
  Mirf.init(); 

  Mirf.channel = 65; 
  Mirf.payload = sizeof(byte); // taille de ce qu'on va recevoir
  Mirf.config(); 

  Mirf.setTADDR((byte *)"nrf01"); // on baptise les deux modules
  Mirf.setRADDR((byte *)"nrf02"); 

  // configuration des sorties (Servo)
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(12,OUTPUT);
  pinMode(13,OUTPUT);
  
  servo1.attach(2);
  servo2.attach(3);
  servo3.attach(4);
  servo4.attach(5);
  servo5.attach(6);
  servo6.attach(7);
  servo7.attach(8);
  servo8.attach(9);
  servo9.attach(10);
  servo10.attach(11);
  servo11.attach(12);
  servo12.attach(13);
}

void loop(){


  byte data[Mirf.payload]; // data va contenir les donnéees reçues
  
  if(!Mirf.isSending() && Mirf.dataReady()){ 

    Mirf.getData(data); // réception du message

    message = data[0];

    // on fait bouger les servos


if (message >= B00001000){
    servo8.write(90); 
    message =  message - B00001000;}
else
   {servo8.write(180); } 

if (message >= B00000111){
    servo7.write(90); 
    message =  message - B00000111;}
else
   {servo7.write(180); } 

if (message >= B00000110){
    servo6.write(90); 
    message =  message - B00000110;}
else
   {servo6.write(180); } 
   
if (message >= B00000101){
    servo5.write(90); 
    message =  message - B00000101;}
else
   {servo5.write(180); } 


if (message >= B00000100){
    servo4.write(90); 
    message =  message - B00000100;}
else
   {servo4.write(180); } 

   
if (message >= B00000011){
    servo3.write(90); 
    message =  message - B00000011;}
else
   {servo3.write(180); } 
   
  
if (message >= B00000010){
    servo2.write(90); 
    message =  message - B00000010;}
else
   {servo2.write(180); } 
    
  }
 
if (message >= B00000001){
    servo1.write(90); 
    }
else
   {servo1.write(180); } 
    
 
}

La communication fonctionne, j’ouvre et je fermes les 6 premiers servos mais au delà ca ne fonctionne plus.

Je pense que mon problème de ce message “B000000001” que j’envoie et que je reçois, je voudrais un truc plus simple mais je n’arrive à traduire ma pensé en code:

J’appuie sur le bouton 1, le message “1” s’envoie
J’appuie sur le bouton 2, le message “2” s’envoie
Ainsi de suite jusqu’au bouton 12

Récepteur:

Si le message est “1”, le servo 1 s’ouvre, sinon il reste à son état initial
Si le message est “2”, le servo 2 s’ouvre, sinon il reste à son état initial
Ainsi de suite jusqu’au servo 12

Bonjour,

tu ne peux pas coder ainsi tes messages : par exemple si le bouton 3 et 6 sont appuyés, tu envoies 9, mais le récepteur ne sait pas si c'est 3+6 ou 4+5 ou 1+8 ...

je te laisse y réfléchir, tu peux trouver par toi-même

J'ai essayé d'envoyer du texte (servo1, servo2, servo 3 etc...) ça ne fonctionne pas.
J'ai essayé d'envoyer des chiffres (1, 2, 3 etc...) ça ne fonctionne pas.
J'ai essayé de modifier mes messages B00000000, ce ne fonctionne pas non plus...

Je commence à désespérer...

à l'émission :

bool val[12];
bool old_val[12];


// dans la boucle i, lecture des boutons et mémorisation de l'état
if (digitalRead(i) == LOW ) { val[i] = TRUE; } else if (digitalRead(i) == HIGH) { val[i] = FALSE; }
// Y a-t-il eu un changement ?
if ( val[i] != old_val[i] ) { // on n'agit que si il y a du changement
  if ( val[i] == TRUE   ) { message = 1 + i;  } else  { message = 21 + i;  } // le message est codé
  old_val[i] = val[i];
  delay(10); // why not, mais il faudra traiter le debounce sérieusement
 // on peut maintenant envoyer le message
 // etc.

pour la réception :

// on fait bouger les servos
if (message == 1) { servo1.write(90); }
else if (message == 21) { servo1.write(180); }
 
elseif (message == 2) { servo2.write(90); }
else if (message == 22) { servo2.write(180); } 
 
elseif (message == 3) { servo3.write(90); }
else if (message == 23) { servo3.write(180); }

//etc.

Merci à toi mais ça ne fonctionne pas… pas de mouvements de mes servos

Le programme ne me reconnaissait pas la commande :

val = TRUE ou val = FALSE
J’ai donc mis:
val = “TRUE” et val = “FALSE”, je ne sais si ça peut faire bugger le programme?

j'avais omis le ; il faut : val = TRUE;

Meme avec cette correction toujours pas le moindre mouvement de mes servos…

Bonjour,
c'est dommage, mais où est l'erreur ?

Tout se telecharge normalement mais les infos reçues par le récepteur n'activent pas les sorties.

Ce n'est pas un problème de setup car c'est la meme confîg que dans mon programme d'origine et quand je le recharge je parviens à faire bouger les 6 premiers servos.

Je pense que le problème est dans le message envoyé/reçu...

Bonjour,
mais encore ?