fendeur hydraulique

bonjour à tous et par avance merci pour votre aide.

je vous écris car je suis novice en programmation arduino et je sais qu'il y a plein de fautes de syntax dans mon programme peut être meme voir certainement de développement.

malheureusement pour moi je vais utiliser pour mon projet une carte mega 2560 et le seul simulateur gratuit que j'ai trouvé c'est tinkercad qui ne peut emuler que une carte uno.

voici donc mon code en pj

j'ai hate de lire vos commentaires et encore merci

fendeur.ino (9.85 KB)

Bonsoir

pour plus de commentaires .....il faut plus de lecteurs du code....
En le mettant en pj tu laisses de côté les utilisateurs de smartphone

Il est donc recommandé de mettre le code dans le corps du message en l'insérant entre des balises code (icône </>)

ça donnera un bloc e ce style et le copié collé dans l'IDE ARduino pour examen sera simple

mon code

Pour les erreurs de syntaxe que dit le compilateur ? autant le faire travailler un peu.....

Vérifie tes while et tes if. La syntaxe d'une condition logique c'est de la mettre entre parenthèses.

Le digitalRead lit une pin : vérifie que c'est bien le cas. Tu dois faire quelque chose comme

ValeurPin = digitalRead (NumeroPin) ;

Le test d'égalité c'est ==

Je ne sais pas ce que tu veux faire au niveau de la ligne ModeAuto:
Si c'est une fonction, la syntaxe n'est pas la même qu'en python. Vérifie ta syntaxe pour les fonctions en C.

Bon courage !

Pour tenir compte des rematques judicieuses précédentes (toutes sont judicieuses), j'ai copié une partie
******(sans les variables globales ni le setup: il y a une butée au nombre de caractères)


votre code et glissé quelques commentaires qui peuvent signaler une partie des défauts, voire tenté de corriger une toute petite partie.

Excusez ma curiosité, mais ce code est il accepté par un compilateur c++ ?
Est ce que, même s'il accepte ce code, il ne signale pas (par warning) des bizarreries?

Il est dans l'état difficile à lire et à faire évoluer (ne respecte aucun standard de codagede ma connaissance)

void loop()
{
  
    
Initialisation:
digitalWrite(ledR, 1);
digitalWrite(ledJ, 1);

 while digitalRead (positionverin)//vérification si verin fermé
   {  
     positionverin= digitalRead(capt_vp_f);
          
    if(positionverin==0)//tant que le contact de position du verin principal fermé ne s'enclanche pas
   {
    digitalWrite(distri_vp_f,1);//fermeture du distributeur
    digitalWrite(by_pass,1);//fermeture du by pass
    positionverin=1;
    }
    else { break;} // 
    }
  //la syntax fait elle en sorte que je revérifie capt_vp_f avant de sortir de la boucle? si le capteur et enclanché capt_vp_f=1

  
    digitalWrite(by_pass,0);//ouverture du by pass
    digitalWrite(distri_vp_f,0);//ouverture du distributeur
    

if digitalRead(capt_br)&& digitalRead(capt_scie_h)&& digitalRead(capt_vp_f)&& digitalRead(capt_vniv_f)
  {digitalWrite(ledR, 0);}
  else
  {digitalWrite (buzzer,1);
  goto initialisation;}
  

if digitalRead(man_auto)//manuel=1 auto=0
  {goto ModeManuel}
  
  else
  {goto ModeAuto} // evitez les goto (ça chagrine les puristes et vous pouvez les remplacer par un appel de fonction
     
     
ModeManuel:
while digitalRead(inter_man_auto)=1
{
  
//deux actions contraires ne peuvent être effectuer en meme temps
//probleme avec le by_pass si le by_pass est fermé alors qu'aucun mouvement n'est fait on casse la pompe. variable??
//avance moteur electrique 
if digitalRead(bp_man_avance)&&digitalRead(capt_bu)=0//si bp=1 et butée=0
  {digitalWrite(marche_moteur);}
  
//bridage manuel
if digitalRead(inter_man_br)
  {digitalWrite(distri_br,1);//distributeur
   digitalWrite(by_pass,1);}
 
//sciage semi automatique
if digitalRead(bp_scie_man)&&digitalRead(inter_man_br)&&digitalRead(capt_br)=0//si le bp de scie est activé ainsi que l'inter de bridage et que le bridage et effectif
  {while digitalRead(capt_scie_fc)=0
    {digitalWrite(distri_scie,1);//distributeur moteur
    digitalWrite(distri_descente,1);
    digitalWrite(by_pass,1);
   }}//distibuteurs de scie et de descente actionné tant que le sciage n'est pas complet
 
//si verrins non jumellés(=0)
if digitalRead(twinverrins)=0
  {
  //ouverture manuelle du verin principal 
   if digitalRead(bp_ouverture_man_vp)=!digitalRead(bp_fermeture_man_vp)&&digitalRead(capt_vp_o)=0
    {digitalWrite(distri_vp_o,1);//distributeur
     digitalWrite(by_pass,1);}
   
 
  //fermeture manuelle du verin principal
    if digitalRead(bp_fermeture_man_vp)=!digitalRead(bp_ouverture_man_vp)&&digitalRead(capt_vp_f)=0
    {digitalWrite(distri_vp_f,1);//distributeur
    digitalWrite(by_pass,1);}

  
  //ouverture manuelle du verin auxilliaire
    if digitalRead(bp_ouverture_man_vaux)=!digitalRead(bp_fermeture_man_vaux)&&digitalRead(capt_vaux_o)=0
    {digitalWrite(distri_vaux_o,1);//distributeur
    digitalWrite(by_pass,1);}
   
 
  //fermeture manuelle du verin principal
    if digitalRead(bp_fermeture_man_vaux)=!digitalRead(bp_ouverture_man_vaux)&&digitalRead(capt_vaux_f)=0
    {digitalWrite(distri_vaux_f,1);//distributeur
     digitalWrite(by_pass,1);}
 } 

//si verrins jumellés(=1)
if digitalRead(twinverrins)=1
  {
  //ouverture manuelle des verins
   if digitalRead(bp_ouverture_man_vp)=!digitalRead(bp_fermeture_man_vp)&&digitalRead(capt_vp_o)=0
    {digitalWrite(distri_vp_o,1);//distributeur
    digitalWrite(distri_vaux_o,1);
     digitalWrite(by_pass,1);}
   
 
  //fermeture manuelle des verins
    if digitalRead(bp_fermeture_man_vp)=!digitalRead(bp_ouverture_man_vp)&&digitalRead(capt_vp_f)=0
    {digitalWrite(distri_vp_f,1);//distributeur
    digitalWrite(distri_vaux_f,1);
    digitalWrite(by_pass,1);}
  
   
   }
}
  
ModeAuto:    
while (digitalRead(inter_man_auto)=0) 
{
  
//deux actions contraires ne peuvent être effectuer en meme temps
//avance moteur electrique 
while //while QUOI
  {if digitalRead(capt_bu)=0//tant que l'on est pas en butee on reste dans la boucle
  {digitalWrite(marche_moteur);}}
  
//bridage, sciage
while 
//while QUOI
  {if digitalRead(capt_bu)
    {digitalWrite(distri_br,1);//distributeur
    digitalWrite(by_pass,1);}
    delay (1000ms);
 
  //sciage automatique
  if digitalRead(capt_br)=0
    {while if digitalRead(capt_scie_fc)=0
      {digitalWrite(distri_scie,1);//distributeur moteur
      digitalWrite(distri_descente,1);
     digitalWrite(by_pass,1);
    }}
    else 
      {var_action++;
      break;}
 
//si verrins non jumellés(=0)
//action de fermeture et d'ouverture
if digitalRead(twinverrins)=0
  {
   if digitalRead(capt_vp_o)&&var_action=1
    while//tant que le capteur de position fermé n'est pas activé on reste dans la boucle
      if digitalRead(capt_vp_f)=0
        {digitalWrite(distri_vp_o,0);
        digitalWrite(distri_vp_f,1);//distributeur
         digitalWrite(by_pass,1);}
         
   if digitalRead(capt_vp_f)&&var_action=1
//while QUOI
    while//tant que le capteur de position ouvert n'est pas activé on reste dans la boucle
      if digitalRead(capt_vp_o)=0
        {digitalWrite(distri_vp_f,0);
        digitalWrite(distri_vp_o,1);//distributeur
         digitalWrite(by_pass,1);}}
   
 //si verrins jumellés(=1)
//action de fermeture et d'ouverture
if digitalRead(twinverrins)=1
  {
   if digitalRead(capt_vp_o)&&var_action=1
//while QUOI
    while//tant que le capteur de position fermé n'est pas activé on reste dans la boucle
      if digitalRead(capt_vp_f)=0
        {digitalWrite(distri_vp_o,0);
        digitalWrite(distri_vaux_o,0);
        digitalWrite(distri_vp_f,1);
        digitalWrite(distri_vaux_f,1);//distributeur
         digitalWrite(by_pass,1);}
         
   if digitalRead(capt_vp_f)&&var_action=1 {
  // while QUOI?
    while//tant que le capteur de position ouvert n'est pas activé on reste dans la boucle
      if digitalRead(capt_vp_o)=0
        {digitalWrite(distri_vp_f,0);
        digitalWrite(distri_vaux_f,0);
        digitalWrite(distri_vp_o,1);
        digitalWrite(distri_vaux_o,1);//distributeur
         digitalWrite(by_pass,1);}}
   
} // j'ai rajouté des accolades, même si elles ne servent à rien
  
 //ouverture manuelle du verin auxilliaire si non jummelé en mode auto
    if digitalRead(bp_ouverture_man_vaux)=!digitalRead(bp_fermeture_man_vaux)&&digitalRead(twinverrins)=0&&digitalRead(capt_vaux_o)=0
    ) // ***pb parenthese
    {digitalWrite(distri_vaux_f,0);
    digitalWrite(distri_vaux_o,1);//distributeur
    digitalWrite(by_pass,1);}

 //fermeture manuelle du verin auxilliaire si non jummelé en mode auto
    if digitalRead(bp_fermeture_man_vaux)=!digitalRead(bp_ouverture_man_vaux)&&digitalRead(twinverrins)=0&&digitalRead(capt_vaux_f)=0
    ) // *****parenthese mal foutue
    {
    digitalWrite(distri_vaux_o,0);
    digitalWrite(distri_vaux_f,1);//distributeur
    digitalWrite(by_pass,1);}
   
 
  
 }  
}
}

Nota: si vous avez un IDE arduino: vous pouvez -désolé de rester général; je n'en ai pas un sous la main...- faire en sorte que le compilateur vous signale toutes les erreurs et tous les avertissements (warnings). Dans tous les cas, les erreurs seront signalées ... et, si vous ne les comprenez pas, vous pouvez les copiller coller et les soumettre à la sagacité de vos lecteurs.
Autre note : est il sain (surtout que ça peut poser des problèmes de sécurité) de se fendre d'un hénaurme bloc de code; ila caut peut être mieux essayer de compiler des petits bouts, moins indigestes.

C'est plus lisible comme ça en effet. Du coup je vois qu'il y a des goto dans le code ce qui explique les labels genre ModeAuto: et ModeManuel: que je n'avais pas vus sur mon téléphone portable hier soir.

Je n'en utilise pas mais ça doit être correct.

Il manque parfois des ';' comme ici :

{goto ModeManuel}

Enfin, lorsqu'il n'y a qu'une seule instruction ou ligne d’instructions dans un bloc, inutile de mettre des accolades : ceci suffit

 goto ModeManuel;

le_bucheron:
je vous écris car je suis novice en programmation arduino et je sais qu'il y a plein de fautes de syntax dans mon programme peut être meme voir certainement de développement.

malheureusement pour moi je vais utiliser pour mon projet une carte mega 2560 et le seul simulateur gratuit que j'ai trouvé c'est tinkercad qui ne peut emuler que une carte uno.

Bonjour,

Pas besoin de simulateur pour voir si ton code compile correctement (ce qui en l’occurrence n'est pas le cas).

Il manque parfois des ';' comme ici :

{goto ModeManuel}

Enfin, lorsqu'il n'y a qu'une seule instruction ou ligne d’instructions dans un bloc, inutile de mettre des accolades : ceci suffit

goto ModeManuel;

Non, ça ne suffit pas:
pour ne pas chagriner les puristes, et à juste titre, il ne faut pas de goto (mettre un appel de fonction à la place, puisqu'il n'y a que des variables globales: seul l'auteur de ce "code" peut en comprendre la structure)
Ensuite, faire un bloc (même si c'est inutile) ne fait pas de mal.... (et permet de tracer avec des printf/Serial.print sans trourner en bourrique)
Un goto de temps en temps (avec l'autorisation de sa grand mère et du pape, disons tous les 29 févriers), on peut serrer les dents et l'admettre; mais là, il y en a trop....

  goto initialisation;
//l'étiquette initialisation étant en début de fonction loop) cela revient à écrire 
  return;

merci de toutes vos réponses et de votre attention!

je vais tenter de répondre dans l'ordre

j'ai collé le code sur mon post mais il a était refusé trop de caractères et j'ignorais le systeme (icone</>).dsl.

je n'ai pas tenté de compiller en l'état car avant je voulais savoir si "la structure" était bonne

il n'y a pas de probleme à ecrire "if digitalRead(pin)==0" ?

oui il y a 3 goto dans mon programme car il y a deux modes manuel/automatique(une pin y est associé) et que en l'état de mes compétences c'est plus simple et évite au programme de lire des lignes pour rien.

oui je me doute que je ne respecte pas les standards de codage, mais je suis là pour les apprendre. comment puis je proceder pour?

  if digitalRead(man_auto)//manuel=1 auto=0
  {
    ModeManuel()
  }

  else
  {
    ModeAuto()
  }
  // ....

void ModeManuel()
{
  // le code ici
}

void ModeAuto()
{
  // le code ici
}

// mais avant tout :
    if digitalRead(twinverrins) = 0
// les parenthèses sont obligatoires :
    if (digitalRead(twinverrins) = 0)
// il  y en a d'autres je te laisse chercher

Lis la doc de référence du langage, notamment le if

On peut essayer de commencer par le début:

vous avez un goto Initialisation;
essayez d'isoler le bloc qui correspond à init,
copiez le collez le au dessus de loop et mettez

void Initialisation(){
// les lignes de code qui reinitialisent
}

Je pense que vous seul pouvez isoler la partie propre à l'initialisation. Mais peut être que je me trompe.
(nota: si vous avez suivi scrupuleusement (aux majuscules près...-) ce que j'ai écrit, vous introduirez ... une erreur de plus ( Initialisation ne peut être à la fois un label et une fonction) , triviale à corriger (vous verrez, elle est triviale) .

En même temps (voire avant) :
essayez de faire compiler votre code (tout le monde pense qu'il ne peut pas se compiler)
copiez collez scrupuleusement les messages d'erreur (au moins le premier; après le compilateur peut "devenir fou" par surmenage/burnout)
insérez ces messages d'erreur dans ce forum
Comme les gens ont l'habitude, ils vous les expliqueront et vous diront comment faire pour retirer ces erreurs.
Ca amelirorera le code (au moins, il pourra s'exécuter), mais il restera difficile à lire.

Nota:
Au moment où j'ai été obligé de fendre votre code pour qu'il puisse être posté, j'ai supprimé toutes les déclarations de variables globales et le setup, qui n'avaient rien de choquant...

Pour la compréhension, si vous avez deux modes, l'un manuel, l'autre automatique, il me semble logique qu'ils soient traités séparément (celà fait un découpage naturel en deux fonctions):
l'avantage d'avoir deux fonctions (outre le fait de ne pas faire souffrir les puristes) , c'est qu'on se concentre sur ces fonctions, au lieu de dériver au gré des goto.... Et ce ne sont pas trois 4 lignes de plus ou de moins qui vont influer sur le confort de lecture (peut on se relire soi même dans trois mois, quand on veut rajouter un bouton? peut on se faire relire/corriger?)

Il y a manifestement une structure dans ce code, mais elle est bien cachée -les commentaires d'autres lecteurs plus doués m'ont permis de la découvrir partiellement- et il est difficile à lire. A terme, ça peut être gênant pour le dépanner/adapter/modifier.

Enfin, les modifications proposées (remplacer les goto par des fonctions) n'impactent en aucune façon les performances du code (au pire, l'appel d'une fonction prend 3 microsecondes, si ma mémoire est exacte (et pareil pour le retour;) au mieux, la fonction est "inlinée" -copiée collée automatiquement - par l'optimiseur, s'il juge que l'éxecutable résultant sera plus rapide: l'optimiseur fait les choses bien mieux qu'un programmeur moyen, sans distractions et il vaut mieux le laisser faire avec les réglages fournis par Arduino)

al1fch:
pour plus de commentaires .....il faut plus de lecteurs du code....
En le mettant en pj tu laisses de côté les utilisateurs de smartphone

et pas que...

bonjour, dsl je ne comprends pas tout (je ne mange du code que depuis la semaine dernière)
si je met "initialisation" au dessus du loop je serai donc dans le setup. nous sommes d'accord?
du coup quand le programme va rencontrer " void initialisation;" je vais sortir de la boucle de loop pour entrer dans la boucle de setup?
afin de simplifier grandement les choses d'expliquer la structure du code et le corriger en meme temps ne serait il pas envisageable de faire un team viewer et d'etre au téléphone en meme temps?

void Initialisation() {..... plein de lignes } est, comme setup et loop, une fonction (une brique logicielle reutilisable)

Il m'est difficile d'expliquer des choses que je pratique depuis des décades:
un programme est une séquence d'instructions (mais ne s'execute pas forcément dans l'ordre où on les a écrites). La première chose à faire c'est de tenter, par tous les moyens , d'extirper les fautes de frappe -inévitables-: le compilateur essaye de les detecter et peut, parfois, produire des fichiers jugés dignes d'être avalés par un arduino ou un simulateur..... S'il ne le fait pas, il le signale (et la solution, pour débuter, est de copier coller ses gémissements et de les envoyer à un forum, où on tentera d'y remédier et de vous les expliquer). au bout d'un moment, le compilateur cessera de se plaindre -ce qui ne veut pas dire que votre programme fera quelque chose de cohérent..... mais ca finit par arriver)

une fonction est une brique logicielle, séquence d'instructions (qui peut faire appel à d'autres fonctions : vous en avez tout plein dans le logiciel, analogRead, pinmode .... sont des fonctions et vous pouvez être heureux qu'elles ne s'executent que quand vous en avez besoin.)

setup et loop sont des noms imposés par arduino, qui les invoque depuis une fonction cachée, main
(en gros, main() demarre avec setup, ne le fait qu'une fois et fait tourner loop .... jusqu'à l'extinction de l'arduino (ou sa reprogrammation -mais après, ça sera la même ritournelle)

void Initialisation(){} sert à dire ce que initialisation() va faire,

mais pas du tout à la lancer ( c'est lorsque main va lancer loop que initialisation va etre lancee -si on l'a prévu explicitement-).
Je doute que vos correcteurs et ce site aient les moyens (temps, matériel) d'une téléconférence : on est obligé de bricoler

Excusez ma curiosité, mais:
savez vous vous servir de tinkercad (vue la taille du code, et la potentielle méchanceté de vos machines, il me semble sain de simuler le fonctionnement, ce que je ne sais pas faire )?
vous êtes vous inspiré de quelque chose?

j'utilise tinkercac mais on ne peut émuler que une carte uno hors vu le nombre d'i/o dont j'ai besoin la uno ne suffit pas!

merci pour la précision sur les fonctions.
à ce sujet petites questions, si j'écris :

void setup(){}

void loop(){

void initialisation(){le code}
void modeManuel(){le code} cette écriture est elle valable?
}

void setup(){}

void loop(){}

void initialisation(){le code}
void modeManuel(){le code} est ce mieux?

si je lance le mode manuel, est ce que je reste dans le mode et revient au début à la fin du code? si je tape return dans mode manu, je reviens au début du mode manu ou au début de loop?

C'est la bonne question

void loop() {
initialisation();
modeMAnual();
return; // si vous ne le spécifiez pas, soit le compialteur va peut être protester et dans tous les cas, il va en mettre un
}

il va appeler les fonctions en séquence, et donc initialiser, traiter le mode manuel, puis quitter; le main (qui vous est caché) relancera loop étéernellement (il ne fait que ça) .
(main () équivaut à void main() {
init_systeme(); // fourni par arduino.....
setup();// à votre choix
while(1==1) { // tant que les jours sont jours : eternellement
loop();
}
return()
}

J'ai un peu regardé votre code (passge par cppcheck et cpplint.py de google) : j'ai vu des horreurs que le compilateur ne peut pas détecter (confusion entre l'égalité "==" on teste si deux valeurs sont égales, et l'affectation x=3.15 "=" on copie 3.14 dans x) : la construction if (x=5) est parfaitement tolérée (sans avertissement) et a l'air de signifier "si l'affectation de 5 à x se passe bien"; est donc vraie....

Sans simulateur (au moins des bouts), je suis très mal à l'aise : il faudrait au minimum que vous remplaciiez des scies, fendeurs, relays (certaines de ces bêtes peuvent être féroces) par des LEDs et leurs résistances, pour essayer de détecter un mauvais comportement (et votre cliveur a-t-il un interrupteur électrique général).

La 1ère écriture n'est pas correcte.

A la fin de l'exécution de modeManuel, que ce soit sur un return ou pas, l'exécution se poursuit dans la loop(), à l'instruction suivant l'appel à modeManuel.

Compile ceci pour mieux saisir :

void setup()
{
   Serial.begin(115200);
}

void loop()
{
// condition = 0 : auto
// condition = 1 : manuel
  int condition = 1;

  Serial.println("LOOP");
  initialisation();
  if (condition == 1) {
    modeManuel();
  }
  else {
    modeAuto();
  }
  Serial.println("END LOOP");
  delay(1000);
}

void initialisation()
{
}

void modeManuel()
{
  Serial.println("MANUEL");
}

void modeAuto()
{
  Serial.println("AUTO");
}

Mais sincèrement, un petit tuto ne ferait pas de mal : Les fonctions - Le langage C • Tutoriels • Zeste de Savoir

merci pour le lien du tuto et pour les commentaires.

j'ai une plaque de relais avec led témoins, avant de mettre en service le groupe hydraulique je testerai le comportement du programme. les relais n'ont par chance pas besoin d'être en charge sur leurs sorties pour fonctionner normalement :wink:

depuis que j'ai posté le code initiale j'ai corrigé pas mal d'érreurs. les = par ==, les oublis de '(' ')' de ';' bref le compilateur fait son taf. cependant je bute sur une ligne

while{ if (digitalRead(capt_bu)==1)
{digitalWrite(distri_br,1);//distributeur
digitalWrite(by_pass,1);}}

le compilateur me dit:

exit status 1
expected '(' before '{' token

une idée? :wink: