Probleme avec un programme qui fonctionnait

International Français
1

Bonjour si je l avais pas mit au point sur une maquette je comprendrais mais la je plane pas d erreur et si j enève minuteriedépart le reste refonctionne arduino nano ch340

// #include <SPI.h>
#include <Wire.h>
//#include <Adafruit_GFX.h> //sans graphique ca passe
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128  // OLED display width, in pixels
#define SCREEN_HEIGHT 64  // OLED display height, in pixels
//Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library.
// On an arduino UNO:       A4(SDA), A5(SCL)
// On an arduino MEGA 2560: 20(SDA), 21(SCL)
// On an arduino LEONARDO:   2(SDA),  3(SCL), ...
#define OLED_RESET -1        // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C  ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define pinILS 2
#define pi 3.14159265359
#define RayonDesBras 0.025                  // en mètre de l'anénomètre
unsigned long antiRebonds = 20000;          // anti-rebonds anemometres 10 millis-secondes
unsigned long chronoAnemometre = micros();  //et > temps de passage devant aimant (à calculer)
unsigned long millis_old = 0;
unsigned long Minuteriedepart = 0; // valeur de la constante millis
unsigned long Raz_Minuteriedepart = 0; // valeur de la constante millis
unsigned long tempsecoule = 0; // valeur de la constante remise a zero
float delta_temps = 0;
float vitesseVentms = 0;
float vitesseVentkmh = 0;
float NombreTourSec = 0;
float NombreTour = 0;
float FEtalonage = 1;
volatile int nombre_aimant = 0;
/* NB : La fonction d'étalonnage traduit les propriétés aérodynamiques de
  l'anémomètre et les frottements qui altèrent le mouvement de rotation de l'anémomètre.
  Elle dépend des dimensions et matériaux de l'anémomètre et de sa vitesse de rotation.
  Seuls des essais en soufflerie à différents régimes de vent permettent de la déterminer précisément. */
bool etat_ILS = false;
bool etat = 0;


int PinLdrEst = A1;  // 4 LdRs capteurs de lumière
int PinLdrOuest = A0;
int PinLdrHaut = A3;
int PinLdrBas = A2;
// A4 réservé oled SDA
// A5 réservé oled SCL
int Ecart = 10;
int lum_moyenne = 0;
int delta_O_E = 5;
int delta_H_B = 5;

int Cp_N = 5;  // valeur de compensation lors de l'alignement variable a chaque install
int Cp_S = 0;  // valeur de compensation lors de l'alignement variable a chaque install
int Cp_E = 0;  // valeur de compensation lors de l'alignement variable a chaque install
int Cp_O = 2;  // valeur de compensation lors de l'alignement variable a chaque install


// 2 moteurs horizontal Est/Ouest et vertical Haut/Bas
//Mot Horizontal
const int Moteur_H = 10;  //ENA
const int EST = 9;        //IN1
const int OUEST = 8;      //IN2
//Mot Vertical
const int Moteur_V = 5;  //ENB
const int HAUT = 6;      //IN3 HAUT
const int BAS = 7;       //IN4
int lumi = 700;
// fin de course
const int Fdc_N = 3;          // broche Rx fin de course Nord
const int Fdc_S = 4;          // broche Rx fin de course Sud
const int Fdc_E = 11;         // broche Rx fin de course Est
const int Fdc_O = 12;         // broche Rx fin de course Ouest
const int hysteresis_H = 8;  //anti baguottage
const int hysteresis_V = 10;  //anti baguottage
const int hysteresis = 10;    //anti baguottage
const int nuit = 240;         // Valeur en-dessous de laquelle on considère qu'il fait nuit
                              // a cette valeur ne produit plus donc retour  verifier la valeur mini
boolean memo_Fdc_E = true;    // pour memo FDC atteint, sert d"anti rebonds
boolean memo_Fdc_O = true;    // pour memo FDC atteint, sert d"anti rebonds
boolean memo_Fdc_S = true;    // pour memo FDC atteint, sert d"anti rebonds
boolean memo_Fdc_N = true;    // pour memo FDC atteint, sert d"anti rebonds

boolean verrou_E_O = false;
boolean verrou_H_B = false;
boolean reveil = true;
//int Erreur    = 0;
//int reveil     = 1;
//int ValLdrEst = 0;     // ldrs valeurs a zero
//int ValLdrOuest = 0;
//int ValLdrHaut = 0;
//int ValLdrBas = 0;
void isr_anemometre() {
  if (micros() > chronoAnemometre) {
    chronoAnemometre = micros();
    nombre_aimant++;
  }
}
void setup() {  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
  //  Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ;  // Don't proceed, loop forever
  }
  display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
  display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
  display.display();
   delay(3000); // Pause for 3 seconds on a le temps stabilise les valeurs au demarrage
   
   
 
  display.clearDisplay();
  display.setTextSize(2);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
  display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
                                                       // display.setCursor(40, 20);                           // Start at top-left corner
                                                       // display.print("MODE MARCHE   ");
  display.setCursor(20,30);                             // Déplacement du curseur en position (0,0), c'est
  display.print(F("TRAQUEUR    V4 2 1"));
  display.display();
   delay(3000); // Pause for 3 seconds on a le temps stabilise les valeurs au demarrage
  display.clearDisplay(); 
  //
  pinMode(pinILS, INPUT_PULLUP);                //sur D2 donc interruption 0
  attachInterrupt(0, isr_anemometre, FALLING);  //ils ramène GND sur D2

  Serial.begin(115200);       // lecture écran
  pinMode(PinLdrEst, INPUT);  // entrées / sorties Ldrs et moteurs
  pinMode(PinLdrOuest, INPUT);
  pinMode(PinLdrHaut, INPUT);
  pinMode(PinLdrBas, INPUT);
  pinMode(Moteur_V, OUTPUT);
  pinMode(Moteur_H, OUTPUT);
  pinMode(EST, OUTPUT);          //EST
  pinMode(OUEST, OUTPUT);        //OUEST
  pinMode(BAS, OUTPUT);          //BAS
  pinMode(HAUT, OUTPUT);         //HAUT
  pinMode(Fdc_N, INPUT_PULLUP);  // declare la pin du fin de course Nord (3)
  pinMode(Fdc_S, INPUT_PULLUP);  // declare la pin du fin de course Sud (4)
  pinMode(Fdc_E, INPUT_PULLUP);  // declare la pin du fin de course Est (11)
  pinMode(Fdc_O, INPUT_PULLUP);  // declare la pin du fin de course Ouest (12)
  // ValLdrEst = analogRead(PinLdrEst);     // lire et calculer les valeurs
  // ValLdrOuest = analogRead(PinLdrOuest);
  // ValLdrHaut = analogRead(PinLdrHaut);
  // ValLdrBas = analogRead(PinLdrBas);
  // delta_O_E = ValLdrEst - ValLdrOuest;
  // delta_H_B = ValLdrHaut - ValLdrBas;
}
void loopvent() {
  //Periode de temps
 // Serial.print(F("La periode de temps  du vent est de "));
//  Serial.print(delta_temps, 2);  //sera toujours == 1
//  Serial.println(F(" s."));

  //Nombre d'Aimant
//  Serial.print(F("Le nombre d'aimants detectes est de "));  //supposons 30 ils/aimants
 // Serial.print(nombre_aimant);
//  Serial.println(F(" aimants."));

  //Nombre de tours
  NombreTour = nombre_aimant / 2;  //nombre de tours=30/3=10tr/s
  //affichage du nombre de tours
//  Serial.print(F("Le nombre de tours  est de "));
//  Serial.print(NombreTour);
 // Serial.println(F(" tours/s."));

  //convertion periode -> fréquense
  NombreTourSec = (NombreTour / delta_temps);
  //affichage du nombre de tours/s
//  Serial.print(F("Le nombre de tours en 1 sec est de "));
 // Serial.print(NombreTourSec);
 // Serial.println(F(" tours/s."));
  //FEtalonage est initialisée à 1
  //vitesse du vent
  vitesseVentms = 2 * pi * RayonDesBras * NombreTourSec * FEtalonage;  // 2/pi*0.025*10=1.57m/s
  vitesseVentkmh = vitesseVentms * 3600 / 1000;                        // (1.57*3600)/1000=5;562Km/h
  //affichage de la vitesse
//  Serial.print(F("La vitesse du vent est de "));
 // Serial.print(vitesseVentms);
 // Serial.print(F(" m/s soit "));
//  Serial.print(vitesseVentkmh);
 // Serial.println(F(" km/h."));

  nombre_aimant = 0;
  millis_old = millis();  // remise à 0 du compteur pour capturer la différence de temps au prochain tour

  display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
  display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
  display.setCursor(40, 20);                           // Start at top-left corner
  display.print("MODE MARCHE   ");
  display.setCursor(0, 0);              // Déplacement du curseur en position (0,0), c'est
  display.setTextColor(SSD1306_WHITE);  // Affichage du texte en "blanc" (avec la couleur principale, en fait, car l'écran monochrome peut être coloré)
  display.print(F("vent "));
  display.setCursor(40, 0);
  display.println(vitesseVentkmh);
  display.setCursor(80, 0);
  display.println(F("km/h."));  //sera toujours == 1

  display.setCursor(30, 50);
  display.print("amb");
  //display.print(verrou_H_B);
  display.setCursor(55, 50);
  display.print(lum_moyenne);
  display.setCursor(85, 50);
  display.println(delta_O_E);
  display.setCursor(105, 50);
  display.println(delta_H_B);
  display.setCursor(0, 8);
  display.print("FcO ");
  display.setCursor(34, 8);
  display.print("FcE ");
  display.setCursor(64, 8);
  display.print("FcN ");
  display.setCursor(95, 8);
  display.print("FcS ");

  display.display();  // Transfert le buffer à l'écran
}

// £££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££££

void loop() {
  delta_temps = (millis() - millis_old);
//  Serial.println(delta_temps, 2);
  delta_temps = float(delta_temps / 1000);
//  Serial.println(delta_temps, 2);
  //delta_temps = float((micros() - micros_old) / 1000000);      //>= et non == car si dépassement
  if (delta_temps >= 1)  // on n'appellera jamais loopvent
  {                      //boucle delta exécutée 1 fois par seconde
    loopvent();
  }

  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ init LDR et FDC µµµµµµµµµµµµµµµ
  int ValLdrHaut = analogRead(PinLdrHaut);
  int ValLdrBas = analogRead(PinLdrBas);
  int ValLdrOuest = analogRead(PinLdrOuest);
  int ValLdrEst = analogRead(PinLdrEst);  // lire et calculer les valeurs
  ValLdrHaut = (ValLdrHaut + Cp_N);
  ValLdrBas = (ValLdrBas + Cp_S);
  ValLdrOuest = (ValLdrOuest + Cp_O);
  ValLdrEst = (ValLdrEst + Cp_E);

  int deltaEO = ValLdrEst - ValLdrOuest;  // ctrl delta entre Est et Ouest
  deltaEO = abs(deltaEO);                 //utile, positive les valeurs negatives
  int deltaHB = ValLdrHaut - ValLdrBas;   // ctrl delta entre Haut et Bas
  deltaHB = abs(deltaHB);
  memo_Fdc_N = digitalRead(Fdc_N);  //
  memo_Fdc_S = digitalRead(Fdc_S);  //
  memo_Fdc_O = digitalRead(Fdc_O);
  memo_Fdc_E = digitalRead(Fdc_E);
  int Etat_Fdc_N = digitalRead(Fdc_N);  // lecture de la valeur du fin de course Nord (pin 3)
  int Etat_Fdc_S = digitalRead(Fdc_S);  // lecture de la valeur du fin de course Sud (pin 4)
  int Etat_Fdc_O = digitalRead(Fdc_O);  // lecture de la valeur du fin de course Ouest (pin 12)
  int Etat_Fdc_E = digitalRead(Fdc_E);  // lecture de la valeur du fin de course Est (pin 11)

  int luminosite_actuelle = ValLdrEst + ValLdrOuest + ValLdrHaut + ValLdrBas;  // établit la luminosité ambiante
  luminosite_actuelle = luminosite_actuelle / 4;

  display.clearDisplay();
  display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
  display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
                                                       // display.setCursor(40, 20);                           // Start at top-left corner
                                                       // display.print("MODE MARCHE   ");
  display.setCursor(0, 0);                             // Déplacement du curseur en position (0,0), c'est
  display.print(F("vent "));
  display.setCursor(40, 0);
  display.println(vitesseVentkmh);
  display.setCursor(80, 0);
  display.println(F("km/h."));  //sera toujours == 1

  display.setCursor(0, 20);  // Start at x 0/ y 20
  display.print("H");
  display.println(ValLdrHaut);
  display.print("B");
  display.println(ValLdrBas);
  display.print("E");
  display.println(ValLdrEst);
  display.print("O");
  display.println(ValLdrOuest);
  display.print("v4");
  display.setCursor(40, 20);
  display.print("MODE MARCHE   ");
  display.setCursor(30, 50);
  display.print("amb");
  display.setCursor(55, 50);
  display.print(luminosite_actuelle);
  display.setCursor(85, 50);
  display.println(deltaEO);
  display.setCursor(105, 50);
  display.println(deltaHB);
  display.setCursor(0, 8);
  display.print("FcO ");
  display.print(memo_Fdc_O);
  display.setCursor(32, 8);
  display.print("FcE ");
  display.print(memo_Fdc_E);
  display.setCursor(64, 8);
  display.print("FcN ");
  display.print(memo_Fdc_N);
  display.setCursor(96, 8);
  display.print("FcS ");
  display.print(memo_Fdc_S);
  display.display();



//  Serial.print(F("fdc N "));
//  Serial.println(memo_Fdc_N);
//  Serial.print(F("fdc E "));
//  Serial.println(memo_Fdc_E);
//  Serial.print(F("fdc O "));
//  Serial.println(memo_Fdc_O);
//  Serial.print(F(" fdc S "));
//  Serial.println(memo_Fdc_S);
//  Serial.print(F(" delta_EO "));
//  Serial.println(deltaEO);
//  Serial.print(F(" delta_HB "));
//  Serial.println(deltaHB);
//  Serial.print(F("   H "));
//  Serial.println(ValLdrHaut);
 // Serial.print(F("   B "));
 // Serial.println(ValLdrBas);
//  Serial.print(F("   E "));
//  Serial.println(ValLdrEst);
 // Serial.print(F("   O "));
//  Serial.println(ValLdrOuest);
//  Serial.print(F(" verrou_E_O "));
//  Serial.println(verrou_E_O);
 // Serial.print(F(" verrou_H_B "));
 // Serial.println(verrou_H_B);
 // Serial.print(F(" reveil "));
  Serial.print(F("  tempsecoule "));
  Serial.println( tempsecoule);
   Serial.println(Minuteriedepart);
   Serial.println(Raz_Minuteriedepart);
   
  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ etat des lieux   µµµµµµµµµµµµµµµ

 // Serial.print(F("  luminosite_actuelle "));
 // Serial.print(luminosite_actuelle);
  //Serial.print(F("  "));

 //securité courroie ou blocage
  
  while( tempsecoule > 120000 && ((EST, HIGH)||(OUEST, HIGH) && (deltaEO > Ecart) )) { // lecture tout les 2.5  minutes(minuterie1)
   digitalWrite(Moteur_H, 255);
   
    //display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
   // display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
   // display.setCursor(40, 30);                           // Start at top-left corner
   // display.print("ERREUR MOTEUR ");                      // le moteur horizontal tourne dans le vide
   // display.display();
   Serial.print(F(" ERREUR MOTEUR H "));
    Serial.println(Minuteriedepart); 

  }
  // µµµµµµµµµµµµµµµµµµµµµ Arret sur fin de course   µµµµµµµµµµµµµµµ

  if (memo_Fdc_E == LOW) {
    digitalWrite(EST, LOW);  // EST    Moteur H arret
    //analogWrite(Moteur_H, LOW);// A voir mit en repos pour cause de bug
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 30);                           // Start at top-left corner
    display.print("STOP FDC EST ");                      // EST le moteur vertical est en fdc Est
    display.display();
    tempsecoule = 0;
     Raz_Minuteriedepart = Minuteriedepart;
   
  //  Serial.println(F(" STOP FDC EST"));
  }
  if (memo_Fdc_O == LOW) {
    digitalWrite(OUEST, LOW);  // EST    Moteur H ARRET
    //analogWrite(Moteur_H, LOW);//A voir mit en repos pour cause de bug
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 30);                           // Start at top-left corner
    display.print("STOP Fc OUEST");                      // EST le moteur vertical est en fdc ouest
    display.display();
    tempsecoule = 0;
     Raz_Minuteriedepart = Minuteriedepart;
  //  Serial.println(F(" STOP FDC OUEST"));
  }
  if (memo_Fdc_N == LOW) {
    digitalWrite(HAUT, LOW);                             // EST    Moteur V arret
                                                         // analogWrite(Moteur_V, LOW);//A voir mit en repos pour cause de bug
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 40);                           // Start at top-left corner
    display.print("STOP Fdc HAUT");                      // EST le moteur vertical est en fdc haut
    display.display();
  //  Serial.println(F(" STOP FDC HAUT"));
  }
  if (memo_Fdc_S == LOW) {
    digitalWrite(BAS, LOW);  // EST    Moteur V ARRET
    //analogWrite(Moteur_V, LOW);// A voir mit en repos pour cause de bug
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 40);                           // Start at top-left corner
    display.print("STOP Fdc BAS ");                      // EST le moteur vertical est en fdc BAS
    display.display();
   // Serial.println(F(" STOP FDC BAS"));
  }

  if ((luminosite_actuelle >= nuit) && (deltaEO <= hysteresis_H))  // modifié
  {

     digitalWrite(EST, LOW);       // EST
     digitalWrite(OUEST, LOW);     // OUEST
     digitalWrite(Moteur_H, LOW);
   // Serial.println(F(" position Horizontale"));
    //  Serial.println(deltaEO);
    //  Serial.println(deltaHB);
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 30);                           // Start at 40/40
    display.print("HORIZONTAL OK ");

    display.display();
    tempsecoule =0;
     Raz_Minuteriedepart = Minuteriedepart;
  }
  if ((luminosite_actuelle >= nuit) && (deltaHB <= hysteresis_V))  // modifié
  {
    digitalWrite(BAS, LOW);       //  BAS
    digitalWrite(HAUT, LOW);     // HAUT
    digitalWrite(Moteur_V, LOW);  // Moteurs V en position arret

   // Serial.println(F(" position verticale"));
    //  Serial.println(deltaEO);
    //  Serial.println(deltaHB);

    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 40);                           // Start at position
    display.print("VERTICAL OK   ");

    display.display();
  }
  // arret moteur idem que position ok mais pour les deux
  if ((luminosite_actuelle <= lumi && luminosite_actuelle >= nuit) || (deltaEO <= hysteresis_H && deltaHB <= hysteresis_V))  //          modifié
  {
    digitalWrite(BAS, LOW);       //  BAS
    digitalWrite(HAUT, HIGH);     // HAUT
    digitalWrite(EST, LOW);       // EST
    digitalWrite(OUEST, LOW);     // OUEST
    digitalWrite(Moteur_V, LOW);  // les 2 Moteurs sont arrétés !
    digitalWrite(Moteur_H, LOW);
   // Serial.println(F(" arret moteurs"));
   // Serial.println(deltaEO);
  //  Serial.println(deltaHB);
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 30);                           // Start at top-left corner
    display.print("ARRET HORIZONT");

    display.setCursor(40, 40);  // Start at position
    display.print("ARRET VERTICAL");

    display.display();
     tempsecoule = 0; // remise a zero  (millis)
      Raz_Minuteriedepart = Minuteriedepart;
  }
  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ orientation des panneaux µµµµµµµµµµµµµµµ
  //si pas de nuages et + de soleil à l'ouest et ecart tolerable est dépassé et pas en butée ouest
  if (luminosite_actuelle >= lumi) {
    if (ValLdrEst < ValLdrOuest && deltaEO > hysteresis_H && (Etat_Fdc_O == HIGH)) {
      
      digitalWrite(EST, LOW);     // EST
      digitalWrite(OUEST, HIGH);  // OUEST   Moteur V tourne vers l'OUEST
      analogWrite(Moteur_H, 220);
    //  Serial.println(F(" Est < marche Ouest"));
      display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
      display.setCursor(40, 20);                           // Start at
      display.print("MODE MARCHE ");
      display.setCursor(40, 30);  // Start at
      display.print("MARCHE OUEST  ");
      

      display.display();
     
      Minuteriedepart = millis(); // ecriture de la valeur de la minuterie1 en milliseconde
      if (Minuteriedepart - Raz_Minuteriedepart > 120000) {// tempsecoule =(millis() - Minuteriedepart); // lecture temps
       
        tempsecoule = 121000 ;
        Raz_Minuteriedepart = Minuteriedepart;
      }  
    }
    //si pas de nuages et + de soleil à l'est et ecart tolerable est dépassé et pas en butée est
    else if (ValLdrEst > ValLdrOuest && deltaEO > hysteresis_H && (Etat_Fdc_E == HIGH)) {
     
      digitalWrite(EST, HIGH);   // EST    Moteur V tourne vers l'EST
      digitalWrite(OUEST, LOW);  // OUEST
      analogWrite(Moteur_H, 220);
      display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
      display.setCursor(40, 30);                           // Start at top-left corner
      display.print("MARCHE EST    ");
      
      display.display();
       Minuteriedepart = millis(); // ecriture de la valeur de la minuterie1 en milliseconde
       if (Minuteriedepart - Raz_Minuteriedepart > 120000) {  // tempsecoule =(millis() - Minuteriedepart); // lecture temps
                                                                    
       tempsecoule = 121000 ;
       Raz_Minuteriedepart = Minuteriedepart;
      }  
      
    //  Serial.println(F("marche Est > Ouest "));
    }

    // SENS vertical
    //si pas de nuages et + de soleil en haut et ecart tolerable est dépassé et pas en butée haute
    if (ValLdrHaut > ValLdrBas && deltaHB > hysteresis_V && (Etat_Fdc_N == HIGH)) {
      digitalWrite(BAS, LOW);    //  BAS
      digitalWrite(HAUT, HIGH);  // HAUT     Moteur H tourne vers le HAUT
      analogWrite(Moteur_V, 255);
      display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
      display.setCursor(40, 40);                           // Start at top-left corner
      display.print("MARCHE MONTE  ");

      display.display();
    //  Serial.println(F(" monte Hauteur < Bas"));
    }
    //si pas de nuages et + de soleil en bas et ecart tolérable est dépassé et pas en butée basse
    else if (ValLdrBas > ValLdrHaut && deltaHB > hysteresis_V && (Etat_Fdc_S == HIGH) && vitesseVentkmh < 5 ) {
      digitalWrite(BAS, HIGH);  // BAS    Moteur H tourne vers le BAS
      digitalWrite(HAUT, LOW);  //HAUT
      analogWrite(Moteur_V, 255);
      display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
      display.setCursor(40, 40);                           // Start at top-left corner
      display.print("MARCHE DESCENT");

      display.display();
    //  Serial.println(F(" Hauteur >marche Bas "));
    }
  }
  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ trop de vent mise à l'hrizontal des panneaux µµµµµµµµµµµµµ

  //
  if (vitesseVentkmh > 5 && (Etat_Fdc_N == HIGH)) {
    digitalWrite(BAS, LOW);    // BAS
    digitalWrite(HAUT, HIGH);  // HAUT     Moteur H tourne vers le HAUT
    analogWrite(Moteur_V, 255);
    display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
    display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
    display.setCursor(40, 20);                           // Start at top-left corner
    display.print("MISE HORS VENT");
    display.setCursor(40, 40);  // Start at top-left corner
    display.print("VENT  MONTE");

    display.display();

   // Serial.println(F(" monte vent"));
  }
  // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ il fait nuit µµµµµµµµµµµµµ
  if (luminosite_actuelle < (nuit + hysteresis))  //si Est < 110, il fait nuit, retour à l'est
  {
    memo_Fdc_E = digitalRead(Fdc_E);
    memo_Fdc_N = digitalRead(Fdc_N);
    // verrou_E_O = true;  //s'il fait nuit,axe Est/Ouest va en garage et se verouille
    verrou_H_B = true;
    reveil = true;  //sera déverrouillé



    if (memo_Fdc_E) {
      digitalWrite(EST, HIGH);   // EST    Moteur H tourne vers l'EST
      digitalWrite(OUEST, LOW);  // OUEST
      analogWrite(Moteur_H, 255);
      digitalWrite(BAS, LOW);    //  BAS
      digitalWrite(HAUT, HIGH);  // HAUT     Moteur H tourne vers le HAUT
      analogWrite(Moteur_V, 255);
      
      display.setTextSize(1);  // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
      display.setCursor(40, 20);       // Start at top-left corner
      display.print("MODE RETOUR  ");  // EST le moteur vertical va en fdc Est
      display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
      
      display.setCursor(40, 40);                           // Start at top-left corner
      display.print("MARCHE MONTE  ");
      display.display();
    //  Serial.println(F(" if marche retour est"));
    } else {
      verrou_E_O = true;       //s'il fait nuit,axe Est/Ouest va en garage et se verouille
                               //sera déverrouillé en ligne
      digitalWrite(EST, LOW);  // EST le moteur vertical est en fdc Est
      digitalWrite(Moteur_H, LOW);

      display.setTextSize(1);  // Taille des caractères (1:1, puis 2:1, puis 3:1)
      display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
      display.setCursor(40, 30);  // Start at top-left corner
      display.print("RETOUR FDC EST");

      display.display();
     // Serial.println(F(" bon retour est"));
    }
    // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ il fait jour µµµµµµµµµµµµµ
    if ((luminosite_actuelle > nuit) && (vitesseVentkmh < 10) && (reveil == true))  // si H > 100; il ne fait pas nuit et pas de vent
    {
      memo_Fdc_S = digitalRead(Fdc_S);
     // Serial.println(F(" reveil"));                                // il fait jour au reveil ou à la mise sous tension.
      if (memo_Fdc_S == HIGH)                                      // reveil est passé à true lors de la mise en garage en ligne
      {                                                            // on passe dans ce if puis le while
        while ((memo_Fdc_S) || (deltaHB <= hysteresis_V))  // tant que le moteur n'est pas sur le fdcbas
        {
          digitalWrite(BAS, HIGH);  // BAS    Moteur V tourne vers le BAS
          digitalWrite(HAUT, LOW);  //HAUT
          analogWrite(Moteur_V, 255);
          display.setTextSize(1);                              // Taille des caractères (1:1, puis 2:1, puis 3:1)
          display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);  // Draw white text
          display.setCursor(40, 40);                           // Start at top-left corner
          display.print("MARCHE DESCENT");

          display.display();  // BAS  moteur bas en marche
                              // memo_Fdc_S = digitalRead(Fdc_S);       // lecture du fdcbas
           memo_Fdc_S = digitalRead(Fdc_S);                    // int deltaHB = ValLdrHaut - ValLdrBas;  // ctrl delta entre Haut et Bas
        }
        reveil = false;  // on est sur le fdcbas, on ne passera plus dans le if
      //  Serial.println(F(" bon reveil"));
      }
      // µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ
      if ((ValLdrBas - ValLdrHaut > hysteresis_V) && (memo_Fdc_S) && vitesseVentkmh < 5 ) {
        digitalWrite(BAS, HIGH);  //  moteur vers le bas
        analogWrite(Moteur_V, 255);
      } else {
        if (((ValLdrBas - ValLdrHaut) < (hysteresis_V)) || (!memo_Fdc_S)) {
          digitalWrite(BAS, LOW);  // Eteindre le moteur
        }
      }

      if ((ValLdrHaut - ValLdrBas > hysteresis_V) && (memo_Fdc_N)) {
        digitalWrite(HAUT, HIGH);  // moteur_V
        analogWrite(Moteur_V, 255);
      } else {
        if (((ValLdrHaut - ValLdrBas) < (hysteresis_V)) || (!memo_Fdc_N)) {
          digitalWrite(HAUT, LOW);  // Eteindre le moteur_V
          digitalWrite(Moteur_V, LOW);
        }
      }
    } else {
      if (ValLdrHaut < (nuit + hysteresis))  // Si H < 100, il fait nuit, retour en haut
      {
        if (memo_Fdc_N) {
          digitalWrite(HAUT, HIGH);
          analogWrite(Moteur_V, 255);
          Serial.println(F(" retour haut"));
          display.setTextSize(1);  // Taille des caractères (1:1, puis 2:1, puis 3:1)
          display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
          display.setCursor(40, 40);  // Start at top-left corner
          display.print("MARCHE MONTE  ");
          Serial.println(F(" monte retour est"));
          display.display();
        } else {
          digitalWrite(HAUT, LOW);
          digitalWrite(Moteur_V, LOW);
        }
      }
    }
    //au premier passage dans le if, le verrou de l'axe sera supprimé
    if (((ValLdrBas - ValLdrHaut) < (hysteresis_V))      //200-190)<50-10
        && ((ValLdrHaut - ValLdrBas) < (hysteresis_V)))  //190-200 <50-10
    {
      verrou_E_O = false;  //a été verouillé en ligne 136
      reveil = true;
    }
   // Serial.println(F(" en bas "));
  }
  delay(250); //permet de regler la cadence de lecture des valeurs
}
2

:warning:

Post mis dans la mauvaise section, on parle anglais dans les forums généraux. ➜ déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans « Les bonnes pratiques du Forum Francophone”

3

Merci mais comment on met dans le francophone ?Je pensais y etre

4

Vous choisissez Français comme catégorie en postant.

J’ai déplacé le post donc c’est au bon endroit maintenant mais on ne comprend pas bien ce que vous demandez…

5

le programme fonctionnait mis au point sur une maquette et puis lors du transfert sur un autre il se met en carafe plus d ecran sauf si j enleve ce que j avais mit comme tempo pour la surveillance du temps de marche et j arrive plus a le faire fonctionner sans pourtant je l avais sur un nano avec ecran pour test donc je l ai vu fonctionner avec le serial qui est actif et maintenant plus rien donc je comprend pas et meme si je le remet sur le meme ne fonctionne plus

6

Le SSD1306 est gourmand en mémoire, peut être vous dépassez ce qui est dispo

7

pourtant lors de la mise au point cela fonctionnait c est d ailleurs le pourquoi j ai supprimé les serials qui servaient pour la mise au point 69 pour le programme 42 pour la memoire

8

En % ?

Quel arduino ?

Si vous revenez au code précédent est. E que ça fonctionne ?

9

oui en %
si j enleve minuteriedepart l ecran revient mais je perd la partie surveillance courroie ou blocage
pourtant comme dit je l avais mit au point sur la meme maquette est ce que j ai pu endommager le nano en mettant le programme sur un lgt328 entre
mais bon sans il fonctionne donc le nano ne peut pas etre defectueux
Une mise a jour entre qui cause le probleme?

10

Je ne comprends pas la phrase… (ni le reste. Mettez des points de virgules passez à la ligne, expliquez avec plus de détail ce qui ne fonctionne pas, ce que vous voyez et …)

11

je l avais verse sur un lgtbf328p nano 3
mais bon il marchait aussi les fois precedantes
comme dit j ais fait au moins 15 televersements sur ma maquette pour la mise au point c est pour cela que je plane
la seule chose qui manque c est les cartes moteurs mais mème sur cette maquette impossible de le faire fonctionner comme avant

12

Avec la minuterie plus d ecran plus de serial
sans, donc programme de base l ecran fonctionne tout est la
et pourtant je l avais mis au point sur cette maquette donc il y avait le serial l ecran et le programme qui fonctionnait et la
rien donc je ne comprend pas

13

Oui mais la mémoire pour l'écran n'est allouée qu'après l'initialisation de l'afficheur.
Pour un écran monochrome 128 x 64, le buffer d'image fait
128 * 64 / 8 = 1024 soit la moitié de la RAM d'un ATmega328.
A quoi il faut ajouter les ressources utilisées par la librairie Adafruit_GFX.

Le fait que le code plante lorsque tu actives la librairie graphique je pense que c'est la conséquence de ça:

  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
  //  Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ;  // Don't proceed, loop forever
  }

Si l'allocation mémoire échoue le code entre dans une boucle infinie.

J'ai peut-être parcouru le code un peu vite mais il me semble que tu n'utilises pas les fonctions graphique mais uniquement le texte et en plus en taille 1. Il y a une librairie, dont j'ai oublié le nom, qui permet de ne travailler qu'en mode texte. Elle travaille sans buffer graphique et du coup demande moins de ressources.

Edit
C'est la librairie U8g2 de Olikraus. Tu peux l'installer depuis le gestionnaire de librairie de l'IDE.
Cette librairie contient une variante, U8x8 qui ne gère que le texte sans buffer graphique car elle écrit directement dans la mémoire de l'afficheur..

14

Tu as raison a part un point je n utilise pas gfx
Je l avais désactivé a la base ainsi que spi et cela fonctionnait aussi
Comme dit cela fonctionnait je l ai vu il y a eu une mise a jour des cartes serait il possible que ce soit cela le problème ?

15

Adafruit_SSD1306 ne peut pas fonctionner sans GFX qui fournit toutes les fonctions de tracé.
Adafruit_SSD1306 ne fournit que les fonctions bas niveau : initialisation de l'afficheur, transfert du buffer à l'afficheur et quelques fonctions d'accélération fournies par le driver d'écran comme le scroll, l'inversion de contraste, .....
En fait Adafruit_SSD1306 hérite de GFX, voilà la définition de la classe
class Adafruit_SSD1306 : public Adafruit_GFX {

Oui, mais il n'y a pas de miracle si ça fonctionne quand tu désactives GFX et SPI c'est que quelque part cela a été fait pour toi.
Par exemple dans Adafruit_SSD1306.h

#include <Adafruit_GFX.h>
#include <SPI.h>
#include <Wire.h>

Je pense que c'était tombé en marche parce que tu devais être très très très limite en RAM.

16

Il faudrait tester sur une MEGA par exemple, ça donnerait une idée si c’est un souci mémoire (ou regarder au run time ce qui est alloué)

17

J'ai décommenté le Serial.print et ajouté une mesure de la RAM disponible dans

  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    Serial.print(freeMemory());
    for (;;)
      ;  // Don't proceed, loop forever
  }

On affiche

SSD1306 allocation failed
1151

Donc c'est sans appel on manque cruellement de mémoire. Si on retire les 1024 octets du buffer il ne reste plus que 127 octets de RAM.

Pour faire tourner ce code il faudrait soit passer sur un processeur avec plus de RAM soit changer de librairie comme suggéré précédemment.

18

Il s'agit de celle-ci :

19

Il y a aussi celle-là mais celle à laquelle je pensais c'est U8x8, un sous-ensemble de U8g2, que j'avais citée dans l'edit de mon message.

20

Vous aviez raison j ai atteins la limite par contre ce qui m a induit en erreur c est que cela fonctionnait ce qui ma mit la puce a l oreille suite a la remarque de fdufnews c est que j arrivais déjà plus a afficher le mode erreur .Arduino c est très light en graphique et pourtant c est chouette l ecran .JJ ai donc décider de faire une cure d amaigrissement au programme encore merci et moi qui voulais encore rajouter un mode bouton manuel je crois que c est foutu a moins de mettre une librairie plus soft mais je ne maîtrise pas assez cela m a prit 4H00 pour me rendre compte que millis ne se remettait pas tout seul a zéro et qu au bout de 3minutes au prochain démarrage je le mettait en défaut