Je suis en train de découvrir le langage arduino depuis 2 semaines et je suis en train de faire une machine qui perce des rondins. Le soucis dans mon code est que la boucle while doit arrêter le code pour laisser le moteur en marche tant que le fond de course n'es pas appuyé et si le fin de course est appuyé le moteur s'arrête et le code continue. Je vous joins le début du code où ça coince. Je me suis inspiré de beaucoup d'info que j'ai vu sur des forum et vidéo pour comprendre la syntaxe, il n'y a pas d'erreur sauf que le relais R1 clignote en boucle car la fonction while n'est pas actionnée.
Un grand merci pour votre aide qui me permettra de progresser.
Bonne journée
Guillaume
const int R1 = 13;
const int RCW = 12;
const int RCCW = 11;
const int FdC1 = 10;
const int FdC2 = 9;
int etatbouton1;
int etatbouton2;
void setup() {
Serial.begin(9600);
pinMode(R1, OUTPUT);
pinMode(RCW, OUTPUT);
pinMode(RCCW, OUTPUT);
pinMode(FdC1, INPUT_PULLUP);
pinMode(FdC2, INPUT_PULLUP);
bool etatbouton1 = 0; // inicialisation du bouton NC/LOW
}
void loop() {
digitalWrite(R1, HIGH); // pousse le rondin
delay(1000);
digitalWrite(R1, LOW); // coupe alim verrin
delay(1000);
etatbouton1 = digitalRead(FdC1);
while (digitalRead(etatbouton1 <= 0)) { // tant que l'inter fin de course 1 est en posiion ouvert/relaché NO/LOW
digitalWrite(RCW, HIGH); // le relais 2 alimente le sens CW et le moteur avance pour serrer les mords sur le rondin
if (digitalRead(etatbouton1 >= 1)) { // si l'inter fin de course 1 est en posiion fermé/appuyé NC/HIGH
digitalWrite(RCW, LOW); //le relais RCW s'éteint et coupe l'alimentation du moteur.
delay(500);
break; // sortir de la boucle while et continuer le programme
}
}
}
Merci ! J'ai essayé ainsi mais le bouton FdC1 lorsqu'il passe en HIGH, le relais RCW ne s'éteint pas. La boucle while est infinie et ne prend pas en compte la sortie break.
const int R1 = 13;
const int RCW = 12;
const int RCCW = 11;
const int FdC1 = 10;
const int FdC2 = 9;
int etatbouton1;
int etatbouton2;
void setup() {
Serial.begin(9600);
pinMode(R1, OUTPUT);
pinMode(RCW, OUTPUT);
pinMode(RCCW, OUTPUT);
pinMode(FdC1, INPUT_PULLUP);
pinMode(FdC2, INPUT_PULLUP);
etatbouton1 = LOW; // inicialisation du bouton NC/LOW
}
void loop() {
digitalWrite(R1, HIGH); // pousse le rondin
delay(1000);
digitalWrite(R1, LOW); // coupe alim verrin
delay(1000);
while (digitalRead(FdC1 == LOW)) { // tant que l'inter fin de course 1 est en posiion ouvert/relaché NO/LOW
digitalWrite(RCW, HIGH); // le relais 2 alimente le sens CW et le moteur avance pour serrer les mords sur le rondin
if (digitalRead(FdC1 == HIGH)) { // si l'inter fin de course 1 est en posiion fermé/appuyé NC/HIGH
digitalWrite(RCW, LOW); //le relais RCW s'éteint et coupe l'alimentation du moteur.
delay(500);
break; // sortir de la boucle while et continuer le programme
}
}
}
c'est le résultat de l'appel à digitalRead() que vous voulez comparer avec LOW
idem pour
--
la loop sert à boucler. vous pourriez écrire votre code pour que ce soit la loop qui fasse office du while. avez vous jeté un oeil aux machines à états ?
Merci, en effet je n'ai pas fait attention aux parenthèses.
Je vais regarder les machines états, je ne connais pas.
Après la boucle while, il y a d'autres opérations à effectuer (déplacement moteur pap, servo, relais) qui fonctionnent correctement. Je ne les ai pas mise pour alléger le code dans le post.
Il faut juste que j'arrive à faire que le FdC1 arrête RCW et quitte la boucle while.
digitalWrite(R1, HIGH); // pousse le rondin
delay(1000);
digitalWrite(R1, LOW); // coupe alim verrin
delay(1000);
digitalWrite(RCW, HIGH); // le relais 2 alimente le sens CW et le moteur avance pour serrer les mords sur le rondin
while (digitalRead(FdC1) != LOW) ; // attente du fin de course
digitalWrite(RCW, LOW); //le relais RCW s'éteint et coupe l'alimentation du moteur.
Merci beaucoup, ça fonctionne un peu mieux comme je le souhaite.
R1 s'allume et s'éteint puis RCW s'allume mais R1 continue à s'allumer et s'éteindre en boucle tant que FdC1 n'est pas HIGH , quand FdC1 passe en HIGH, RCW s'éteint comme je le souhaite et R1 aussi alors qu'il ne doit s'allumer et s'éteindre qu'une fois au début du loop.
Merci pour l'aide j'ai pu constater que je cherchais à faire bien trop compliqué avec un changement d'état de bouton et plusieurs fonction.
const int R1 = 13;
const int RCW = 12;
const int RCCW = 11;
const int FdC1 = 10;
const int FdC2 = 9;
void setup() {
Serial.begin(9600);
pinMode(R1, OUTPUT);
pinMode(RCW, OUTPUT);
pinMode(RCCW, OUTPUT);
pinMode(FdC1, INPUT_PULLUP);
pinMode(FdC2, INPUT_PULLUP);
}
void loop() {
digitalWrite(R1, HIGH); // pousse le rondin
delay(1000);
digitalWrite(R1, LOW); // coupe alim verrin
delay(1000);
digitalWrite (RCW, HIGH);
while(digitalRead(FdC1) !=HIGH){
digitalWrite(RCW, LOW);}
}
Je dois donc trouver comment faire pour que while bloque le loop de R1 et que lorsque FdC1 est HIGH (donc appuyé) permette au loop de continuer car il s'arrête.
Voici le code en entier va être comme cela( pour l'essai du code, j'utilise un petit moteur pap 28BYJ-48) . la boucle while bloque le loop et ne permet pas de continuer le déroulement du code.
Merci pour votre aide.
Bien cordialement
// déclaration moteur pap
#include <Stepper.h> // bibliotheque qui permet de faire fonctionner un moteur pap
const int nbpas = 2048; // Nombre de pas par tour moteur 28BYJ-48 = 2048 pas
const int ln_1 = 3;
const int ln_2 = 4;
const int ln_3 = 5;
const int ln_4 = 6;
Stepper moteur (nbpas, ln_1, ln_2, ln_3, ln_4);
// déclaration servo
#include <Servo.h> // bibliothèque pour faire fonctioner le servo
#define servo1Pin 8 // servo qui rapproche les mords
#define servo2Pin 7 // servo laisse tomber la pile de rondin
int min = 550; // palonnier position 0 degres pour servo digital, valeur trouvée par essai
int max = 2600; // palonnier position 180 degres pour servo digial, valeur trouvée par essai
Servo Servo1; // déclaration du servo1
Servo Servo2; // déclaration du servo2
//déclaration relais et inter fin de course
const int R1 = 13; // verrin pousseur des rondins
const int RCW = 12; // moteur serrer mords
const int RCCW = 11; //moteur desserrer mords
const int FdC1 = 10; // stop moteur serrage
const int FdC2 = 9; // stop moteur desserrage
const int R2 = 2; // verrin pousseur des rondins usinés
void setup() { // déclaration sorties relais et entrée inter fin de course
Serial.begin(9600);
Servo1.write (0);// inicialise la position de départ car sinon la position est par defaut à 90°
Servo2.write (180);// inicialise la position de départ car sinon la position est par defaut à 90°
Servo1.attach(servo1Pin, min, max);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
pinMode(11, OUTPUT);
pinMode(10, INPUT_PULLUP);
pinMode(9, INPUT_PULLUP);
pinMode(8, OUTPUT);
pinMode(7, OUTPUT);
pinMode(2, OUTPUT);
}
void loop(){
digitalWrite(R1, HIGH); // pousse le rondin
delay(500);
digitalWrite(R1, LOW); // coupe alim verrin
delay(500);
for (int position = 90; position >=0; position --) { // servo libère la pile de rondin
Servo1.write(position);
delay(20);}
for (int position = 0; position <=90; position ++) { // servo bloque la pile de rondin
Servo1.write(position);
delay(20);}
for (int position = 180; position >=0; position --) { // servo approche les mords avant serrage
Servo2.write(position);
delay(20);}
digitalWrite (RCW, HIGH); // acive le relais CW et allume le moteur.
while(digitalRead(FdC1) !=HIGH){ // attend que FdC1 soit appuyé.
digitalWrite(RCW, LOW);} // désactive le relais et arrête le moteur.
moteur.setSpeed(10); // 10 max pour le moteur 28BYJ-48 // le moteur pap perce, vitesse à définir
moteur.step(512); // le moteur pap fait 1/4 tour dans le sens persage
delay (1000);
moteur.setSpeed(10); // 10 max pour le moteur 28BYJ-48// le moteur pap se retire, definir une vitesse plus grande en ajoutant un parametre vitesse2??
moteur.step(-512); // le moteur pap fait 1/4 tour dans le sens inverse et reviens à sa position incitial (2x64 pas)
digitalWrite (RCCW, HIGH); // active le relais CW et allume le moteur.
while(digitalRead(FdC2) !=HIGH){ // attend que FdC1 soit appuyé.
digitalWrite(RCCW, LOW);} // désactive le relais et arrête le moteur.
for (int position = 0; position <=180; position ++) { // servo relâche les mords avant deserrage
Servo2.write(position);
delay(20);}
digitalWrite(R2, HIGH); // pousse le rondin usiné
delay(500);
digitalWrite(R2, LOW); // coupe alim verrin
delay(500);
}
Remarque le ; à la fin du while : le while attend et ne fait rien. Ensuite le relais est désactivé.
C'est pareil ici :
Il faudrait indenter ton code pour le rendre plus lisible : ça se fait automatiquement dans l'IDE avec CTRL T.
Si ton code ne doit être exécuté qu'une seule fois, autant tout mettre dans le setup et laisser la loop vide. Sinon, explique mieux ce que tu désires faire.
le moteur est un moteur induction qui à un sens CW et CCW, il y a 2 relais pour piloter et inverser le sens.
il faut deux boucles While :
FdC1 arrête le moteur commandé par le relais CW ( le sens horaire) , le moteur serre les mords avant perçage.
FdC2 arrête le moteur commandé par le relais CCW ( le sens anti-horaire) , le moteur déserre les mords après perçage.
J'ai expliqué dans le code, les actions qui correspondent aux lignes.
Je me doute que c'est pas évident quand on à pas la machine sous les yeux pour comprendre au mieux l'enchainement des actions, j'ai fabriqué et conçu la machine mais le plus dur pour moi est l'édition du code pour qu'il soit correctement interprété,
ça progresse grâce à votre aide. Je vais aussi me rapprocher d'un fablab afin qu'il puisse m'aider.
je faisais ça pendant que tu as mis le code complet
donc, ne réponds peut etre pas à ce que tu désire
const int R1 = 13;
const int RCW = 12;
const int RCCW = 11;
const int FDC1 = 10;
const int FDC2 = 9;
int etatFDC1;
int etatFDC2;
void setup() {
Serial.begin(115200); //on ne mets plus 9600, la liaison encaisse très bien 115200
digitalWrite(R1,LOW); pinMode(R1, OUTPUT);
digitalWrite(RCW,LOW); pinMode(RCW, OUTPUT);
digitalWrite(RCCW,LOW);pinMode(RCCW, OUTPUT);
pinMode(FDC1, INPUT_PULLUP);
pinMode(FDC2, INPUT_PULLUP);
etatFDC1 = digitalRead(FDC1);
etatFDC2 = digitalRead(FDC2);
}
void loop() {
arrivee_rondin(); //pendant 1 seconde par relais R1
serrage_des_mors(); //jusqu'à FDC1
rotation_perceuse();
avance_perceuse(); //jusqu'à FDC3
recul_perceuse(); //jusqu'à FDC4
ouverture_des_mors(); //jusqu'à FDC2
}
// ***************************************** positionnement rondin par tempo
void arrivee_rondin() {
digitalWrite(R1, HIGH); // pousse le rondin
delay(1000); // pendant 1 seconde
digitalWrite(R1, LOW); // coupe alim verrin
delay(1000); //après une attente de 1 seconde
}
// ***************************************** fermeture avec WHILE
void serrage_des_mors() {
etatFDC1 = digitalRead(FDC1);
while (etatFDC1 == HIGH) { // tant que FDC1 n'est pas actionné
digitalWrite(RCW, HIGH); // le relais 1 (CW)colle et le moteur tourne pour serrer les mors sur le rondin
etatFDC1 = digitalRead(FDC1); // lit le FDC1
}
digitalWrite(RCW, LOW); // le relais 1 passe au repos le rondin est serré par les mors
delay(500);
}
void rotation_perceuse(){;}
void avance_perceuse() {;} //jusqu'à FDC3
void recul_perceuse() {;} //jusqu'à FDC4
// ***************************************** ouverture avec DO WHILE
void ouverture_des_mors() {
do { //faire tant que FDC2 n'est pas actionné
digitalWrite(RCCW, HIGH); //coller le relais 2 (CCW) ,moteur en inverse pour deserrer les mors
etatFDC2 = digitalRead(FDC2);
} while (etatFDC2 == HIGH); // tant que le FDC n'est pas actionné
digitalWrite(RCCW, LOW); // le relais 2 passe au repos le rondin est deserré
delay(500);
}
