[Resolu] Problème de relais qui bloque des actions

Bonjour dbrion06,

Merci pour m'avoir fais la remarque et guider pour cela car justement j'essayais de trouver une autre alternative mais j'avais vu cette façon sur le net mais il faut croire que j'avais du mal m'y prendre (certainement trop d'espace) puisque celle-ci n'avais pas bien fonctionner. Je viens de réessayer et c'est mieux maintenant il me prend vraiment les valeurs qui sont comprises dedans et non la dernière.

Merci bien :slight_smile:

A mon avis, mon histoire d'utiliser un pont en H je vais vite l'oublier. Je pense que au final mettre 2 relais pour faire du courant négatif serais plus facile mais comment câbler cela ? J'ai beau chercher je ne trouve rien qui correspond à un minimum à se que je recherche c'est à dire alimenter ma bobine via 2 relais qui change d'état pour pouvoir alimenter la bobine en -5V/+5V.

Serait-il possible de me guider ?

Un pont ferait très bien l'affaire autrement tu peux utiliser un second relais pour faire un inverseur.

Du coup j'ai choisi de prendre 2 relais, l'un me sers pour le nord, qui envoie du +5V et l'autre me sers pour le sud mais justement j'ai un problème sur lui alors je ne sais pas si c'est mon code vu que je l'ai modifié pas mal aujourd'hui ou sois mes câblages sont tout simplement mauvais.

int pincapteur=A0;

const int pinLed=7;
const int pinLed1=8;
const int pinLed2=9;

const int LEDB=10;
const int bouton=11;
int etatbouton=0;

const int RELAIS = 6;
const int RELAIS2 = 5;
//boolean etatRelais = 0;
//boolean etatRelais2 = 0;

void setup() 
{
Serial.begin(9600);

pinMode(LEDB,OUTPUT);      
pinMode(bouton,INPUT_PULLUP); 

pinMode(pinLed,OUTPUT);
pinMode(pinLed1,OUTPUT);
pinMode(pinLed2,OUTPUT);

pinMode(RELAIS,OUTPUT);
pinMode(RELAIS2,OUTPUT);
}

void loop() 
{
  boutonled();
  valeurcapteur();
  capteurled();
  }

void boutonled()
{  
etatbouton = digitalRead(bouton);
  if (etatbouton == HIGH) 
  {     
    digitalWrite(LEDB,LOW);  
  }
  else 
  {
    digitalWrite(LEDB,HIGH); 
  }
} 

void valeurcapteur()
{
      // Moniteur série pour vérifier valeur
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur
  Serial.print("Valeur Capteur : ");
  Serial.print(valeur);
  Serial.println();
  delay(1000);
  if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
  Serial.println("Test centre OK");
  digitalWrite(RELAIS,LOW);
  digitalWrite(RELAIS2,HIGH);
}
else if ((valeur >=0) && (valeur <= 501))              // Valeur Min
{
  Serial.println("Test NORD OK");
  digitalWrite(RELAIS,HIGH);
  digitalWrite(RELAIS2,LOW);
}

else if ((valeur >=515) && (valeur <= 1023))
{
  Serial.println("Test SUD OK");
  digitalWrite(RELAIS,LOW);
  digitalWrite(RELAIS2,LOW);
}
}

void capteurled()
{
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur

if ((valeur >=0) && (valeur <= 501))              // Valeur Min
 {
    digitalWrite(pinLed,HIGH);                        // on allume la LED emplacement 7
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,LOW);
  } 
else if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
    digitalWrite(pinLed,LOW);                   
    digitalWrite(pinLed1,HIGH);                     // on allume la LED emplacement 8
    digitalWrite(pinLed2,LOW);
  }  
else if ((valeur >=515) && (valeur <= 1023))     // Valeur Max
{
    digitalWrite(pinLed,LOW);                  
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,HIGH);                    // on allume la LED emplacement 9
  }
}

J'ai fais un petit schéma de mon arduino uno avec mes relais relier avec l'arduino et le branchement avec la bobine sachant que se n'est pas une pile de 9V que j'utilise mais plutôt une alimentation externe que j'ai mis en Série pour avoir +5V/-5V.

Merci encore pour vos réponses et votre aide :slight_smile:

Je ne te cacherais pas que j'ai renoncé à interpréter ton "schéma". C'est complètement illisible.
Voilà un schéma de câblage des relais que je te propose
relais.png
Les 2 relais au repos ou actifs le moteur est arrêté
Un relais actif l'autre au repos le moteur tourne dans un sens. Avec la combinaison inverse le moteur tourne dans l'autre sens.

relais.png

Oui désolé ce n'était pas trop propre ^^"

J'ai réussi à faire autrement et à faire fonctionner sauf que maintenant mon prof aimerais que cela fonctionne comme une sorte de banc de test il dis que cela va nous préparer pour l'an prochain.

Je voudrais rajouter en plus comme quoi si mes 3 test sont OK alors une LED verte pour dire test OK pour tout s'allume et une LED rouge si il y a une erreur et là je bloque un peu au niveau du code ^^"

voilà actuellement mon code

int pincapteur=A0;

const int pinLed=7;
const int pinLed1=8;
const int pinLed2=9;

const int LEDB=10;
const int bouton=11;
int etatbouton=0;

const int RELAIS = 6;
const int RELAIS2 = 5;
boolean etatRelais = 0;
boolean etatRelais2 = 0;

void setup() 
{
Serial.begin(9600);

pinMode(LEDB,OUTPUT);      
pinMode(bouton,INPUT_PULLUP); 

pinMode(pinLed,OUTPUT);
pinMode(pinLed1,OUTPUT);
pinMode(pinLed2,OUTPUT);

pinMode(RELAIS,OUTPUT);
pinMode(RELAIS2,OUTPUT);
}

void loop() 
{
  boutonled();
  valeurcapteur();
  capteurled();
  }

void boutonled()
{  
etatbouton = digitalRead(bouton);
  if (etatbouton == HIGH) 
  {     
    digitalWrite(LEDB,LOW);  
  }
  else 
  {
    digitalWrite(LEDB,HIGH); 
  }
} 

void valeurcapteur()
{
      // Moniteur série pour vérifier valeur
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur
  Serial.print("Valeur Capteur : ");
  Serial.print(valeur);
  Serial.println();
  delay(1000); 
  if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
  Serial.println("Test centre OK");
  etatRelais=!etatRelais;
  digitalWrite(RELAIS,!etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
else if ((valeur >=0) && (valeur <= 501))              // Valeur Min
{
  Serial.println("Test NORD OK");
  digitalWrite(RELAIS,etatRelais);
  etatRelais2=!etatRelais2;
  digitalWrite(RELAIS2,!etatRelais2);
}

else if ((valeur >=515) && (valeur <= 1023))
{
  Serial.println("Test SUD OK");
  digitalWrite(RELAIS,etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
}

void capteurled()
{
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur

if ((valeur >=0) && (valeur <= 501))              // Valeur Min
 {
    digitalWrite(pinLed,HIGH);                        // on allume la LED emplacement 7
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,LOW);
  } 
else if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
    digitalWrite(pinLed,LOW);                   
    digitalWrite(pinLed1,HIGH);                     // on allume la LED emplacement 8
    digitalWrite(pinLed2,LOW);
  }  
else if ((valeur >=515) && (valeur <= 1023))     // Valeur Max
{
    digitalWrite(pinLed,LOW);                  
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,HIGH);                    // on allume la LED emplacement 9
  }
}

Merci pour votre aide

Sur le point

if (valeur=analogRead(pincapteur)== (0, 500) )              // Valeur Min
 {

Hikashiro:
Merci pour m'avoir fais la remarque et guider pour cela car justement j'essayais de trouver une autre alternative mais j'avais vu cette façon sur le net mais il faut croire que j'avais du mal m'y prendre (certainement trop d'espace) puisque celle-ci n'avais pas bien fonctionner.

Votre écriture ne voulait pas dire grand chose.

il y avait une affectation valeur= de la valeur de la formule à droite analogRead(pincapteur) == (0, 500) donc déjà comme on a un == ce qui arriverait dans valeur serait un booléen (vrai ou faux).

ensuite dans l'évaluation du test d'égalité on irait bien chercher la valeur analogique associée à pincapteur et que l'on comparerait à l'évaluation de l'expression (0, 500)

La virgule ainsi utilisée dit au compilo, évalue l'expression à gauche de la virgule, puis évalue celle à droite de la virgule et retourne comme valeur cette seconde évaluation. ici on a des valeurs, donc rien vraiment à exécuter donc (0, 500) est évalué à 500.

donc c'est comme si on avait écrit: valeur = (analogRead(pincapteur) == 500)
donc en français, valeur sera vrai si la mesure analogique de la pin pincapteur donne 500. Dans ce cas valeur vaudra true (donc 1) sinon elle vaudra false (donc 0)

ce n'est donc certainement pas ce que vous vouliez faire... je ne sais pas trop où vous avez vu cette notation...

D'accord merci pour l'explication plus technique qui me fais vraiment mieux comprendre mon erreur.

Et j'avais trouvé cette solution là sur un forum qui parlais du langage C pour pouvoir mettre des nombres en "fourchette" mais il semblerais que j'ai sois du mal interpréter se que la personne expliquais ou sois c'était faux.

En tout cas merci pour votre explication :slight_smile:

(Si vous avez des idées ou une explication qui pourrais m'aider dans mon dernier poste je suis preneur merci bien )

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

--> moi je ré-écrirais tout sous cette forme :slight_smile:

D'accord je vais aller voir ton tuto merci pour ton temps et ton aide.

J'ai réussi à faire que quand j'appuie sur mon bouton le programme se lance mais le seul problème est que si je lâche le bouton le programme s'arrête ^^"

Avez vous une solution ?

int pincapteur=A0;

const int pinLed=7;
const int pinLed1=8;
const int pinLed2=9;

const int LEDB=10;
const int bouton=11;
int etatbouton=0;

const int RELAIS = 6;
const int RELAIS2 = 5;
boolean etatRelais = 0;
boolean etatRelais2 = 0;

void setup() 
{
Serial.begin(9600);

pinMode(LEDB,OUTPUT);      
pinMode(bouton,INPUT_PULLUP); 

pinMode(pinLed,OUTPUT);
pinMode(pinLed1,OUTPUT);
pinMode(pinLed2,OUTPUT);

pinMode(RELAIS,OUTPUT);
pinMode(RELAIS2,OUTPUT);
}

void loop() 
{
  valeurcapteur();
  capteurled();
  }

void valeurcapteur()
{
  etatbouton = digitalRead(bouton);
  if (etatbouton == LOW)
  {
      // Moniteur série pour vérifier valeur
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur
  Serial.print("Valeur Capteur : ");
  Serial.print(valeur);
  Serial.println();
  delay(1000); 
  if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
  Serial.println("Test centre OK");
  etatRelais=!etatRelais;
  digitalWrite(RELAIS,!etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
else if ((valeur >=0) && (valeur <= 501))              // Valeur Min
{
  Serial.println("Test NORD OK");
  digitalWrite(RELAIS,etatRelais);
  etatRelais2=!etatRelais2;
  digitalWrite(RELAIS2,!etatRelais2);
}

else if ((valeur >=515) && (valeur <= 1023))
{
  Serial.println("Test SUD OK");
  digitalWrite(RELAIS,etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
}
else (etatbouton == HIGH);
{
  digitalWrite(LEDB,HIGH);
}
}
void capteurled()
{
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur

if ((valeur >=0) && (valeur <= 501))              // Valeur Min
 {
    digitalWrite(pinLed,HIGH);                        // on allume la LED emplacement 7
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,LOW);
  } 
else if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
    digitalWrite(pinLed,LOW);                   
    digitalWrite(pinLed1,HIGH);                     // on allume la LED emplacement 8
    digitalWrite(pinLed2,LOW);
  }  
else if ((valeur >=515) && (valeur <= 1023))     // Valeur Max
{
    digitalWrite(pinLed,LOW);                  
    digitalWrite(pinLed1,LOW);
    digitalWrite(pinLed2,HIGH);                    // on allume la LED emplacement 9
  }
}

la solution n'est pas de traquer la position des boutons mais les transitions et ce que ça veut dire... et plus vous rajouterez de contraintes plus votre code avec cette approche sera compliquée...

C'est ce que fait une machine à état plus simplement

Hum je sens que cette histoire d'automatisé cela va être compliqué.

Parce que le but est que si j'appuie sur le bouton poussoir tout les actions qui teste le NORD/SUD et Centre se font et si cela est bon alors j'allume une led et si cela ne sais rien fais ou si il y a des erreurs alors une autre led s'allume sauf que avec mon niveau en arduino je commence un peu à bloquer ^^"

Merci pour votre aide

c'est pour cela qu'une machine à état simplifie la réflexion.

Quel est l'état initial ? (tout éteint)
quels sont les événements qui peuvent se produire? (Détection Nord, Détection Sud, Pas de Détection, Bouton On, Bouton Off)

donc que se passe-t-il depuis l'état initial si on a un de ces évènements ?
--> ça vous donne de nouveaux états

ensuite quels sont les événements qui peuvent se produire pour chacun de ces états --> nouveaux états ou rejoindre un état déjà existant

commencez par là et bâtissez le graphe d'états

Oui mais là je commence un peu à être perdu vu que cela se complique pour moi. Le fais de commander le bouton à un état précis et qui gère avec un "if" tout un programme j'ai du mal ^^"

Et les graphes d'état c'est une première pour moi ^^

et oui faut bosser :slight_smile:

Bonjour,

J'ai cherché une bonne partie du week-end et je n'ai pas avancer. Sachant que mon projet dois se finir dans 2 semaines donc ça commence un peu à pousser malheureusement.

C’est pas sorcier de dessiner des boites et des flèches - montrez nous ce que vous avez fait « tout le week end » et où ça coince... une chose est sûre, c’est votre projet et on ne va pas le faire pour vous ni à votre place...

Je n'ai pas dis cela. Mais j'ai trouvé se week-end que pas mal de monde parlais de la fonction "millis" et j'aimerais dire que si mon bouton est à l'état "LOW" pendant 1sec alors exécuter le programme. Mais là est justement le problème, comment écrire cela.

J'ai oublié de mettre la partie concerné que j'ai faite :

{
  etatbouton = digitalRead(bouton);
  time = millis();
  if (etatbouton == LOW, millis() => 1000)
  {
      // Moniteur série pour vérifier valeur
int valeur=analogRead(pincapteur); // on lit la valeur transmise par le capteur
  Serial.print("Valeur Capteur : ");
  Serial.print(valeur);
  Serial.println();
  delay(1000); 
  if ((valeur >=502) && (valeur <= 514))   // Valeur Moy
{
  Serial.println("Test centre OK");
  etatRelais=!etatRelais;
  digitalWrite(RELAIS,!etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
else if ((valeur >=0) && (valeur <= 501))              // Valeur Min
{
  Serial.println("Test NORD OK");
  digitalWrite(RELAIS,etatRelais);
  etatRelais2=!etatRelais2;
  digitalWrite(RELAIS2,!etatRelais2);
}

else if ((valeur >=515) && (valeur <= 1023))
{
  Serial.println("Test SUD OK");
  digitalWrite(RELAIS,etatRelais);
  digitalWrite(RELAIS2,etatRelais2);
}
}
else (etatbouton == HIGH);
{
  digitalWrite(LEDB,HIGH);
}
}

if (etatbouton == LOW, millis() => 1000)

Est ce que ça compile?
Est ce que ce ne serait pas plus lisible sous la forme (si c'est bien ce que vous voulez)
if ((LOW == etatbouton) && (millis >= 1000)).

Par ailleurs, buis je vous signaler (il vous reste un ou deux week ends... et même semaines) que ce forum donne accés à des tutoriels, parmi ceux ci, les liens de Tuto pour code non bloquant et FreeRTOS - Tutoriels et cours - Arduino Forum et le tutoriel sur les machines d'etat Programmation Automate fini / Machine à état - Tutoriels et cours - Arduino Forum pourraient vous être plus fructueux que des tâtonnements dans l'etrange toile....