[Resolu] Partie d'un code qui ne s'exécute pas

Bonjour,

Il suffisait de faire une boucle dans laquelle on réinitialise toute les variables.

J'ai comme projet de créer une voiture radio commandée. Pour cela, j'utilise un émetteur constitué de deux joysticks et d'un récepteur (la voiture) avec deux roues, deux hélices, 4 servomoteurs (j'en utilise seulement deux pour l'instant). Tout ça est relié par du 433hertz.

A titre d'information : pour envoyer les données, j'utilise deux variables (pour les différentier, il y en a une qui est obligatoirement plus grande que 30 000 et l'autre plus petite) dans lesquelles je mets à différentes position les valeurs des joysticks (j'effectue une fonction map avant l'envoi et non après). Une fois mes données reçues, je n'ai qu'à faire une succession de calculs sur mes variables et les stocker dans une variable différente pour chaque information.

Après de multiples problèmes comme l'incompatibilité de la bibliothèque virtualwire et servo (que j'ai finalement réussi à résoudre en utilisant une autre bibliothèque), j'ai un autre problème auquel je n'ai pas d'idée par où chercher pour essayer de le résoudre :

Lorsque je reçois une valeur (par exemple tourner à gauche) j'ai l'impression qu'il reste sur la fonction tourner_gauche et qu'il ne fait que ça (impossibilité de lui dire de tourner à droite même si je tourne le joystick vers la droite par exemple).

A titre d'information, tous les contrôles (les chiffres décodés) sont corrects et bien reçus.

Le code partie émetteur (à titre informatif) :

#include <RCSwitch.h>

RCSwitch radio = RCSwitch();

int PIN_POTENTIOMETRE_GAUCHE_X = A1;
int PIN_POTENTIOMETRE_GAUCHE_Y = A0;
int PIN_POTENTIOMETRE_DROITE_X = A3;
int PIN_POTENTIOMETRE_DROITE_Y = A2;
int PIN_BOUTON_GAUCHE = 2;
int PIN_BOUTON_DROITE = 3;
int PIN_BOUTON_ = 4;

int vitesse;
int helice;
int direction_;
int direction_h_b;
int direction_d_g;
int bouton_gauche;
int bouton_droite;
int bouton_;

long envoi_radio;
int envoi_radio_a;
int envoi_radio_b;

void setup() {
  Serial.begin(9600);

  radio.enableTransmit(9);

  pinMode(PIN_POTENTIOMETRE_GAUCHE_X, INPUT);
  pinMode(PIN_POTENTIOMETRE_GAUCHE_Y, INPUT);
  pinMode(PIN_POTENTIOMETRE_DROITE_X, INPUT);
  pinMode(PIN_POTENTIOMETRE_DROITE_Y, INPUT);
  pinMode(PIN_BOUTON_GAUCHE, INPUT);
  pinMode(PIN_BOUTON_DROITE, INPUT);
  pinMode(PIN_BOUTON_, INPUT);

  pinMode(4, INPUT);

}

void loop() {

  vitesse = map(analogRead(PIN_POTENTIOMETRE_GAUCHE_Y), 0, 1023, 0, 255);
  helice = map(analogRead(PIN_POTENTIOMETRE_GAUCHE_X), 0, 1023, 1, 5);
  direction_h_b = map(analogRead(PIN_POTENTIOMETRE_DROITE_Y), 0, 1023, 1, 4); // 1->arriere(cela ne marche pas) / 2-> rien / 3 et 4 ->avancer
  direction_d_g = map(analogRead(PIN_POTENTIOMETRE_DROITE_X), 0, 1023, 1, 4); // 1->gauche / 2->rien / 3 et 4->droite
  bouton_gauche = digitalRead(PIN_BOUTON_GAUCHE);//1->bouton non pressé / 0->bouton pressé
  bouton_droite = digitalRead(PIN_BOUTON_DROITE);//1->bouton non pressé / 0->bouton pressé
  bouton_ = digitalRead(PIN_BOUTON_);

  //envoi_radio = (vitesse * 1000000) + (direction_h_b * 100000) + (direction_d_g * 10000) + (helice * 1000) + (bouton_gauche * 100) + (bouton_droite * 10) + bouton_;

  envoi_radio_a = (vitesse * 100) + (direction_h_b * 10) + direction_d_g;
  envoi_radio_b = 30000 + (bouton_gauche * 1000) + (bouton_droite * 100) + (helice * 10) + bouton_;

  radio.send(envoi_radio_a, 24);
  delay(10);
  radio.send(envoi_radio_b, 24);
  delay(10);

}

Le code partie récepteur (où il y a le problème) :

#include <RCSwitch.h>

#include <Servo.h>

RCSwitch radio = RCSwitch();

Servo Servo_avant_gauche;
Servo Servo_avant_droite;

Servo Servo_arriere_gauche;
Servo Servo_arriere_droite;

int roue_avant_gauche = 10;
int roue_avant_droite = 11;

int roue_arriere_gauche = 7;
int roue_arriere_droite = 8;

//long envoi_radio;
int vitesse;
int helice;
int direction_;
int direction_h_b;
int direction_d_g;
int bouton_gauche;
int bouton_droite;
int bouton_;
int var_radio;

void setup() {
  Serial.begin(9600);

  radio.enableReceive(0);
  
  Servo_avant_gauche.attach(9);
  Servo_avant_droite.attach(6);

  Servo_arriere_gauche.attach(5);
  Servo_arriere_droite.attach(3);

  pinMode(roue_avant_gauche, OUTPUT);
  pinMode(roue_avant_droite, OUTPUT);

  pinMode(roue_arriere_gauche, OUTPUT);
  pinMode(roue_arriere_droite, OUTPUT);
  
}

void loop() {
  decodage();
  voiture();
}
void decodage(){
  if(radio.available()){
    var_radio = radio.getReceivedValue();
    if(var_radio < 30000){
      vitesse = var_radio / 100;
      direction_h_b = (var_radio / 10) - (vitesse * 10);
      direction_d_g = var_radio - (vitesse * 100) - (direction_h_b * 10);
    }
    else{
      bouton_gauche = (var_radio / 1000) - 30;
      bouton_droite = (var_radio / 100) - 300 - (bouton_gauche * 10);
      helice = (var_radio / 10) - 3000 - (bouton_gauche * 100) - (bouton_droite * 10);
      bouton_ = var_radio - 30000 - (bouton_gauche * 1000) - (bouton_droite * 100) - (helice * 10);
    }
    Serial.println(direction_d_g);
    radio.resetAvailable();
  }
  
}
void servo_ejection_gauche(int ejection){
  if(ejection == 0){
    Servo_avant_gauche.write(0);
  }
  else{
    Servo_avant_gauche.write(180);
  }
}
void servo_ejection_droite(int ejection){
  if(ejection == 0){
    Servo_avant_droite.write(0);
  }
  else{
    Servo_avant_droite.write(180);
  }
}
void servo_retournement(int ejection){
  if(ejection == 0){
    Servo_arriere_gauche.write(0);
    Servo_arriere_droite.write(0);
  }
  else{
    Servo_arriere_gauche.write(180);
    Servo_arriere_droite.write(180);
  }
}
void helice_(){
  digitalWrite(roue_arriere_gauche, HIGH);
  digitalWrite(roue_arriere_droite, HIGH);
}
void roue_ejection_gauche(){
  digitalWrite(roue_arriere_gauche, HIGH);
  digitalWrite(roue_arriere_droite, LOW);
}
void roue_ejection_droite(){
  digitalWrite(roue_arriere_droite, HIGH);
  digitalWrite(roue_arriere_gauche, LOW);
}
void stop_helice(){
  digitalWrite(roue_arriere_gauche, 0);
  digitalWrite(roue_arriere_droite, 0);
}
void avancer(){
  digitalWrite(roue_avant_gauche, vitesse);
  digitalWrite(roue_avant_droite, vitesse);
}
void tourner_droite(){
  digitalWrite(roue_avant_gauche, vitesse);
  digitalWrite(roue_avant_droite, 0);
}
void tourner_gauche(){
  digitalWrite(roue_avant_gauche, 0);
  digitalWrite(roue_avant_droite, vitesse);
}
void arreter(){
  digitalWrite(roue_avant_gauche, 0);
  digitalWrite(roue_avant_droite, 0);
}

void voiture(){
  if(direction_h_b == 3 or direction_d_g == 4){
    avancer();
    //Serial.println("  avance");
  }
  if(direction_h_b == 1 or direction_h_b == 2){
    arreter();
    //Serial.println("  n'avance pas");
  }
  if(direction_d_g == 1){
    tourner_gauche();
    Serial.println("  tourne à gauche");
  }
  if(direction_d_g == 3 or direction_d_g == 4){
    tourner_droite();
    Serial.println("  tourne à droite");
  }
  if(helice == 1 or helice == 5){
    helice_();
    //Serial.println("  fait tourner ses hélices");
  }
  if(helice == 2){
    roue_ejection_gauche();
    //Serial.println("  fait tourné son hélice gauche");
  }
  if(helice == 4){
    roue_ejection_droite();
   //Serial.println("  fait tourné son hélice droite");
  }
  if(helice == 3){
    stop_helice();
    //Serial.println("  ne fait pas tourner ses hélices");
  }
  if(bouton_gauche == 0){
    servo_ejection_gauche(180);
    //Serial.println("  utilise son bras gauche");
  }
  else{
    servo_ejection_gauche(0);
    //Serial.println("  n'utilise pas son bras gauche");
  }
  if(bouton_droite == 0){
    servo_ejection_droite(180);
    //Serial.println("  utilise son bras droit");
  }
  else{
    servo_ejection_droite(0);
    //Serial.println("  n'utilise pas son bras droit");
  }
}
[/code :( ]
(Je n'utilise pas le bouton qui s'appelle bouton_ et deux des quatre servomoteurs, cela sera pour une future modification)

Auriez vous une solution, une piste, ou une fonction permettant de dire à l'arduino de regarder le reste du programme ?

Cordialement,

Aurélie :)

il y en a une qui est obligatoirement plus grande que 30 000

Peut elle dépasser 32767 ?

Ta façon d"encoder les informations est compliquée, donc sujette à erreurs.
Apparement tu cherches à envoyer 3 ou 4 données en seul appel à la radio. Tu "compactes" ces données dans un entier long.

1 - pour seulement 3 ou4 données, c'est peu efficace (par rapport au risque d'erreur que ça crée). Autant envoyer les données une par une, à la queue leu-leu ?
(Règle de base du programmeur: on optimise à la fin, quand tout fonctionne en mode bourrin)

2 - Pour envoyer un paquet de données, on les mets dans une structure. L'emmetteur remplit les membres de la structure et envoie la struct en un seul message radio.
Le récepteur reçoit le message directement dans une struct identique. Aucun calcul à faire.

Merci de vos réponses,
Tout d''abord, ma valeur ne dépasse pas 32767 comme je ne peux envoyer des longs.
Ensuite, si j'envoi les 7 valeurs une à une, cela me mets trop de latence donc ce n'est pas pratique pour piloter la voiture (j'avance le joystick vers le haut et trois secondes après, la voiture avance).
Pour finir, je ne sais pas faire des tableaux mais ma méthode marche (lors du décodage des données, j'ai testé une à une les valeurs des variables et elles s'incrémentent bien comme il faut).
En fait c'est comme si le code restait bloquer dans une fonction.
Merci beaucoup de votre réponse rapide,
Aurélie

avec ce code (si ma mémoire est bonne)

  radio.send(envoi_radio_a, 24);
  delay(10);
  radio.send(envoi_radio_b, 24);
  delay(10);

vous envoyez les 24 premiers bits des variables envoi_radio_a et envoi_radio_b qui sont des int.

si vous êtes sur un UNO, les int sont sur 16 bits seulement. Quelle est votre plateforme pour l'émission ?