Probleme assez complexe d'origine electrique il me semble

[scorius]

Bonjour, j'ai un programme arduino assez long pour un BabyFOOt.

Le programme fonctionne vraiment bien et ce qu'il fait c'est:
Lorsque un but est marqué, un capteur ultrason détecte la balle d'un camp et incrémente le score sur un afficheur digital et vice versa pour l'autre équipe.
Il y a des boutons poussoir ajouté pour activer des barrières derrière le goal avec des servo moteur pour agrémenter la partie et pleins d'autres choses. Aussi il y avait de la musique avec un buzzer que j'ai enlever pour faciliter la lecture du code sinon ce serait trop long.

Mon problème est que j'ai simplement voulu ajouter la touche finale avec un ruban led 2812B pour animer un peu visuellement lors des buts marqué.

Mon animation LED fonctionne bien indépendamment sur un programme à part mais lorsque j'ai voulu l'intégrer au programme principal (et j'ai chercher un bon moment avec de poster ce post), j'ai remarque que lorsqu'un but est marqué, (normalement il y a le buzzer qui fait sa petite musique) , hé bien les LEDs s'allument correctement mais pendant l'allumage de ces LEDs, je pense que l'alimentation de la commande des servo moteur se désactive pendant l'animation des lumière LED car les servo moteurs se relâchent et à la fin de l'animation des LEDs, le moteur se réactivent, et je ne souhaite pas ça !! (J'ai fait une mesure avec un multimètre)

Les servos moteur sont pourtant sur une Alimention externe 5V / 10A/ 50W et les LED sont sur une autre Alimentation Externe 5V/ 20A/ 200W.

L'activation des LEDs viens dès la partie:

if (distance > 0 && distance < 4 && !objectDetected) {
  // Objet détecté à proximité et aucune détection précédente
  objectDetected = true; // Marquer l'objet comme détecté
  
  // Effectuer l'incrémentation et l'affichage
  counterR++;
  if (counterR >= sizeof(tableR) / sizeof(tableR[0])) {
    counterR = 0;
  }
  DisplayR(counterR);
  
// Répéter deux fois la boucle complète

Objet détecté: est lorsque la balle est détecté dans le but et la boucle du RUBANLED commence à partir de : // Répéter deux fois la boucle complète

Voici le Code

#include <Adafruit_NeoPixel.h>

#define RUBANLED 150 // Total de LEDs
#define DATA_PIN 40
Adafruit_NeoPixel strip(RUBANLED, DATA_PIN, NEO_GRB + NEO_KHZ800);

#include <Servo.h>
#include <OneButton.h>
Servo myservoBonusGoalR;
Servo myservoGamelleR;
Servo myservoBonusGoalB;
Servo myservoGamelleB;
Servo myservoBallesRebond;
Servo myservoBallSurprise;

// Pin assignations
int triggerPinR = 14;  // Ultrasonic sensor trigger pin
int echoPinR = 15;     // Ultrasonic sensor echo pin
int buttonBonusGoalR = 6;
bool buttonPressedBonusGoalR = false;
int buttonCountdBonusGoalR = 0; // 
int buttonGamelleR = 7;   // Button Gamelle
bool buttonPressedGamelleR = false;
int data_R = 9;   //74HC595  pin D07 DS
int latch_R = 10;  //74HC595  pin D08 STCP
int clock_R = 11; //74HC595  pin D09 SHCP
int triggerPinB = 2;      // Ultrasonic sensor2 trigger pin
int echoPinB = 3;         // Ultrasonic sensor2 echo pin
int buttonreset = 29;   // Button reset
int dataB_B = 21;   //74HC595  pin D21 DS
int latch2_B = 22;  //74HC595  pin D22 TCP
int clock2_B = 23; //74HC595  pin D23 SHCP
int buttonBonusGoalB = 18;
bool buttonPressedBonusGoalB = false;
int buttonCountdBonusGoalB = 0; // 
int buttonGamelleB = 19;   // Button Gamelle
bool buttonPressedGamelleB = false;
int PosMyservoBonusGoalB = 0;
int PosMyservoBonusGoalR = 0;
int PosMyservoGamelleR = 0;
int PosMyservoGamelleB = 0;
int PosMyservoBallesRebond = 0;
int PosMyservoBallSurprise = 200;
const int buzzerPin = 28;
const int VerinBas = 36;      // Broche IN1 du module L298N
const int VerinHaut = 37;       // Broche IN2 du module L298N
const int BoutonVerinMonteManu = 38;   // Broche du bouton poussoir
const int BoutonVerinDescendManu = 39;   // Broche du bouton poussoir
bool notesdeFinJouee  = false;


//pour eviter les delais des verins
unsigned long previousMillisDescendreVerinBas = 0;
unsigned long previousMillisMonterVerinHaut = 0;
const unsigned long delaiDescendreVerin  = 1200; // Durée de la descente en millisecondes
const unsigned long delaiMonterVerin  = 1400; // Durée de la montée en millisecondes




unsigned long previousMillisDisplayR = 0;
const long incrementInterval = 5000;  // Intervalle de temps pour incrémenter l'afficheur gamelle
unsigned long previousMillisDisplayB = 0;
const long incrementInterval2 = 5000;  // Intervalle de temps pour incrémenter l'afficheur gamelle


// DisplayR digit values
unsigned char tableR[] = {
0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f,0x6f|0x80,0x7f|0x80,0x07|0x80,0x7d|0x80,0x6d|0x80,0x66|0x80,0x4f|0x80,0x5b|0x80, 0x06|0x80,
};  
// DisplayB digit values for the second display (anodes common)
unsigned char tableB[] = {
 ~0x3f, ~0x06, ~0x5b, ~0x4f, ~0x66, ~0x6d, ~0x7d, ~0x07, ~0x7f, ~0x6f, ~0x77, ~0x7c, ~0x39, ~0x5e, ~0x79, ~0x71,~0x06, ~0x5b, ~0x4f, ~0x66, ~0x6d, ~0x7d, ~0x07, ~0x7f, ~0x6f,~(0x6f|0x80),~(0x7f|0x80),~(0x07|0x80),~(0x7d|0x80),~(0x6d|0x80),~(0x66|0x80),~(0x4f|0x80),~(0x5b|0x80), ~(0x06|0x80),
};


// DisplayBN digit values for the second display (anodes common)
unsigned char tableBN[] = {
 0x3f|0x80, 0x06|0x80, 0x5b|0x80, 0x4f|0x80, 0x66|0x80};

// Current value of the display
unsigned char counterR = 0;
unsigned char counterB = 0;

unsigned long previousMillisBonusGoalR = 0; //gardre en memoire le temp pour le SERVO MOTEUR 1
const long intervalBonusGoalR = 100000; //gardre en memoire le temp pour le SERVO MOTEUR 1
unsigned long previousMillisGamelleR = 0; //gardre en memoire le temp pour le SERVO MOTEUR 2
const long intervalGamelleR = 100000; //gardre en memoire le temp pour le SERVO MOTEUR 2

unsigned long previousMillisBonusGoalB = 0; //gardre en memoire le temp pour le SERVO MOTEUR 3
const long intervalBonusGoalB = 100000; //gardre en memoire le temp pour le SERVO MOTEUR 4
unsigned long previousMillisGamelleB = 0; //gardre en memoire le temp pour le SERVO MOTEUR 3
const long intervalGamelleB = 100000; //gardre en memoire le temp pour le SERVO MOTEUR 4


const byte boutonRelai_1R = 12;
const byte relai_1R = 8;
const byte ledVerteR = 32;
const byte ledRougeR = 33;
const unsigned long tempo_Bouton_relai_1R = 0;
unsigned long tempo_Bouton_relai_1R_maintenu = 0;

const byte boutonRelai_1B = 13;
const byte relai_1B = 20;
const byte ledVerteB = 34;
const byte ledRougeB = 35;
const unsigned long tempo_Bouton_relai_1B = 0;
unsigned long tempo_Bouton_relai_1B_maintenu = 0;

const unsigned long dureeSurchargeB = 25000; // Durée du délai en millisecondes
const unsigned long dureeSurchargeR = 25000; // Durée du délai en millisecondes
bool surchargeActiveB = false;
bool surchargeActiveR = false;
unsigned long tempsDebutSurchargeB = 0;
unsigned long tempsDebutSurchargeR = 0;

OneButton OneboutonRelai_1R(boutonRelai_1R);
OneButton OneboutonRelai_1B(boutonRelai_1B);
bool relaiActif_1R = false;
bool relaiActif_1B = false;
unsigned long tempsDebutAppuiRelai_1R = 0;
unsigned long tempsDebutAppuiRelai_1B = 0;

bool disableRelai_1B = false;
bool disableRelai_1R = false;

unsigned long previousMillisBallSurprise = 0;

unsigned char previousCounterR = -1;
unsigned char previousCounterB = -1;

const byte ledBleuR = 24;
const byte ledJauneR = 25;
const byte ledBleuB = 26;
const byte ledJauneB = 27;



void debutAppuiLongRelai_1R() {
  if (disableRelai_1R) {
    return;
   }{ if (!surchargeActiveR) {
  tempsDebutAppuiRelai_1R = millis();
  digitalWrite(relai_1R, LOW);
  relaiActif_1R = true;
  tempo_Bouton_relai_1R_maintenu = random(2000, 5001); // Durée aléatoire entre 3 et 10 secondes
  }
}
}
void debutAppuiLongRelai_1B() {
  if (disableRelai_1B) {
    return;
  }{ if (!surchargeActiveB) {
    tempsDebutAppuiRelai_1B = millis();
    digitalWrite(relai_1B, LOW);
    relaiActif_1B = true;
    tempo_Bouton_relai_1B_maintenu = random(2000, 5001); // Durée aléatoire entre 3 et 10 secondes
  }
}
}

void finAppuiLongRelai_1R() {
  digitalWrite(relai_1R, HIGH);
  relaiActif_1R = false;
}

void finAppuiLongRelai_1B() {
  digitalWrite(relai_1B, HIGH);
  relaiActif_1B = false;
}

void setup() 

{
  Serial.begin(9600);
  myservoBonusGoalR.attach(4);
  myservoGamelleR.attach(5);
  myservoBonusGoalB.attach(16);
  myservoGamelleB.attach(17);
  pinMode(buttonBonusGoalR, INPUT_PULLUP);
  pinMode(buttonGamelleR, INPUT_PULLUP);
  pinMode(buttonBonusGoalB, INPUT_PULLUP);
  pinMode(buttonGamelleB, INPUT_PULLUP);
  pinMode(latch_R, OUTPUT);
  pinMode(clock_R, OUTPUT);
  pinMode(data_R, OUTPUT);
  pinMode(triggerPinR, OUTPUT);
  pinMode(echoPinR, INPUT);
  pinMode(latch2_B, OUTPUT);
  pinMode(clock2_B, OUTPUT);
  pinMode(dataB_B, OUTPUT);
  pinMode(triggerPinB, OUTPUT);
  pinMode(echoPinB, INPUT);
  pinMode(buttonreset, INPUT_PULLUP);
  
  pinMode(BoutonVerinMonteManu, INPUT_PULLUP);
  pinMode(BoutonVerinDescendManu, INPUT_PULLUP);
  pinMode(VerinBas, OUTPUT);
  pinMode(VerinHaut, OUTPUT);

  // Définir le nombre de LED et la broche de données
  strip.begin();
  // Définir la luminosité (entre 0 et 255)
  strip.setBrightness(255); // Allumer à pleine luminosité (255)
  strip.show();
  

  int PosmyservoBonusGoalR = 110;
  while (PosMyservoBonusGoalR >= 0) {
    myservoBonusGoalR.write(PosMyservoBonusGoalR);
    delay(10);
    PosMyservoBonusGoalR -= 1;
  }
  int PosmyservoGamelleR = 110;
  while (PosmyservoGamelleR >= 0) {
    myservoGamelleR.write(PosmyservoGamelleR);
    delay(10);
    PosmyservoGamelleR -= 1;
  }
  int PosMyservoBonusGoalB = 110;
  while (PosMyservoBonusGoalB >= 0) {
    myservoBonusGoalB.write(PosMyservoBonusGoalB);
    delay(10);
    PosMyservoBonusGoalB -= 1;
  }
  int PosmyservoGamelleB = 110;
  while (PosmyservoGamelleB >= 0) {
    myservoGamelleB.write(PosmyservoGamelleB);
    delay(10);
    PosmyservoGamelleB -= 1;
  }
  myservoBallesRebond.write(PosMyservoBallesRebond);
  myservoBallSurprise.write(PosMyservoBallSurprise);
   pinMode(buzzerPin, OUTPUT);
  myservoBallesRebond.attach(30);
  myservoBallesRebond.write (0);
  myservoBallSurprise.attach(42);
  myservoBallSurprise.write(30);
  delay (500);
  DisplayR(0);
  DisplayB(0);

   pinMode(ledVerteR, OUTPUT);
  digitalWrite(ledVerteR, HIGH);
  pinMode(ledRougeR, OUTPUT);
  digitalWrite(ledRougeR, LOW);
  digitalWrite(relai_1R, HIGH);
  pinMode(relai_1R, OUTPUT);
  OneboutonRelai_1R.setPressMs(tempo_Bouton_relai_1R);
  OneboutonRelai_1R.attachLongPressStart(debutAppuiLongRelai_1R);
  OneboutonRelai_1R.attachLongPressStop(finAppuiLongRelai_1R);

  pinMode(ledVerteB, OUTPUT);
  digitalWrite(ledVerteB, HIGH);
  pinMode(ledRougeB, OUTPUT);
  digitalWrite(ledRougeB, LOW);
  digitalWrite(relai_1B, HIGH);
  pinMode(relai_1B, OUTPUT);
  OneboutonRelai_1B.setPressMs(tempo_Bouton_relai_1B);
  OneboutonRelai_1B.attachLongPressStart(debutAppuiLongRelai_1B);
  OneboutonRelai_1B.attachLongPressStop(finAppuiLongRelai_1B);

  pinMode(ledBleuR, OUTPUT);
  digitalWrite(ledBleuR, HIGH);
  pinMode(ledJauneR, OUTPUT);
  digitalWrite(ledJauneR, HIGH);

  pinMode(ledBleuB, OUTPUT);
  digitalWrite(ledBleuB, HIGH);
  pinMode(ledJauneB, OUTPUT);
  digitalWrite(ledJauneB, HIGH);
  }

 
void DisplayR(unsigned char num) {
  digitalWrite(latch_R, LOW);
  shiftOut(data_R, clock_R, MSBFIRST, tableR[num]);
  digitalWrite(latch_R, HIGH);
}
void DisplayB(unsigned char num) {
  digitalWrite(latch2_B, LOW);
  shiftOut(dataB_B, clock2_B, MSBFIRST, tableB[num]);
  digitalWrite(latch2_B, HIGH);
}


void resetProgram() {
  counterR = 0;
  counterB = 0;
  DisplayR(counterR);
  DisplayB(counterB);
  disableRelai_1R = false;
  disableRelai_1B = false;
  digitalWrite(ledVerteB, HIGH);
  digitalWrite(ledVerteR, HIGH);
  myservoBallesRebond.write(0);
  delay(200);
  myservoBallSurprise.write(30);
  delay(200);
  resetServoTimers();
  buttonCountdBonusGoalR = 0; // Réinitialiser le compteur de boutons
  buttonCountdBonusGoalB = 0; // Réinitialiser le compteur de boutons
}

void resetServoTimers() {
   previousMillisBonusGoalR = 99999;
  delay(200);
  previousMillisGamelleR = 99999;
  delay(200);
  previousMillisBonusGoalB = 99999;
  delay(200);
  previousMillisGamelleB = 99999;
  delay(200);
  
}
 

void descendreVerinBas() {
  digitalWrite(VerinBas, HIGH);  // Activer le VerinBas (descendre)
    delay(00);  // Attendre 1 seconde
    digitalWrite(VerinBas, LOW);  // Désactiver le VerinBas (arrêter)
}

void monterVerinHaut() {
  digitalWrite(VerinHaut, HIGH);  // Activer le VerinHaut (Monter)
    delay(00);  // Attendre 1 seconde
    digitalWrite(VerinHaut, LOW);  // Désactiver le VerinHaut (arrêter)
}


void loop(){
unsigned long currentMillis = millis();
  

if (counterR != previousCounterR) {
    if (counterR > previousCounterR) {
      // CounterR a été incrémenté
      descendreVerinBas();
    }
    previousCounterR = counterR;
  }
  
  if (counterB != previousCounterB) {
    if (counterB > previousCounterB) {
      // CounterB a été incrémenté
      monterVerinHaut();
    }
    previousCounterB = counterB;
  }
  
  int etatBoutonVerinMonteManu = digitalRead(BoutonVerinMonteManu); // Lecture de l'état du bouton VerinMonteManu
  int etatBoutonVerinDescendManu = digitalRead(BoutonVerinDescendManu); // Lecture de l'état du bouton BoutonVerinDescendManu
  
  // Gestion du bouton VerinMonteManu
  if (etatBoutonVerinMonteManu == LOW) {
    // Si le bouton est enfoncé, monter le vérin
    delay(15);
    digitalWrite(VerinHaut, HIGH);
  } else {
    // Si le bouton est relâché, arrêter le vérin
    delay(10);
    digitalWrite(VerinHaut, LOW);
  }
  // Gestion du bouton VerinDescendManu
  if (etatBoutonVerinDescendManu == LOW) {
    // Si le bouton est enfoncé, descend le vérin
    delay(15);
    digitalWrite(VerinBas, HIGH);
  } else {
    // Si le bouton est relâché, arrêter le vérin
    delay(10);
    digitalWrite(VerinBas, LOW);
  }

   // Vérifier si l'afficheur atteint la valeur 7
  if (counterR >= 8 || counterB >= 8 || counterR >= 9 || counterB >= 9){
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillisBallSurprise >= random(500, 1501)) { // Déclencher après un délai aléatoire entre 20 et 220 secondes
      delay(200);
      myservoBallSurprise.write(PosMyservoBallSurprise);
      delay(200);
      previousMillisBallSurprise = currentMillis;
      delay(200);
    }
  }

  
  OneboutonRelai_1R.tick();
  OneboutonRelai_1B.tick();

  if (digitalRead(ledRougeB) == HIGH && !surchargeActiveB) {
    surchargeActiveB = true;
    tempsDebutSurchargeB = millis();
    delay(100);
    myservoGamelleR.write(110);
    delay(100);
  }

  


//Fin surcharge,désactivation moteur gammelleR quand surchageB
if (surchargeActiveB && millis() - tempsDebutSurchargeB >= dureeSurchargeB) {
    surchargeActiveB = false;
    digitalWrite(ledRougeB, LOW);
    digitalWrite(ledVerteB, HIGH);
    delay(100);
    int PosmyservoGamelleR = 110;
  while (PosmyservoGamelleR >= 0) {
    myservoGamelleR.write(PosmyservoGamelleR);
    delay(10);
    PosmyservoGamelleR -= 1;
  }
}


 if (digitalRead(ledRougeR) == HIGH && !surchargeActiveR) {
    surchargeActiveR = true;
    tempsDebutSurchargeR = millis();
    delay(100);
    myservoGamelleB.write(110);
    delay(100);
}
//Fin surcharge,désactivation moteur gammelleB quand surchageR
    if (surchargeActiveR && millis() - tempsDebutSurchargeR >= dureeSurchargeR) {
    surchargeActiveR = false;
    digitalWrite(ledRougeR, LOW);
    digitalWrite(ledVerteR, HIGH);
    delay(100);
    int PosmyservoGamelleB = 110;
  while (PosmyservoGamelleB >= 0) {
    myservoGamelleB.write(PosmyservoGamelleB);
    delay(10);
    PosmyservoGamelleB -= 1;
  }
}

 if (relaiActif_1R) {
    if (millis() - tempsDebutAppuiRelai_1R >= tempo_Bouton_relai_1R_maintenu) {
      digitalWrite(relai_1R, HIGH);
      relaiActif_1R = false;
      digitalWrite(ledRougeR, HIGH);
      digitalWrite(ledVerteR, LOW);     
    }
  }

  if (relaiActif_1B) {
    if (millis() - tempsDebutAppuiRelai_1B >= tempo_Bouton_relai_1B_maintenu) {
      digitalWrite(relai_1B, HIGH);
      relaiActif_1B = false;
      digitalWrite(ledRougeB, HIGH);
      digitalWrite(ledVerteB, LOW);
      
    }
  }



if (buttonCountdBonusGoalR == 0) {
    digitalWrite(ledBleuR, HIGH); // allume ledBleuR
    digitalWrite(ledJauneR, HIGH); // allume ledBleuR
  } else if (buttonCountdBonusGoalR == 1) {
    digitalWrite(ledBleuR, LOW); // eteind ledBleuR
  } else if (buttonCountdBonusGoalR == 2) {
    digitalWrite(ledJauneR, LOW); // eteind ledJauneR
  }

  if (buttonCountdBonusGoalB == 0) {
    digitalWrite(ledBleuB, HIGH); // allume ledBleuR
    digitalWrite(ledJauneB, HIGH); // allume ledBleuR
  } else if (buttonCountdBonusGoalB == 1) {
    digitalWrite(ledBleuB, LOW); // eteind ledBleuR
  } else if (buttonCountdBonusGoalB == 2) {
    digitalWrite(ledJauneB, LOW); // eteind ledJauneR
  }
  
// fonction du SERVO MOTEUR BonusGoalR
 if (digitalRead(buttonBonusGoalR) == LOW && !buttonPressedBonusGoalR && buttonCountdBonusGoalR < 2) {
    buttonPressedBonusGoalR = true;
    buttonCountdBonusGoalR++;
    for (PosMyservoBonusGoalR = 0; PosMyservoBonusGoalR <= 110; PosMyservoBonusGoalR += 1) {
      myservoBonusGoalR.write(PosMyservoBonusGoalR);
      delay(10);
    }
    previousMillisBonusGoalR = millis(); // Enregistrer le temps actuel
  }

  // Vérifier si le temps écoulé depuis l'appui sur le bouton est supérieur ou égal à 5 secondes
  if (buttonPressedBonusGoalR && millis() - previousMillisBonusGoalR >= intervalBonusGoalR) {
    for (PosMyservoBonusGoalR = 110; PosMyservoBonusGoalR >= 0; PosMyservoBonusGoalR -= 1) {
      myservoBonusGoalR.write(PosMyservoBonusGoalR);
      delay(10);
    }
    buttonPressedBonusGoalR = false;
    }

  
{long duration, distance;
bool objectDetected = false;

digitalWrite(triggerPinR, LOW);
delayMicroseconds(2);
digitalWrite(triggerPinR, HIGH);
delayMicroseconds(10);
digitalWrite(triggerPinR, LOW);

duration = pulseIn(echoPinR, HIGH);
distance = duration * 0.034 / 2;


  if (digitalRead(buttonreset) == LOW) { // Si le bouton est pressé
    delay(30);
    if (digitalRead(buttonreset) == LOW) {
      resetProgram(); // Appeler la fonction de réinitialisation
      delay(500);
    }
  }

if (distance > 0 && distance < 4 && !objectDetected) {
  // Objet détecté à proximité et aucune détection précédente
  objectDetected = true; // Marquer l'objet comme détecté
  
  // Effectuer l'incrémentation et l'affichage
  counterR++;
  if (counterR >= sizeof(tableR) / sizeof(tableR[0])) {
    counterR = 0;
  }
  DisplayR(counterR);
  
// Répéter deux fois la boucle complète
    for (int repeat = 0; repeat < 2; repeat++) {
      // Allumer progressivement le premier groupe de LEDs de la 1ère à la 50e LED
      for (int i = 0; i < 50; i++) {
        strip.setPixelColor(i, strip.Color(255, 0, 0)); // Couleur rouge pour la LED i
        strip.show();
        delayMicroseconds(100); // Attendre un court délai pour allumer progressivement la LED
      }

      // Attendre un court délai avant de passer au groupe suivant
      delay(1);

      // Boucle principale pour allumer les groupes de LEDs jusqu'à la 150e LED
      for (int groupStart = 0; groupStart <= RUBANLED - 50; groupStart++) {
        // Éteindre la première LED du groupe précédent (sauf pour le premier groupe)
        if (groupStart > 0) {
          strip.setPixelColor(groupStart - 1, strip.Color(0, 0, 0)); // Éteindre la première LED du groupe précédent
        }

        // Allumer le groupe de LEDs actuel
        for (int i = 0; i < 50; i++) {
          strip.setPixelColor(groupStart + i, strip.Color(255, 0, 0)); // Couleur rouge pour le groupe actuel
        }

        strip.show();
        delayMicroseconds(100); // Attendre un court délai avant de passer au groupe suivant
      }

      // Éteindre le groupe de 50 LEDs restant progressivement jusqu'à la 150e LED
      for (int i = 49; i >= 0; i--) {
        strip.setPixelColor(RUBANLED - i - 1, strip.Color(0, 0, 0)); // Éteindre la LED du groupe restant
        strip.show();
        delayMicroseconds(100); // Attendre un court délai pour éteindre progressivement la LED
      }
    }
    // Boucle pour le clignotement rapide en rouge pendant 2 secondes
    unsigned long startTime = millis();
    while (millis() - startTime <= 1000) {
      // Allumer toutes les LED en rouge
      strip.fill(strip.Color(255, 0, 0)); // Couleur rouge pour toutes les LED
      strip.show();
      delay(10); // Attendre 10 millisecondes avant de changer le motif

      // Éteindre toutes les LED
      strip.fill(strip.Color(0, 0, 0)); // Éteindre toutes les LED
      strip.show();
      delay(100); // Attendre 100 millisecondes avant de changer le motif
    }
  



  if (myservoGamelleB.read() > 100) {
    counterR += 1;
    if (counterR >= sizeof(tableR) / sizeof(tableR[0])) {
      counterR = 0;
    }
    DisplayR(counterR);
    previousMillisDisplayR = millis(); // Reset the timer
 }
    
    
}

// Check if the elapsed time since the last increment of DisplayB is greater than or equal to the specified interval
  if (millis() - previousMillisDisplayR >= incrementInterval2) {
  if (distance > 0 && distance < 4 && myservoGamelleB.read() > 100) {
    counterR += 2;
    if (counterR >= sizeof(tableR) / sizeof(tableR[0])) {
      counterR = 0;
    }
    DisplayR(counterR);
    delay(200);
  }
  previousMillisDisplayR = millis(); // Reset the timer
    

  } 
  } 

// fonction du SERVO MOTEUR BonusGoalB
 if (digitalRead(buttonBonusGoalB) == LOW && !buttonPressedBonusGoalB && buttonCountdBonusGoalB < 2) {
    buttonPressedBonusGoalB = true;
    buttonCountdBonusGoalB++;
    for (PosMyservoBonusGoalB = 0; PosMyservoBonusGoalB <= 110; PosMyservoBonusGoalB += 1) {
      myservoBonusGoalB.write(PosMyservoBonusGoalB);
      delay(10);
    
    }
    previousMillisBonusGoalB = millis(); // Enregistrer le temps actuel
}

  // Vérifier si le temps écoulé depuis l'appui sur le bouton est supérieur ou égal à 5 secondes
  if (buttonPressedBonusGoalB && millis() - previousMillisBonusGoalB >= intervalBonusGoalB) {
    for (PosMyservoBonusGoalB = 110; PosMyservoBonusGoalB >= 0; PosMyservoBonusGoalB -= 1) {
      myservoBonusGoalB.write(PosMyservoBonusGoalB);
      delay(10);
    }
    buttonPressedBonusGoalB = false;
}
   
 {long duration2, distance2;
bool objectDetected2 = false;

digitalWrite(triggerPinB, LOW);
delayMicroseconds(2);
digitalWrite(triggerPinB, HIGH);
delayMicroseconds(10);
digitalWrite(triggerPinB, LOW);

duration2 = pulseIn(echoPinB, HIGH);
distance2 = duration2 * 0.034 / 2;

 if (digitalRead(buttonreset) == LOW) { // Si le bouton est pressé
    delay(30);
    if (digitalRead(buttonreset) == LOW) {
      resetProgram(); // Appeler la fonction de réinitialisation
      delay(500);
    }
  }

if (distance2 > 0 && distance2 < 5 && !objectDetected2) {
  // Objet détecté à proximité et aucune détection précédente
  objectDetected2 = true; // Marquer l'objet comme détecté
  
  // Effectuer l'incrémentation et l'affichage
  counterB++;
  if (counterB >= sizeof(tableB) / sizeof(tableB[0])) {
    counterB = 0;
  }
  DisplayB(counterB);
    delay(200);
  if (myservoGamelleR.read() > 100) {
    counterB += 1;
    if (counterB >= sizeof(tableB) / sizeof(tableB[0])) {
      counterB = 0;
    }
    DisplayB(counterB);
    previousMillisDisplayB = millis(); // Reset the timer
     }
}
// Check if the elapsed time since the last increment of DisplayB is greater than or equal to the specified interval
  if (millis() - previousMillisDisplayB >= incrementInterval) {
  if (distance2 > 0 && distance2 < 5 && myservoGamelleR.read() > 100) {
    counterB += 2;
    if (counterB >= sizeof(tableB) / sizeof(tableB[0])) {
      counterB = 0;
    }
    DisplayB(counterB);
    delay(200);
  }
  previousMillisDisplayB = millis(); // Reset the timer
}
}
}

Sujet assez complexe je l'avoue.

Merci a ceux qui prendront le temps de voir une anomalie quelque part.

Merci

[UKHeliBob]

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

[fdufnews]

Il faudrait regarder l'occupation mémoire en RAM par les variables.
Il y a par exemple la librairie memoryFree pour ça (lien ci-dessous).

Problème de fonctionnement de la carte sd et de la rtc simultanément

Beaucoup de capteurs, beaucoup de librairies plus la gestion de carte SD. Il est fort probable que la RAM est mise à mal. Qu'indique le compilateur sur l'utilisation mémoire? Ou mieux, utilise la librairie MemoryFree. Il suffit ensuite d'ajouter les lignes suivantes à la fin du setup() Serial.print("freeMemory()="); Serial.println(freeMemory());

Dans le cas de ton programme c'est la quantité de variables à laquelle s'ajoute le tampon qui stocke la valeurs des LEDs qui pourraient saturer la RAM.
Tu pourrais commencer en déclarant un bandeau composé d'une seule LED pour voir la quantité de RAM disponible (ou alors une version antérieure de ton code). En fonction de la mémoire disponible tu sauras combien de LED tu peux utiliser. Si le nombre est trop faible il faudra peut-être envisager soit de passer sur une cible avec un peu plus de RAM, soit d'optimiser l'usage de la RAM.

[jpbbricole]

Bonsoir scorius

@scorius

la commande des servo moteur se désactive pendant l'animation des lumière LED

Tu as peut-être un conflit entre 2 bibliothèques?
Essaies d'en changer, pour le servo, VarSpeedServo et pour les LED FastLED.

Je n'ai pas essayé ton programme, mais à lire ton descriptif, ça doit être fun de jouer au babyfoot

Cordialement
jpbbricole

[scorius]

OK merci, je vais regarder cette histoire de mémoire demain.

Merci

[scorius]

Je n'ai pas la librairy [VarSpeedServo] dans ma banque, je peux en essayer une autre mais il est compliquer de tout changer

[scorius]

Pensez vous qu'il faille que j'utilise 2 Arduino pour régler le problème?

[scorius]

Ok j'ai reussi, il fallait telecharger la library Free memory.

Alors la memoire s'affiche toutes secondes et lorsque je fait afficher les led, ca bloque le rafraichissement de données de la mémoire durant l'affichage des led et une fois fini, l'état de la mémoire reprend, comme si l'affichage des LED bloquait tout le programme.

[fdufnews]

@scorius

Alors la memoire s'affiche toutes secondes

Oui, d'accord, mais l'idée c'est de connaitre la quantité de mémoire libre.
Quelle est la valeur affichée.

[scorius]

Ok je viens de regarde j'ai
Free memory: 7004 bytes
Pensez-vous que c'est bien ?

[fdufnews]

Qu'est-ce c'est comme carte?

[scorius]

C'est l'arduino mega.

[fdufnews]

@scorius

lorsque je fait afficher les led, ca bloque le rafraichissement de données de la mémoire durant l'affichage des led et une fois fini, l'état de la mémoire reprend,

L'affichage des LEDs se fait dans une boucle qui bloque tout le reste du programme, donc c'est normal que l'affichage de l'occupation mémoire ne soit pas mis à jour.

@scorius

Ok je viens de regarde j'ai
Free memory: 7004 bytes

Cela laisse pas mal de place. Donc, oui, c'est bien.

[scorius]

Ce que je ne comprends pas, c'est que lorsque le capteur ultrason détecte la balle, il incremente bien l'afficheur digital et ensuite dois faire l'animation des Led, ça c'est la boucle mais les moteurs eux, ne sont pas dans cette boucle mais une boucle à part, alors pourquoi sont'ils impactés par l'allumage des leds et s'éteignent?

Le fait de déplacer la boucle des Leds ailleurs ne résoudrait pas le problème je pense.

[jpbbricole]

Bonjour scorius

@scorius

mais les moteurs eux, ne sont pas dans cette boucle mais une boucle à part, alors pourquoi sont'ils impactés par l'allumage des leds et s'éteignent?

J'en reviens avec un conflit de bibliothèques. Je ne suis pas suffisamment connaisseur des arcanes de la programmation mais il m'est arrivé que 2 bibliothèques utilisaient le même timer ou même interrupt du processeur. Si on part du fait que ton moteur de servo est maintenu en position par une largeur d'impulsion (PWM) qui nécessite l'usage, en interne, d'un timer et que ce timer est également utilisé pou animer les LED WS2812, pendant cette animation, le PWM du servo n'est plus généré donc ton servo part à 0.
D'où l'intérêt d'essayer d'autres bibliothèques.

Je viens de faire cette recherche Adafruit_NeoPixel.h and servo.h

Un moyen de contourner ce problème est d'utiliser un module à base de PCA9685 qui permet de driver 16 servo, ce qui permettra d'agrémenter, encore plus, ton babyfoot.

C'est très facile à mettre en oeuvre sur ton Arduino.

Nécessite une bibliothèque comme Adafruit_PWMServoDriver.h (il y en a d'autres).

Cordialement
jpbbricole

Cordialement
jpbbricole

[scorius]

Bonsoir a vous,

Alors j'ai essayé la bibliothèque : PCA9685, VarSpeedServo, même résultât négatif.

J'ai essayé la bibliothèque : Adafruit_PWMServoDriver.h et ca fonctionne pour seulement un seul moteur. Adafruit_PWMServoDriver.h me renvoi sur TiCoServo est-ce bien celui-ci ?

voici un programme tres simplifié avec seulement l'animation LED et 2 ServoMoteur avec <Adafruit_TiCoServo.h>

un seul des deux moteurs fonctionne.

Votre avis ?

#include <Adafruit_NeoPixel.h>
#include <Adafruit_TiCoServo.h>

#define RUBANLED 150 // Total de LEDs
#define DATA_PIN 40
Adafruit_TiCoServo myservoBonusGoalR;
Adafruit_TiCoServo myservoGamelleR;
int buttonBonusGoalB = 18;
int PosMyservoGamelleR = 0;
int PosMyservoBonusGoalR = 0;

Adafruit_NeoPixel strip(RUBANLED, DATA_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  myservoBonusGoalR.attach(4);
  myservoGamelleR.attach(5);
  pinMode(buttonBonusGoalB, INPUT_PULLUP);
  strip.begin();
  strip.setBrightness(255);
  strip.show();

  PosMyservoBonusGoalR = 110;
  while (PosMyservoBonusGoalR >= 0) {
    myservoBonusGoalR.write(PosMyservoBonusGoalR);
    delay(10);
    PosMyservoBonusGoalR -= 1;
  }
  
  PosMyservoGamelleR = 110;
  while (PosMyservoGamelleR >= 0) {
    myservoGamelleR.write(PosMyservoGamelleR);
    delay(10);
    PosMyservoGamelleR -= 1;
  }
}

void loop() {
  if (digitalRead(buttonBonusGoalB) == LOW) {
    for (int repeat = 0; repeat < 2; repeat++) {
      for (int i = 0; i < 50; i++) {
        strip.setPixelColor(i, strip.Color(255, 0, 0));
        strip.show();
        delayMicroseconds(100);
      }
      delay(1);

      for (int groupStart = 0; groupStart <= RUBANLED - 50; groupStart++) {
        if (groupStart > 0) {
          strip.setPixelColor(groupStart - 1, strip.Color(0, 0, 0));
        }

        for (int i = 0; i < 50; i++) {
          strip.setPixelColor(groupStart + i, strip.Color(255, 0, 0));
        }

        strip.show();
        delayMicroseconds(100);
      }

      for (int i = 49; i >= 0; i--) {
        strip.setPixelColor(RUBANLED - i - 1, strip.Color(0, 0, 0));
        strip.show();
        delayMicroseconds(100);
      }
    }

    unsigned long startTime = millis();
    while (millis() - startTime <= 1000) {
      strip.fill(strip.Color(255, 0, 0));
      strip.show();
      delay(10);

      strip.fill(strip.Color(0, 0, 0));
      strip.show();
      delay(100);
    }
  }
}

[scorius]

Pour information, souvent j'ai, pour une raison inattendue les servo moteur qui bougent tout seul sans raison.