aide programmation fin de course pour suiveur solaire adapté au camping car

Bonjour et merci de m'accueillir sur votre site. Je me présente, je m'appelle Patrick, je sois papy et je découvre depuis peu ce type de loisir ce qui veut dire que je ne connais absolument pas la programmation. , j'essaie mais cela n'a rien d'évident.
Mon problème est le suivant, j'essaie de monter un suiveur solaire pour poser sur le toit de mon camping car. Après avoir effectuer beaucoup de recherche, j'ai réussi, je pense à adapter le programme à mes besoins, mais j'ai épuisé mes ressources et suis bloqué quant à l'écriture des fins de courses.
A savoir que ces derniers sont posés pour couper l'alimentation du moteur DC horizontal (Est/Ouest). Il en sera de même pour l'élévation par la suite.
J'ai scrupuleusement suivi le déroulé sur le blog d'Eskimon (sur le bouton) mais rien à faire.

Pouvez vous me diriger ?
Vous remerciant d'avance
Patrick

[const int PinLdrEst = A0;             // 4 LdRs capteurs de lumière
const int PinLdrOuest = A1;
const int PinLdrHauteur = A2;
const int PinLdrBas = A3;             /////////////////
const int Ecart = 40;
 
                                // 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot H
const int ENA = 10;
const int IN1 = 9;
const int IN2 = 8;
//Mot V
const int ENB = 5;
const int IN3 = 6;
const int IN4 = 7;
const int lumi = 900;           // intensité lumineuse minimum

const int FDCE = 4;        // Ajout fin de course Est pin 4
int etatBoutonEst;   // variable qui enregistre l'etat du fin de course


 
void setup()  
{ 
  Serial.begin(9600);         // lecture écran
  pinMode(FDCE, INPUT_PULLUP);  // Résistance PULLUP
  pinMode(4,INPUT);
  etatBoutonEst = LOW;         // on initialise le fin de course comme fermé
  pinMode(PinLdrEst,INPUT);   // entrées / sorties Ldrs et moteurs
  pinMode(PinLdrOuest,INPUT);
  pinMode(PinLdrHauteur,INPUT);
  pinMode(PinLdrBas,INPUT);      //////////////////
  pinMode(ENA, OUTPUT);  
  pinMode(ENB, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
 
}
  void loop()  
  
  {
  int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs                     
  int ValLdrOuest = analogRead(PinLdrOuest); 
  int ValLdrHauteur = analogRead(PinLdrHauteur);
  int ValLdrBas = analogRead(PinLdrBas);          ////////////////// 
  
 
  Serial.print("   H "); Serial.println(ValLdrHauteur);
  Serial.print("   E "); Serial.println(ValLdrEst);
  Serial.print("   O "); Serial.println(ValLdrOuest);
  Serial.print("   B "); Serial.println(ValLdrBas);
 
  int test = ValLdrEst + ValLdrOuest + ValLdrHauteur + ValLdrBas;  // établit la luminosité ambiante
  test = test / 4;                    
  Serial.print("  test "); 
  Serial.print (test);
  Serial.print("  ");
 
  int Diff1 = ValLdrEst - ValLdrOuest;
  Diff1 = abs(Diff1);
  int Diff2 = ValLdrHauteur - ValLdrBas;
  Diff2 = abs(Diff2);
 
 if (test <= lumi || Diff1 <= Ecart || Diff2 <= Ecart)
 { 
    digitalWrite(ENA, LOW);  // les 2 Moteurs sont arrétés !
    digitalWrite(ENB, LOW);
 }         
 if (test >= lumi && ValLdrEst < ValLdrOuest && Diff1 > Ecart)
 {
    digitalWrite(IN1, LOW);  // Moteur H tourne dans un sens
    digitalWrite(IN2, HIGH);
    analogWrite(ENA, 130);
    Serial.println(" Est < Ouest");
 }
else if (test >= lumi && ValLdrEst > ValLdrOuest && Diff1 > Ecart)
 { 
    digitalWrite(IN1, HIGH);  // Moteur H tourne dans l'autre sens
    digitalWrite(IN2, LOW);
    analogWrite(ENA, 130);
    Serial.println(" Est > Ouest ");
 } 
 
                           //  FIN DE COURSE EST
{

etatBoutonEst = digitalRead(FDCE);  // rappel: pin 4

if(etatBoutonEst == LOW) .  //teste si le fin de course a un niveau logique bas
      {
        digitalWrite(9, HIGH); //le fin de course est fermé, le moteur IN1 tourne
        digitalWrite(8, HIGH); //le fin de course est fermé, le moteur IN2 tourne
      }
else                     // teste si le fin de course a un niveau logique different de bas (donc haut)
      {
        digitalWrite(9, LOW);  // le fin de course est ouvert, arret moteur IN1
        digitalWrite(8, HIGH);  // le fin de course est ouvert, arret moteur IN2
        }
 
  }
  delay(100);   // petite attente
}

 
 
  // SENS vertical  
  if(test >= lumi && ValLdrHauteur < ValLdrBas && Diff2 > Ecart)
 {
    digitalWrite(IN3, LOW);  // Moteur V tourne dans un sens
    digitalWrite(IN4, HIGH);
    analogWrite(ENB, 120);
    Serial.println(" Hauteur < Bas");  
 }
else if (test >= lumi && ValLdrHauteur > ValLdrBas && Diff2 > Ecart)
 {
    digitalWrite(IN3, HIGH);  // Moteur V tourne dans l'autre sens
    digitalWrite(IN4, LOW);
    analogWrite(ENB, 120);
    Serial.println(" Hauteur > Bas ");
 }
   delay (3000000); // boucle en arrêt toute les 10 mm
 }/code]

Ligne 28 : à ma connaissance le mode INPUT_PULLDOWN n'existe pas. Tu devrais prendre le mode INPUT_PULLUP et connecter le bouton comme indiqué sur le site : pin 4 -- bouton -- GND. Il sera LOW si appuyé.

Sinon ton code semble bien. Tu peux déclarer tes constantes en "const" (lignes 3 à 7, 18) et la variable etatbouton en bool, ce qui gagnera un peu de mémoire (très peu)

bonjour et merci

mais j'ai de grosses lacunes et tout ce langage me dépasse complètement

1- pouvez vous préciser
connecter le bouton comme indiqué sur le site : pin 4 -- bouton -- GND. Il sera LOW si appuyé

désolé de vous ennuyer

Pas de problème... Dans l'IDE, tout en bas en dessous de la zone de résultat de compilation, à gauche, il y a le numéro de la ligne où se trouve le curseur.

Pour l'INPUT_PULLUP, voir ce tuto et ce schéma


Là, le bouton est connecté en INPUT_PULLUP sur la pin 7.

Au passage, peux-tu éditer ton message et déplacer la balise CODE au début du listing et pas au début du message ?

effectivement dans ce schéma le bouton est bien sur la pin 7, sur mon exemple il est bien sur la pin 4 (const int FDCE= 4;) a moins que je me trompe.

pour ce qui est du déplacement il me faut encore me familiariser avec le forum.

j'ai apporté les modifs mentionnées mis à part le bool qu'il me faut comprendre

j'ai maintenant une erreur ligne 93

""if(etatBoutonEst == LOW ) etc..

si la variable étatBoutonEst (fin de course NC) = HIGH, le courant passe le moteur tourne,

ce qui est different dans ma ligne 30, cela ne devrait pas être LOW mais HIGH et donc different également ligne 93

est ce que ma déduction est correcte

Il y a un point sur la ligne du if avant les deux / et ça ne peut pas compiler.

Je ne sais pas ce qu'est ton fin de course. Tout ce que je sais c'est ce qui écrit sur le tuto que je t'ai indiqué. Un bouton poussoir connecté en INPUT_PULLUP passe à LOW lorsqu'il est appuyé.

À toi de voir si ça marche avec ton montage.

correction effectuée,

maintenant je me retrouve avec une autre erreur sur la ligne 111

if(test >= lumi && ValLdrHauteur < ValLdrBas && Diff2 > Ecart)

quel lien peut il y avoir entre la partie purement suiveur solaire réalisée qui fonctionnait
et la partie fin de course qui est rajoutée ?

le recette de mon précédent post lu sur le site openclassroom correspondait à l'étude d'un poussoir classique

L'ensemble du message d'erreur fourni par le compilateur est important pour comprendre le problème. Souvent il y a plusieurs erreurs mais on ne voit que la dernière car on laisse la fenêtre du compilateur assez petite.

Il faut que tu postes ici l'ensemble des messages du compilateur, en utilisant le bouton 'copier les messages' (de mémoire) situé à droite de la fenêtre du compilateur, puis en le collant dans ton message.

On gagne du temps en voyant tout d'un coup plutôt qu'erreur par erreur.

Donc, poste dans ton prochain message le code actualisé et les messages du compilateur. Merci

Arduino : 1.8.8 (Mac OS X), Carte : "Arduino/Genuino Uno"

suiveur_papy_4_LCD_2_modif:111:3: error: expected unqualified-id before 'if'
if(test >= lumi && ValLdrHauteur < ValLdrBas && Diff2 > Ecart)
^
suiveur_papy_4_LCD_2_modif:118:1: error: expected unqualified-id before 'else'
else if (test >= lumi && ValLdrHauteur > ValLdrBas && Diff2 > Ecart)
^
suiveur_papy_4_LCD_2_modif:125:10: error: expected constructor, destructor, or type conversion before '(' token
delay (3000000); // boucle en arrêt toute les 10 mm
^
suiveur_papy_4_LCD_2_modif:126:2: error: expected declaration before '}' token
}
^
exit status 1
expected unqualified-id before 'if'

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

Et le code ? Une erreur signalée par le compilateur à la ligne n peut avoir sa source à la ligne n-1 ou n+1...

alors là c'est du russe

Tovarich Patrick, il faut poster le code qui donne ces erreurs à la compilation. Spaciba.

si le code est renseigné sur la partie rouge, il s'agit de

"" expected unqualified-it before 'if'

[// Trackeur solaire - papy 2018
 
const int PinLdrEst = A0;             // 4 LdRs capteurs de lumière
const int PinLdrOuest = A1;
const int PinLdrHauteur = A2;
const int PinLdrBas = A3;             /////////////////
const int Ecart = 40;
 
                                // 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot H
const int ENA = 10;
const int IN1 = 9;
const int IN2 = 8;
//Mot V
const int ENB = 5;
const int IN3 = 6;
const int IN4 = 7;
const int lumi = 900;           // intensité lumineuse minimum

const int FDCE = 4;        // Ajout fin de course Est pin 4
int etatBoutonEst;   // variable qui enregistre l'etat du fin de course


 
void setup()  
{ 
  Serial.begin(9600);         // lecture écran
  pinMode(FDCE, INPUT_PULLUP);  // Résistance PULLUP
  pinMode(4,INPUT);
  etatBoutonEst = LOW;         // on initialise le fin de course comme fermé
  pinMode(PinLdrEst,INPUT);   // entrées / sorties Ldrs et moteurs
  pinMode(PinLdrOuest,INPUT);
  pinMode(PinLdrHauteur,INPUT);
  pinMode(PinLdrBas,INPUT);      //////////////////
  pinMode(ENA, OUTPUT);  
  pinMode(ENB, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
 
}
  void loop()  
  
  {
  int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs                     
  int ValLdrOuest = analogRead(PinLdrOuest); 
  int ValLdrHauteur = analogRead(PinLdrHauteur);
  int ValLdrBas = analogRead(PinLdrBas);          ////////////////// 
  
 
  Serial.print("   H "); Serial.println(ValLdrHauteur);
  Serial.print("   E "); Serial.println(ValLdrEst);
  Serial.print("   O "); Serial.println(ValLdrOuest);
  Serial.print("   B "); Serial.println(ValLdrBas);
 
  int test = ValLdrEst + ValLdrOuest + ValLdrHauteur + ValLdrBas;  // établit la luminosité ambiante
  test = test / 4;                    
  Serial.print("  test "); 
  Serial.print (test);
  Serial.print("  ");
 
  int Diff1 = ValLdrEst - ValLdrOuest;
  Diff1 = abs(Diff1);
  int Diff2 = ValLdrHauteur - ValLdrBas;
  Diff2 = abs(Diff2);
 
 if (test <= lumi || Diff1 <= Ecart || Diff2 <= Ecart)
 { 
    digitalWrite(ENA, LOW);  // les 2 Moteurs sont arrétés !
    digitalWrite(ENB, LOW);
 }         
   // SENS HORIZONTAL
   
 if (test >= lumi && ValLdrEst < ValLdrOuest && Diff1 > Ecart)
 {
    digitalWrite(IN1, LOW);  // Moteur H tourne dans un sens
    digitalWrite(IN2, HIGH);
    analogWrite(ENA, 130);
    Serial.println(" Est < Ouest");
 }
else if (test >= lumi && ValLdrEst > ValLdrOuest && Diff1 > Ecart)
 { 
    digitalWrite(IN1, HIGH);  // Moteur H tourne dans l'autre sens
    digitalWrite(IN2, LOW);
    analogWrite(ENA, 130);
    Serial.println(" Est > Ouest ");
 } 
 
                           //  FIN DE COURSE EST
{

boolean etatBoutonEst = digitalRead(FDCE);  // rappel: pin 4

if(etatBoutonEst == LOW)   //teste si le fin de course a un niveau logique bas
      {
        digitalWrite(9, LOW); //le fin de course est fermé, le moteur IN1 tourne
        digitalWrite(8, LOW); //le fin de course est fermé, le moteur IN2 tourne
      }
else                     // teste si le fin de course a un niveau logique different de bas (donc haut)
      {
        digitalWrite(9, HIGH);  // le fin de course est ouvert, arret moteur IN1
        digitalWrite(8, HIGH);  // le fin de course est ouvert, arret moteur IN2
        }
 
  }
  delay(100);   // petite attente
}

  // SENS vertical  
  
  if(test >= lumi && ValLdrHauteur < ValLdrBas && Diff2 > Ecart)
 {
    digitalWrite(IN3, LOW);  // Moteur V tourne dans un sens
    digitalWrite(IN4, HIGH);
    analogWrite(ENB, 120);
    Serial.println(" Hauteur < Bas");  
 }
else if (test >= lumi && ValLdrHauteur > ValLdrBas && Diff2 > Ecart)
 {
    digitalWrite(IN3, HIGH);  // Moteur V tourne dans l'autre sens
    digitalWrite(IN4, LOW);
    analogWrite(ENB, 120);
    Serial.println(" Hauteur > Bas ");
 }
   delay (3000000); // boucle en arrêt toute les 10 mm
 }code]

vous devez me prendre pour un fou, mais malheureusement je ne le fais pas exprès, tout ce langage m'est inconnu et donc faut que cela arrive au cerveau

Pas de souci,, tu es là pour apprendre, comme tout le monde. C'est l'intérêt de la communauté : j'aide avec mes connaissances et j'apprends en lisant les réponses des autres...

Pour ton problème, il suffit de savoir une petite chose toute simple : dans l'IDE Arduino, les touches CTRL T permettent de corriger l'indentation des blocs. Les lignes entre des couples d'accolades { et } sont indentées, ce qui permet de voir les blocs beaucoup plus facilement.

J'ai copié ton code dans l'IDE, j'ai fait CTRL T et j'ai parcouru le code : à partir de la ligne 108, les lignes commencent à l'extrême gauche de la fenêtre alors qu'on est censé être dans la loop, donc à l'intérieur d'un bloc (l'accolade ouvre au début de la loop). Donc il y a une accolade fermante de trop. Je pense que c'est celle de la ligne 108. Ça m'a pris dix secondes. 8)

Essaye d'ôter cette ligne et de recompiler...
A+

bonjour et merci
j'ai maintenant deux autres questions, relatives aux fin de courses, le fin de course Est est réalisé, je dois faire de même pour le côté Ouest et ensuite pour la partie verticale, haut et bas, dois appliquer la même méthode ?

enfin dans un deuxième temps, je dois ajouter un inter deux positions manuel/auto afin de pouvoir alimenter un joystick pour une commande manuelle dans les deux axes. est ce que le principe est similaire ?

merci pour cette aide précieuse
Patrick

patrick-papy:
j'ai maintenant deux autres questions, relatives aux fin de courses, le fin de course Est est réalisé, je dois faire de même pour le côté Ouest et ensuite pour la partie verticale, haut et bas, dois appliquer la même méthode ?

A priori oui

patrick-papy:
enfin dans un deuxième temps, je dois ajouter un inter deux positions manuel/auto afin de pouvoir alimenter un joystick pour une commande manuelle dans les deux axes. est ce que le principe est similaire ?

Tu peux lire ceci et cela pour les interrupteurs. Il n'y a pas de différence fondamentale, tout dépend de ce que tu veux en faire et de la manière dont tu vas le brancher. Conserve à l'esprit que l'Arduino lit un état (LOW ou HIGH, ou 0 ou 1) via le digitalRead. Il faut que tu branches ton interrupteur afin qu'il lise LOW dans une position et HIGH dans l'autre.
Ensuite, selon la valeur lue, il lancera une action ou une autre (passage en mode manuel ou en mode auto si je comprends bien).

merci je suis dans cette lecture, j'ai terminé mes 4 fins de courses et me suis attelé à mon interrupteur deux positions NC ou NO (spdt) qui permettra soit de laisser le suiveur en mode automatique, soit passer en mode manuel et piloter mes moteurs avec un joystick.
bien entendu les difficultés apparaissent

#include <Bounce2.h>

                    //  INTERRUPTEUR MANUEL/AUTO
                    
   // définition des broches de l'interrupteur Manuel/Automatique
   
const int INTERMANU = 12;    // ajout interrupteur manuel pin 12
int etatInterManu;           // variable qui enregistre l'état manuel
const int INTERAUTO = 13;    // ajout interrupteur automatique pin 13
int etatInterAuto;           // variable qui enregistre l'etat automatique
#define INTER_ETAT_INDEFINI  -1

   // Créer (instancier) un objet bounce pour chaque position de l'interrupteur

   Bounce intermanu;
   Bounce interauto;
   


const int PinLdrEst = A0;             // 4 LdRs capteurs de lumière
const int PinLdrOuest = A1;
const int PinLdrHauteur = A2;
const int PinLdrBas = A3;             /////////////////
const int Ecart = 40;

// 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot H
const int ENA = 10;
const int IN1 = 9;
const int IN2 = 8;
//Mot V
const int ENB = 5;
const int IN3 = 6;
const int IN4 = 7;
const int lumi = 900;           // intensité lumineuse minimum

                  // MISE EN PLACE DES FINS DE COURSE
                  
const int FDCE = 4;        // Ajout fin de course Est pin 4
int etatBoutonEst;   // variable qui enregistre l'etat du fin de course
const int FDCO = 3;             // Ajout fin de course Ouest pin 3
int etatBoutonOuest;  // variable qui enregistre l'état du fin de course
const int FDCB = 2;        // Ajout fin de course Bas pin 2
int etatBoutonBas;    // variable qui enregistre l'etat du fin de course
const int FDCH = 11;        // Ajout fin de course haut pin 11
int etatBoutonHaut;    // variable qui enregistre l'etat du fin de course




void setup()
{
  Serial.begin(9600);         // lecture écran
  pinMode(INTERMANU, INPUT_PULLUP);    // résistance PULLUP
  pinMode(12,INPUT); 
  etatInterManu = LOW;        // on initialise l'interrupteur comme fermé 
  pinMode(INTERAUTO, INPUT_PULLUP);    //résistance PULLUP
  pinMode (13, INPUT);
  etatInterAuto = HIGH;       // on initialise l'interrupteur comme ouvert
  intermanu.attach(INTERMANU);   // attache l'objet "intermanu" à sa broche
  intermanu.interval(5);         // temps de latence entre deux mesures d'état
  interauto.attach(INTERAUTO);   // attache l'objet"interauto" à sa broche
  interauto.interval(5);         // temps de latence entre deux mesures d'état
  int courant = INTER_ETAT_INDEFINI;
  
  pinMode(FDCE, INPUT_PULLUP);    // Résistance PULLUP
  pinMode(4, INPUT);
  etatBoutonEst = LOW;            // on initialise le fin de course comme fermé
  pinMode(FDCO, INPUT_PULLUP);   // résistance PULLUP
  pinMode(3, INPUT);
  etatBoutonOuest = LOW;          // on initialise le fin de course comme fermé
  pinMode(FDCB, INPUT_PULLUP);   // résistance PULLUP
  pinMode(2, INPUT);
  etatBoutonBas = LOW;           // on initialise le fin de course comme fermé
  pinMode(FDCH, INPUT_PULLUP);   // résistance PULLUP
  pinMode(11, INPUT);
  etatBoutonHaut = LOW;          // on initialise le fin de course comme fermé
  
  pinMode(PinLdrEst, INPUT);  // entrées / sorties Ldrs et moteurs
  pinMode(PinLdrOuest, INPUT);
  pinMode(PinLdrHauteur, INPUT);
  pinMode(PinLdrBas, INPUT);     //////////////////
  pinMode(ENA, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop()

{
      // mise à jour de l'état des intermanu et auto 
      intermanu.update();
      interauto.update();

      // récupération de l'état des broches
      int valeurA = intermanu.read();
      int valeurB = interauto.read();

      // si la valeur n'a pas changé depuis la dernière fois, rien à faire
      if (valeurA == true && courant == INTERMANU)
      return;
      if (valeurB == true && courant == INTERAUTO)
      return;

      if (valeurA == true)
          courant = INTERMANU;
      if (valeurB == true)
          courant = INTERAUTO;

       // Agir en fonction de l'état du bouton
       if ( courant == INTERMANU)
       { Instructions etat A }
       else
       { Instructions etat B }
  
}


{
  int ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs
  int ValLdrOuest = analogRead(PinLdrOuest);
  int ValLdrHauteur = analogRead(PinLdrHauteur);
  int ValLdrBas = analogRead(PinLdrBas);          //////////////////


  Serial.print("   H "); Serial.println(ValLdrHauteur);
  Serial.print("   E "); Serial.println(ValLdrEst);
  Serial.print("   O "); Serial.println(ValLdrOuest);
  Serial.print("   B "); Serial.println(ValLdrBas);

  int test = ValLdrEst + ValLdrOuest + ValLdrHauteur + ValLdrBas;  // établit la luminosité ambiante
  test = test / 4;
  Serial.print("  test ");
  Serial.print (test);
  Serial.print("  ");

  int Diff1 = ValLdrEst - ValLdrOuest;
  Diff1 = abs(Diff1);
  int Diff2 = ValLdrHauteur - ValLdrBas;
  Diff2 = abs(Diff2);

  if (test <= lumi || Diff1 <= Ecart || Diff2 <= Ecart)
  {
    digitalWrite(ENA, LOW);  // les 2 Moteurs sont arrétés !
    digitalWrite(ENB, LOW);
  }
  /code]