Boucle "if" boiteuse... [non résolu]

Salut à tous,

j'ai un soucis dans une boucle "if" sur un programme pour un projet de BTS, mais mes competences en programation ne me permettent pas de trouver la solution malgré des heures de recherches... Si l'un d'entre vous peut me filler un petit coup de main ce serait sympa! :slight_smile:

but du projet: commander un distributeur hydraulique sur une benne à ordure

Le soucis: le code semble fonctionner presque partout mais j'ai un soucis avec la partie "descente de benne et remonter bequilles".
Normalement, lorsque l'on appui sur le bouton "descente de benne", la benne descend (logique), il y a la sonnette qui marche. Une fois la benne complemement descendu (capteur ct_ben_bas activé) on remonte les bequilles de stabilisation.
En réalite, lorsque la benne descend, la sonnette (qui doit normalement bippée -gestion du bip interne à la sonnette- juste alimentée en 12v continu) fait un bruit bizarre (comme si l'alimentation n'etait pas continue) et souvent au bout de quelques secondes, tout plante et je doit reseté la carte pour que cela marche...

je pense que le probleme vient de cette partie

 else
  {

    digitalWrite(accel, LOW);
    digitalWrite(embra, LOW);
    digitalWrite(pell1, LOW);                                                                                     // pelle sens 1
    digitalWrite(pell2, LOW);                                                                                     // pelle sens 2
    digitalWrite(dc_beq, LOW);                                                                                    // sortir bequilles
    digitalWrite(benne, LOW);                                                                                     // monter benne
    digitalWrite(mt_beq, LOW);                                                                                    // rentrer bequilles
    digitalWrite(peign_f, LOW);                                                                                   // fermer le peigne 
    digitalWrite(peign_o, LOW);                                                                                   // ouvrir le peigne 
    digitalWrite(mt_lc, LOW);                                                                                     // monter le leve containeur
    digitalWrite(dc_lc, LOW);                                                                                     // descendre le leve containeur
    digitalWrite(mt_blc, LOW);                                                                                    // monter le basculeur leve containeur
    digitalWrite(dc_blc, LOW);                                                                                    // descendre le basculeur leve containeur
    digitalWrite(cl_para, LOW);

    digitalWrite(sonnet, t_sonnette);                                                                             // activation sonnette
    digitalWrite(cl_para, t_clap_para);                                                                           // ouvrir clapet parachute
  }

en effet, le probleme ne semble present que lorsque la benne descent . Voila la configuration que l'on devrait avoir dans ce cas

entrées actives
et_bt_dben (bouton pupitre descente de benne)

si benne pas en position basse (et_ct_ben_bas), on n'accelere pas (Hydropwr OFF, tout les sorties en OFF sauf le clapet parachute (clapet d'ouverture du verin de benne ) et la sonnette en marche tant que les bequilles ne sont pas rentrées

Si benne descendu (et_ct_ben_bas activé), on accelere, mon remonte les bequilles stabilisatrices et la sonnette marche jusqu'a ce que les bequilles sont remontées

Merci de votre aide

voila le code (simplifié)

if (contact_State == LOW)

{
digitalWrite(pwr, HIGH);

// Sonnette alarme
t_sonnette = (!et_bt_sonnette || et_ct_beq_rent == HIGH); // sonnette si appui bouton ou bequilles non rentrées

// Pelle sens1 (monter)
t_pelle_s1 = (!et_bt_pell1); // vérification du BP pelle monter

// Pelle sens2 (descente)
t_pelle_s2 = (!et_bt_pell2); // vérification du BP pelle descente

// Sortir bequilles et monter benne
t_beq_sortir = (!et_bt_mben && et_ct_beq_sort == HIGH && !et_ct_lc); //vérification BP monte benne et capteur bequilles non sorties et capteur LC came actif
t_benne = (!et_bt_mben && !et_ct_beq_sort && !et_ct_lc); //vérification BP monte benne et capteur bequilles sorties et capteur LC came actif
t_clap_para = (!et_bt_mben && !et_ct_beq_sort && !et_ct_lc); //vérification BP monte benne et capteur bequilles sorties et capteur LC came actif

// Descente benne et remonter bequilles
t_clap_para = (!et_bt_dben && et_ct_ben_bas == HIGH); //vérification BP descente benne et capteur benne basse non activé
t_beq_rentrer = (!et_bt_dben && !et_ct_ben_bas); //vérification BP descente benne et capteur benne basse activé && !et_ct_lc

// Mettre Leve containeur en position route
t_lc_route = (!et_bt_lc_rt && !et_ct_lc); //vérification BP LC position route (test)

// Monter Leve containeur
t_ferm_peigne = (!et_bt_mont_lc && et_bt_desc_lc == HIGH && et_ct_peigne == HIGH && !et_ct_ben_bas); //vérification BP monte Leve containeur et peigne ouvert et benne en bas
t_monter_lc = (!et_bt_mont_lc && et_bt_desc_lc == HIGH && !et_ct_peigne && et_ct_lc_h == HIGH && !et_ct_basclc_b); //vérification BP monte Leve containeur et peigne ferme et capteur lc haut non actif et capteur Basculeur lc en bas
t_monter_basclc = (!et_bt_mont_lc && et_bt_desc_lc == HIGH && !et_ct_peigne && !et_ct_lc_h); //vérification BP monte Leve containeur et peigne ferme et capteur lc haut actif et capteur Basculeur lc haut non actif

// Descente Leve containeur
t_desc_basclc = (!et_bt_desc_lc && et_bt_mont_lc == HIGH && !et_ct_peigne && !et_ct_lc_h && et_ct_basclc_b == HIGH); //vérification BP monte Leve containeur et peigne ferme et capteur lc haut actif et capteur Basculeur lc bas non actif
t_desc_lc = (!et_bt_desc_lc && et_bt_mont_lc == HIGH && !et_ct_basclc_b && et_ct_lc == HIGH); //vérification BP descente Leve containeur et capteur basculeur lc bas actif et capteur LC NA
t_ouv_peigne = (!et_bt_desc_lc && et_bt_mont_lc == HIGH && !et_ct_basclc_b && !et_ct_lc); //vérification BP descente Leve containeur et capteur basculeur lc bas actif et capteur LC active

HydroPwr = (t_pelle_s1 || t_pelle_s2 || t_beq_sortir || t_benne || t_beq_rentrer || t_ferm_peigne || t_monter_lc || t_desc_lc || t_lc_route || t_ouv_peigne || t_monter_basclc || t_desc_basclc || t_desc_basc_manuel || t_mont_lc_manuel);

if (HydroPwr == HIGH)
{
digitalWrite(accel, HydroPwr);

if(currentMillis >= (previousMillis_ac + delay_Acc))
{
digitalWrite(embra, HydroPwr);
digitalWrite(pell1, t_pelle_s1); // pelle sens 1 (monter)
digitalWrite(pell2, t_pelle_s2 || t_lc_route); // pelle sens 2 (descente)
digitalWrite(dc_beq, t_beq_sortir); // sortir bequilles
digitalWrite(benne, t_benne); // monter benne
digitalWrite(mt_beq, t_beq_rentrer); // rentrer bequilles
digitalWrite(peign_o, t_ouv_peigne); // ouvrir le peigne
digitalWrite(peign_f, t_ferm_peigne || t_lc_route); // fermer le peigne
digitalWrite(mt_lc, t_monter_lc); // monter le leve containeur || t_mont_lc_manuel
digitalWrite(dc_lc, t_desc_lc || t_lc_route); // descendre le leve containeur
digitalWrite(mt_blc, t_monter_basclc); // monter le basculeur leve containeur
digitalWrite(dc_blc, t_desc_basclc || t_lc_route); // descendre le basculeur leve containeur || t_desc_basc_manuel
digitalWrite(cl_para, t_benne);
}
}
else
{

digitalWrite(accel, LOW);
digitalWrite(embra, LOW);
digitalWrite(pell1, LOW); // pelle sens 1
digitalWrite(pell2, LOW); // pelle sens 2
digitalWrite(dc_beq, LOW); // sortir bequilles
digitalWrite(benne, LOW); // monter benne
digitalWrite(mt_beq, LOW); // rentrer bequilles
digitalWrite(peign_f, LOW); // fermer le peigne
digitalWrite(peign_o, LOW); // ouvrir le peigne
digitalWrite(mt_lc, LOW); // monter le leve containeur
digitalWrite(dc_lc, LOW); // descendre le leve containeur
digitalWrite(mt_blc, LOW); // monter le basculeur leve containeur
digitalWrite(dc_blc, LOW); // descendre le basculeur leve containeur
digitalWrite(cl_para, LOW);

digitalWrite(sonnet, t_sonnette); // activation sonnette
digitalWrite(cl_para, t_clap_para); // ouvrir clapet parachute
}

}
else
{
digitalWrite(accel, LOW);
digitalWrite(embra, LOW);
digitalWrite(pell1, LOW); // pelle sens 1
digitalWrite(pell2, LOW); // pelle sens 2
digitalWrite(dc_beq, LOW); // sortir bequilles
digitalWrite(benne, LOW); // monter benne
digitalWrite(mt_beq, LOW); // rentrer bequilles
digitalWrite(peign_f, LOW); // fermer le peigne
digitalWrite(peign_o, LOW); // ouvrir le peigne
digitalWrite(mt_lc, LOW); // monter le leve containeur
digitalWrite(dc_lc, LOW); // descendre le leve containeur
digitalWrite(mt_blc, LOW); // monter le basculeur leve containeur
digitalWrite(dc_blc, LOW); // descendre le basculeur leve containeur
digitalWrite(cl_para, LOW);

delay(delay_PWR);

digitalWrite(pwr, LOW);

}

Code difficile à lire pour qui n'est pas dans le truc.
Maintenant il y a des choses bizarres comme ça:

capteur bequilles sorties et capteur LC came actif     
  t_clap_para = (!et_bt_mben && !et_ct_beq_sort && !et_ct_lc);                                //vérification  BP monte benne et capteur bequilles sorties et capteur LC came actif 

  // Descente benne et remonter bequilles
  t_clap_para = (!et_bt_dben && et_ct_ben_bas == HIGH);                                       //vérification  BP descente benne

Tu affectes une variable 2 fois de suite.
Est-ce une conséquence d'une copie partielle du code.

Maintenant, de ce que tu dis:

En réalite, lorsque la benne descend, la sonnette (qui doit normalement bippée -gestion du bip interne à la sonnette- juste alimentée en 12v continu) fait un bruit bizarre (comme si l'alimentation n'etait pas continue) et souvent au bout de quelques secondes, tout plante et je doit reseté la carte pour que cela marche...

On pourrais penser que tu actives une fonctionnalité que tu désactives aussitôt après.
Cela peut être du à une logique "foireuse" dans les conditions de déclenchement et de maintient de la fonctionnalité.
Du style:
Si le bouton_rouge est appuyé et la butée_repos enclenchée
lancer tel action

un peu plus loin

Si la butée_repos n'est pas enclenchée
arrêter tout

ce genre de test lance une action et l'interrompt immédiatement.

Ne pas oublier que dans les systèmes séquentiels il y a :
un état de départ avec des conditions particulières
un état de fin avec des conditions particulières
entre les deux (pendant le déroulement de l'action) tout ou partie des conditions peuvent changer.

Il est donc préférable de travailler en créant des variables bistables qui activent l'action
Si le bouton_rouge est appuyé et la butée_repos enclenchée
activer_action=1

Si butée_fin enclenchée ou sécurité activé
activer_action=0

si activer_action
lancer tel action

Cela donne une meilleur maîtrise des conditions de fonctionnement et une vue plus claire sur les processus.
C'est surtout la transcription directe du diagramme d'état qui a du être fait avant de commencer à coder étant donnée le nombre de conditions à prendre en compte dans ce code.

Bonjour

merci bcp de ton aide...

donc il faut que je reécrive tout mon code? sachant que la je l'ai deja bien allégé pour pas trop surchargé le forum...

pour la variable affectée deux fois, c'est "normal" (du moins dans ma logique :wink: mais je suis d'accord avec toi que cela ne devrait pas etre le cas. En fait pour pouvoir monter ou descendre la benne, il faut ouvrir ce clapet de sécurite sur le pied du verin

Ce que je dis, c’est tel qu’on voit le code, le fait d’affecter la variable sur 2 lignes consécutives n’a pas de sens. La première affectation est immédiatement écrasée par celle qui est derrière.

Après récrire tout ton code on ne peut pas juger. Le morceau visible n’est pas très clair. On voit plein d’affectation de variables qui ne sont pas utilisées (ou du moins qui semble n’être pas utilisées).

voici le code complet

comment penses tu que je puisse optimiser cela? car la ca marche pas terrible lors de la descente de benne

Merci de ton aide

benne.txt (23.3 KB)

Le code est touffu et difficile à lire. Tu aurais gagné à découper en fonctions pour améliorer la lisibilité.
Une fonction manuel, une fonction automatique pour commencer.
Sans connaitre la logique de fonctionnement du système on ne peut pas beaucoup t'aider. Tout au plus te donner des règles de bonne pratique pour mettre au point.

Il faut placer quelques Serial.print un peu partout dans le code pour voir où il passe. Il faut quand même rester raisonnable car si on sort beaucoup d'informations, on peut ralentir un peu l'exécution du programme et tomber en marche sans comprendre pourquoi.
Faire afficher l'état des variables pour comprendre pourquoi il ne suit pas la logique voulu.
Ne pas perdre de vue que loop est exécuté plusieurs milliers de fois par secondes et que cela peut jouer des tours lorsqu'on est connecté à des systèmes qui sont lents par rapport au temps de réaction du programme.