porte de poulailler encore

bonjour,

une porte de poulailler encore!!! le programme a été crée avec mes faibles compétence mais la porte fonctionne.

le principe une cellule photoélectrique qui lorsque la valeur descend en dessous de 100 active un L298 et ferme la porte l’arrêt de la porte se fait par l’intermédiaire d’un FDC bon j’ai plusieurs petit pb mais le but est de les résoudre un par un.

je voudrais rajouter une tempo avant la fermeture de la porte (la cellule >100 on attend X min et on ferme la porte)
la fonction “milli” pourrais faire l’affaire mais je ne la comprend pas cela dit un delay est largement suffisant sauf que lorsque je place dans ma boucle if ou dans void fermeture cela ne fonctionne pas le script se bloque

merci de votre aide

le code

 /* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A7
int sensorValue = 0; // variable ou est stocké la valeur de la cellule

/*la porte*/
const int moteurA = 6; // moteur porte 
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D6 fin de course haut
const int hallbas = 5; // Broche D7 fin de course bas 
int sensorValuehaut =0 ; // variable de stockage FDC haut
int sensorValuebas =0 ; // variable de stockage FDC bas 

/*bouton poussoir*/
const int bouton = 2; // bouton poussoir sur broche D2 
int etatbouton = 0; // variable de stockage du bouton 

const int LedVerte =9; // LedVerte connectée sur broche D9

void setup() {
 
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie 
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  pinMode( bouton, INPUT); // declare la broche omme une entree
  pinMode (13, OUTPUT); // declare la broche 13 comme une sortie BUZZER
  }

  /* parametre de d'ouverture et fermeture de la porte */
  
void ouverture(){ // enclenche l'ouverture de la porte 
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)
}

void fermeture(){
  //delay(1000); MARCHE PAS !!!!!!!!!!!!!
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
}
 void stop(){
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 }
 
void loop() {
  
  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(sensorValue); // on imprime la valeur sur le moniteur serie
  Serial.print ("  FDC haut =");
  Serial.print(sensorValuehaut); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.print(sensorValuebas); // on affiche sur le port serie
  Serial.print("  bouton =");
  Serial.println(etatbouton);
  /*attention le delay influ sur le temps de reaction des capteurs*/
  //delay(100); // tempo pour affichage plus lisible
  
  sensorValue = analogRead(analogInPin); // lecture valeur cellule photoelectrique 
  sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
  sensorValuebas = digitalRead( hallbas ); // lecture du capteur a Effet Hall 
  etatbouton = digitalRead(bouton );// lecture de l'etat du bouton 
  
 /*partie lancement du d'ouverture ou fermeture en fonction de la cellule*/
 
 if (sensorValue > 300) // si la valeur lue est correspondante au jour  
{
ouverture();
}
 if (sensorValuehaut == LOW) // si fin de course haut activé
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 //delay(1000); // empeche l'inertie du moteur
 digitalWrite (ENA, LOW); // desactive le l298
  }

 if (sensorValue < 100) // si la valeur lue est correspondante a la nuit 
{
  //delay (1000); MARCHE PAS !!!!!!!!!!!!!
fermeture();
}
if (sensorValuebas == LOW && sensorValue <100) // si fin de course bas activé et (cellule <100 sinon empeche l'ouverture de la porte) 
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 delay(1000);
 digitalWrite (ENA, LOW); // desactive le l298
  }
 //delay(1);
}

Le schéma (on peut poster un message avec une image associée, puis copier l'adresse de l'image, puis editer le post pour mettre l'image dans le texte):

le script se bloque

On peut alimenter l'Arduino:

  • en 7,5V à 12V par la prise alim
  • en 7,5V à 12V par la broche Vin
  • en 5V par l'USB
  • en 5V par la broche 5V

Alimenter par du 5V sur Vin n'est pas suffisant, il y a un régulateur de tension série derrière et on ne va avoir plus que 3,5V. Si les moteurs se mettent à tourner, il est possible que le 5V diminue un peu, et l'Arduino ne sera plus alimenté suffisamment.

Dans ce poulailler, on peut

  • alimenter Arduino par le 5V du L298 mais sur la broche du 5V
  • alimenter Arduino par le 12V de la batterie sur la broche Vin

On peut tester si l'Arduino est suffisamment alimenté avec un voltmètre et si on en a pas trois leds ROUGES et une résistance 100ohms en série. En dessous d 3*1,5V les leds ne s'allument pas. A 5V cela fait dans les 5mA et elles brillent.


Faire une tempo avec delay est simple, mais pendant ce temps on ne peut rien faire d'autre. Millis est comme une horloge, on vient la regarder de temps en temps. On peut faire autre chose en attendant.

Exemple:

  • quand le soleil baisse, je ferme la porte du poulailler, mais j'attends 10mn avant pour être sûr que les poules soient rentrées -> je n'ai rien à faire pendant l'attente, je peux utiliser un delay(10ul60ul1000ul); (ul pour faire le calcul sur des entiers longs)
  • quand le soleil baisse, je ferme la porte du poulailler, mais j'attends 10mn avant pour être sûr que ce n'est pas une poule qui est arrêtée devant la cellule pour pondre un oeuf de Pâques -> quand la cellule baisse, je démarre la temporisation t0=millis(); et pendant la temporisation (un while) je l'arrête si le soleil revient. Cela donne quelque chose comme
void fermeture(void)
{
  long t0=millis();
  while (millis() - t0 < 10ul*60ul*1000ul)
  {
    if (sensorValue > 300) return; // si la valeur lue est correspondante au jour on ne ferme plus
    <ici on peut aussi faire aussi autre chose si on n'emploie pas trop delay>
  }
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
}

j'ai branché sur le 5v l’Arduino depuis le l298 de plus je crois que j’économise quelques milliampère si je n'utilise pas le régulateur de tension de l’Arduino

je ne comprend pas le calcul pour avoir 10min et je n'ai rien trouver sur le net

ensuite je me retrouve avec le meme pb mon script n'est pas bon alors j'ai rajouté les fin de courses dans le void ouverture et fermeture sinon j'avais un conflit et les moteur ne se lancait pas.

Maintenant lorsque j'ajoute un delay il ne se lance pas au debut du void ouverture mais a la fin ce qui laisse forcer le moteur alors que FDC est activé je suis en train de faire un essai avec la fonction millis que tu ma donné mais je pense que je vais avoir le meme pb

void ouverture(){ // enclenche l'ouverture de la porte

delay (1000);// se lance a la fin du void et pas au debut

digitalWrite (ENA, HIGH); // active le L298
digitalWrite (LedVerte, HIGH); // on allume la Led
digitalWrite (moteurA, HIGH); // ouverture porte
digitalWrite (moteurB, LOW); // ouverture porte
analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)

if (sensorValuehaut == LOW) // si fin de course haut activé
{
digitalWrite (moteurA, LOW); // arret porte
digitalWrite (moteurB, LOW); // arret porte
//delay(1000); // empeche l'inertie du moteur
digitalWrite (ENA, LOW); // desactive le l298
}
}

je ne comprend pas le calcul pour avoir 10min

10 minutes c'est
10 * 60 secondes (60 secondes par minutes)
1060s c'est 1060*1000 millièmes de secondes. En utilisant millis on a des millièmes de secondes
Il faut faire les calculs avec un type qui puisse contenir le résultat 600.000. Dans un int on ne peut aller que jusqu'à 32000, il faut donc prendre un entier long. Non signé, on calcule des durées, d'où le ul (unsigned long)
delay(600000ul); c'est donc une attente de 10 mn (aà réduire pour les premiers tests)

je suis en train de faire un essai avec la fonction millis que tu ma donné mais je pense que je vais avoir le meme pb

J'ai juste entouré ta fonction avec la temporisation. Je n'ai pas cherché à changer le code...
Je n'ai pas les moyens de tester ce code, je n'ai pas de poule!

Maintenant lorsque j'ajoute un delay il ne se lance pas au debut du void ouverture mais a la fin

Si des modifications ont été faites, redonne le code complet.

Pour savoir ce que fait la tempo, il suffit de remplacer

delay(1000);

par

Serial.println("Je vais faire delay");
delay(1000);
Serial.println("Je viens de finir delay");

Bien souvent le code fait ce qu'on lui dit, mais on en a une autre impression!

j’y voie un peu clair merci en plus j’aurais pu voir le calcul honte a moi !!!

alors finalement voila comment ça a l’air de se passer:
il fait jour → attend x seconde delay ou millis
→ lance l’ouverture
→ le FDC arrete l’ouverture

mais comme il fait jour je repars dans la boucle 1 fois

j’ai essayé plusieurs manip et entre autre de rajouter une condition de plus dans le if en fonction du FDC mais ca ne change rien

   /* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A7
int sensorValue = 0; // variable ou est stocké la valeur de la cellule

/*la porte*/
const int moteurA = 6; // moteur porte 
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D6 fin de course haut
const int hallbas = 5; // Broche D7 fin de course bas 
int sensorValuehaut =0 ; // variable de stockage FDC haut
int sensorValuebas =0 ; // variable de stockage FDC bas 

/*bouton poussoir*/
const int bouton = 2; // bouton poussoir sur broche D2 
int etatbouton = 0; // variable de stockage du bouton 

const int LedVerte =9; // LedVerte connectée sur broche D9

void setup() {
 
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie 
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  pinMode( bouton, INPUT); // declare la broche omme une entree
  pinMode (13, OUTPUT); // declare la broche 13 comme une sortie BUZZER
  }

  /* parametre de d'ouverture et fermeture de la porte */
  
void ouverture(void){ // enclenche l'ouverture de la porte 
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)
  if (sensorValuehaut == LOW) // si fin de course haut activé
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 //delay(1000); // empeche l'inertie du moteur pas neccessaire a la montée
 digitalWrite (ENA, LOW); // desactive le l298
  }
}

void fermeture(void){
  long t0=millis();
  while (millis() - t0 < 2ul*1000ul)
  {
    if (sensorValue > 300) return; // si la valeur lue est correspondante au jour on ne ferme plus
    //<ici on peut aussi faire aussi autre chose si on n'emploie pas trop delay>
  }
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
 
}
 
void loop() {
  
  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(sensorValue); // on imprime la valeur sur le moniteur serie
  Serial.print(" moteurA = ");
  Serial.print(digitalRead (moteurA) );
  Serial.print(" moteurB = ");
  Serial.print(digitalRead (moteurB));
  Serial.print ("  FDC haut =");
  Serial.print(sensorValuehaut); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.print(sensorValuebas); // on affiche sur le port serie
  Serial.print("  bouton =");
  Serial.println(etatbouton);
  /*attention le delay influ sur le temps de reaction des capteurs*/
  //delay(100); // tempo pour affichage plus lisible
  
  sensorValue = analogRead(analogInPin); // lecture valeur cellule photoelectrique 
  sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
  sensorValuebas = digitalRead( hallbas ); // lecture du capteur a Effet Hall 
  etatbouton = digitalRead(bouton );// lecture de l'etat du bouton 
  
 /*partie lancement du d'ouverture ou fermeture en fonction de la cellule*/
 
 if (sensorValue > 300) // si la valeur lue est correspondante au jour  
{
ouverture();
}


 if (sensorValue < 100) // si la valeur lue est correspondante a la nuit 
{

fermeture();
}

petite erreur j’ai mis le mauvais script

voila le bon enfin presque

 /* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A7
int sensorValue = 0; // variable ou est stocké la valeur de la cellule

/*la porte*/
const int moteurA = 6; // moteur porte 
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D6 fin de course haut
const int hallbas = 5; // Broche D7 fin de course bas 
int sensorValuehaut =0 ; // variable de stockage FDC haut
int sensorValuebas =0 ; // variable de stockage FDC bas 

/*bouton poussoir*/
const int bouton = 2; // bouton poussoir sur broche D2 
int etatbouton = 0; // variable de stockage du bouton 

const int LedVerte =9; // LedVerte connectée sur broche D9

void setup() {
 
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie 
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  pinMode( bouton, INPUT); // declare la broche omme une entree
  pinMode (13, OUTPUT); // declare la broche 13 comme une sortie BUZZER
  }

  /* parametre de d'ouverture et fermeture de la porte */
  
void ouverture(void){ // enclenche l'ouverture de la porte 
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)
 
  if (sensorValuehaut == LOW) // si fin de course haut activé
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 //delay(1000); // empeche l'inertie du moteur pas neccessaire a la montée
 digitalWrite (ENA, LOW); // desactive le l298
  }
}

void fermeture(void){
  long t0=millis();
  while (millis() - t0 < 2ul*1000ul)
  {
    if (sensorValue > 300) return; // si la valeur lue est correspondante au jour on ne ferme plus
    //<ici on peut aussi faire aussi autre chose si on n'emploie pas trop delay>
  }
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
  
 if (sensorValuebas == LOW && sensorValue <300) // si fin de course bas activé et (cellule <300 sinon empeche l'ouverture de la porte) 
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 delay(1000);
 digitalWrite (ENA, LOW); // desactive le l298
  }
}
 
void loop() {
  
  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(sensorValue); // on imprime la valeur sur le moniteur serie
  Serial.print(" moteurA = ");
  Serial.print(digitalRead (moteurA) );
  Serial.print(" moteurB = ");
  Serial.print(digitalRead (moteurB));
  Serial.print ("  FDC haut =");
  Serial.print(sensorValuehaut); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.print(sensorValuebas); // on affiche sur le port serie
  Serial.print("  bouton =");
  Serial.println(etatbouton);
  /*attention le delay influ sur le temps de reaction des capteurs*/
  //delay(100); // tempo pour affichage plus lisible
  
  sensorValue = analogRead(analogInPin); // lecture valeur cellule photoelectrique 
  sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
  sensorValuebas = digitalRead( hallbas ); // lecture du capteur a Effet Hall 
  etatbouton = digitalRead(bouton );// lecture de l'etat du bouton 
  
 /*partie lancement du d'ouverture ou fermeture en fonction de la cellule*/
 
 if (sensorValue > 300) // si la valeur lue est correspondante au jour  
{
ouverture();
}


 if (sensorValue < 100) // si la valeur lue est correspondante a la nuit 
{

fermeture();
}

 //delay(1);
}

D'abord les attentes. A priori quand tu attend, tu n'a rien à faire, tu peux donc utiliser delay. L'avantage de passer par millis, est que si plus tard tu veux rajouter quelque chose pendant le temps d'attente, c'est déjà fait.


Au niveau de la déclaration des variables. Ce n'est pas important dans ce cas, car le programme est petit et il n'a pas besoin d'aller vite. Mais c'est une bonne habitude de les choisir avec attention.

les numéros des broches vont de 0 à 53 avec une Méga, il faut plutôt un nombre 8 bits non signé -> uint8_t (perso je prends byte, mais les bibliothèques utilisent uint8_t). Au lieu de

const int analogInPin = A0; // cellule photoelectrique sur broche A7
Mettre
const uint8_t analogInPin = A0; // cellule photoelectrique sur broche A7

cela rend le code plus lisible car on comprnd mieux ce que l'on peut stocker. Ceal évite aussi à l'exécution de faire le calcul int -> uint8_t. Au passage, la cellule est sur A0 ou A7? ,le commentaire ne correspond pas.

Pour sensorValue, si elle est issue d'une conversion analogique elle peut aller de 0 à 1023, il faut un nombre 16 bits, mais un non signé est mieux (cela va dire à celui qui lit que la valeur n'est que positive).

int sensorValue = 0; // variable ou est stocké la valeur de la cellule
devient
uint16_t sensorValue = 0; // variable ou est stocké la valeur de la cellule

Le poussoir n'a que deux états, autant prendre une variable booléenne. Si on veut aller dans la finesse, on définira deux valeurs appuyé et relâché, mais bien souvent on se contente de true et false. Je pense d'ailleurs que c'est plus simple à lire. On va dire false il n'est pas appuyé, true si il l'est:

boolean etatbouton = false; // variable de stockage du bouton, true si appuyé
ou encore
boolean etatbouton = false; // variable de stockage du bouton, non appuyé.

On aurait aussi pu prendre LOW et HIGH, mais ce qui importe pour comprendre c'est si il est appuyé ou pas. C'est plus clair de dire = true ou HIGH que 1 en tout cas.

Il faut faire pareil pour les autres déclarations.

const int hallhaut = 4; // broche D6 fin de course haut
const int hallbas = 5; // Broche D7 fin de course bas

Ces deux lignes ont des commentaires de brioches qui ne correspondent pas. Cela n'empêche pas le programme de fonctionner, mais mettre les bons noms est plus facile à lire et comprendre. C'est le cas pour ceux qui lisent le code, mais aussi pour toi si dans 6 mois tu t'y replonges.


sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall

On peut effectivement écrire :

sensorValuehaut = digitalRead( hallhaut );
if (sensorValuehaut == HIGH)....

mais on peut faire directement:
if (digitalRead( hallhaut ) == HIGH)....


Le programme commence par le loop. Lopp fait 4 choses:

  • un affichage
  • la lecture des boutons
  • l'ouverture si c'est utile
  • la fermeture si c'est nécessaire.

Je suppose que c'est ce que tu veux, à toi de penser oui ou non. L'ouverture si c'est utile? on peut traduire par:

  • Il faut ouvrir si c'est le jour ==> if (sensorValue > 300) ouverture();
    ou
  • Il faut ouvrir si c'est le jour ET que la porte n'est sas ouverte. Double condition! Il faut mémoriser quelque part si la porte est ouverte ou fermée. En générat on a une variable booléenne etatDeLaPorte.

Ici ce n'est pas la peine, si la porte est fermée sensorValuebas est activé ou mieux si sensorValuehaut n'est pas activé

if ((sensorValue > 300) && (sensorValuehaut == false)) ouverture(); // Si c'est le jour et que la porte est fermée

Moi, c'est comme cela que je l'écris mais dans ton style cela va donner

if ((sensorValue > 300) && (sensorValuehaut == LOW)) // Si c'est le jour et que la porte est fermée
{
ouverture();
}

Pareil pour la fermeture


Pour la fonction qui ouvre la porte, que veux-t-on (c'est encore ma supposition, je peux me tromper)?

  • on met les moteurs en route
  • on arrête les moteurs QUAND la porte est ouverte
    Ce qui est écrit:
  • on met les moteurs en route
  • on les arrête immédiatement SI la porte est ouverte (sinon on s'en va)

Comme la porte n'a pas le temps de s'ouvrir instantanément, la condition

if (sensorValuehaut == LOW) // si fin de course haut activé

est toujours fausse et l'arrêt ne sera pas fait. et on a fini la fonction
De toutes façons même si la porte s'ouvrait instantanément la variable n'est pas mise à jour, et le test serait faux. Il faudrait mettre:

sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
if (sensorValuehaut == LOW) // si fin de course haut activé
ou encore:
if (digitalRead( hallhaut ) == LOW) // si fin de course haut activé

C'est pas trop grave, comme c'est le jour, on va recommencer à allumer les moteur qui sont déjà en route, et on va appeler plein de fois la fonction. Cela fonctionne, sauf si on corrige loop comme ci dessus.

Mais si on ne corrige pas, quand il fait jour et que la porte est ouverte, on appelle quand même ouverture qui met les moteurs en route et qui les arrête immédiatement. Ça doit clignoter, même si c'est éteint plus longtemps.

on arrête les moteurs quand la porte est ouverte? C'est mal formulé parce que je fais quoi en attendant ? Et si elle n'est pas ouverte?... Autre formulation plus exacte: j'attends (mon action) tant que la porte n'est pas ouverte. Et ça, on l'écrit plutôt tant que la porte n'est pas ouverte, j'attends (mon action):

while ((digitalRead( hallhaut ) == LOW) {} // J'attends que la porte soit ouverte
ou
while ((digitalRead( hallhaut ) == LOW); // J'attends que la porte soit ouverte
ou
while (sensorValuehaut == LOW)
{
sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
}; // J'attends que la porte soit ouverte

Cela ferait à peu près:

void ouverture(void){ // enclenche l'ouverture de la porte
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)

 while ((digitalRead( hallhaut ) == LOW); // J'attends que la porte soit ouverte

 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 //delay(1000); // empeche l'inertie du moteur pas neccessaire a la montée
 digitalWrite (ENA, LOW); // desactive le l298
  }
}

Et on fait pareil pour la fermeture.

Je ne suis pas allé dans le détail, il se peu qu'il y ait encore des erreurs (ce serait d'ailleurs normal).

génial merci beaucoup a présent il va quand même me falloir deux jour pour digérer tout ça :slight_smile:
pour les commentaires en effet j,ai fait des modif quand j'ai soudé la platine et je n'ai pas mis a jour ce sera fait

la pour ce soir je pense prendre un doliprane et au lit
encore merci

il va quand même me falloir deux jour pour digérer tout ça
je pense prendre un doliprane

Ha bon? Le doliprane ça fait digérer?

Faut que je sois sérieux...

Le problème c'est que quand on a tout digérer, on ne peut s'empêcher de recommencer... Bon travail et bon repos. On reste en contact et/ou je passe le relais(allusion bien sûr aux contact travail et repos des relais)

Bonjour,

Je ne suis pas un grand programmeur non plus, mais je n’aime pas les “while”, je préfère abuser des “if else” et puis en ajoutant quelques variables on évite de répéter une commande inutilement à chaque boucle.

Faudra voir si ce délay(1000) est vraiment utile après ça ??

A essayer, pas testé,

/* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A7
int sensorValue = 0; // variable ou est stocké la valeur de la cellule

/*la porte*/
const int moteurA = 6; // moteur porte
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D6 fin de course haut
const int hallbas = 5; // Broche D7 fin de course bas
int sensorValuehaut = 0 ; // variable de stockage FDC haut
int sensorValuebas = 0 ; // variable de stockage FDC bas

/*bouton poussoir*/
const int bouton = 2; // bouton poussoir sur broche D2
int etatbouton = 0; // variable de stockage du bouton

const int LedVerte = 9; // LedVerte connectée sur broche D9

// les variables :
unsigned long chrono = 0;// variable contenant un temps mémorisé en millisecondes.
unsigned long retard = 120000; // 2 mn
bool ouvert;
bool clos;
bool tourne = 0; // indique que le moteur tourne


void setup()
{
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  pinMode( bouton, INPUT); // declare la broche omme une entree
  pinMode (13, OUTPUT); // declare la broche 13 comme une sortie BUZZER
}

/* parametre de d'ouverture et fermeture de la porte */

void ouverture()
{ // enclenche l'ouverture de la porte
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, HIGH); // on allume la Led
  digitalWrite (moteurA, HIGH); // ouverture porte
  digitalWrite (moteurB, LOW); // ouverture porte
  analogWrite (ENA, 160); // PWM moteur a l'ouverture (0.255)
  tourne = true;
}

void fermeture()
{
  //delay(1000); MARCHE PAS !!!!!!!!!!!!!
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
  tourne = true;
}

void stop()
{
  digitalWrite (moteurA, LOW); // arret porte
  digitalWrite (moteurB, LOW); // arret porte
  digitalWrite (ENA, LOW); // desactive le l298
  tourne = false;
}

void loop()
{

  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(sensorValue); // on imprime la valeur sur le moniteur serie
  Serial.print ("  FDC haut =");
  Serial.print(sensorValuehaut); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.print(sensorValuebas); // on affiche sur le port serie
  Serial.print("  bouton =");
  Serial.println(etatbouton);
  /*attention le delay influ sur le temps de reaction des capteurs*/
  //delay(100); // tempo pour affichage plus lisible

  sensorValue = analogRead(analogInPin); // lecture valeur cellule photoelectrique
  sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
  sensorValuebas = digitalRead( hallbas ); // lecture du capteur a Effet Hall
  etatbouton = digitalRead(bouton );// lecture de l'etat du bouton

  /*partie lancement du d'ouverture ou fermeture en fonction de la cellule*/


  if (!ouvert) // si la valeur lue est correspondante au jour
  { // et fdc non atteint
    if (sensorValue > 300)// jour
    {
      if (!tourne && ((millis() - chrono) > retard)) ouverture();
    }
    else chrono = millis();// RAZ si jour pas maintenu

    if (!sensorValuehaut)//fdc haut atteint
    {
      stop(); // si fin de course haut activé
      ouvert = true;
      clos = false;
    }
  }

  if (!clos)
  {
    if (sensorValue < 100) // si la valeur lue est correspondante a la nuit
    {
      if (!tourne && ((millis() - chrono) > retard))fermeture();
    }
    else chrono = millis();

    if (sensorValuebas == LOW && sensorValue < 100) // si fin de course bas activé et (cellule <100 sinon empeche l'ouverture de la porte)
    {
      stop();
      delay(1000); // ???
      ouvert = false;
      clos = true;
    }
  }
}

Je n’aime pas les “while”, je préfère abuser des “if else” et puis en ajoutant quelques variables on évite de répéter une commande inutilement à chaque boucle.

Il n’y a pas de meilleur programme, chacun va trouver une solution différente. Un critère essentiel est que l’on puisse écrire son code, le comprendre et pouvoir le relire. Et en particulier au bout de 6 mois.

Dans la solution que j’ai esquissée, j’ai essayer de coller à la solution proposée. J’aurais pu dire “j’aurais fais autrement, j’aurais fait ceci et cela”, mais cela aurait été moins pédagogique. C’est sûr que si je devais écrire ce programme, je n’aurais probablement pas fait comme ça. Mais ma solution dépend de mon histoire. Et c’est normal que d’autres font autrement. Et dans les critères un qui est très important est celui énonçé “Je n’aime pas”.

Pour affecter la variable jour (true/false) ) la valeur lue de la cellule par analogRead(analogInPin) il y a pleins de solutions, laquelle est la meilleure?

sensorValue = analogRead(analogInPin);
if (sensorValue > 300) jour = true;
else jour = false;
if (analogRead(analogInPin) > 300) jour = true;
else jour = false;
jour = false;
if (analogRead(analogInPin) > 300) jour = true;
jour = (analogRead(analogInPin) > 300);
jour = analogRead(analogInPin) > 300? true, false;

Si je prends en compte les critères de lisibilité, la première solution (que je n’aime pas) peut arriver en tête.

Maintenant, je pense que les while amènent plus de bugs que les if then else, et c’est rare de trouver des do while. Ce sont des choix personnels.


Pour en revenir au code d’@achess, c’est simplement une autre approche, mais dans l’état, il y a un problème 3 lignes avant la fin:
delay(1000); // ? ? ?
Quand on arrête un moteur à courant continu, on peut:

  • le débrancher
  • imposer la même tension sur ses deux fils au moins pendant qu’il s’arrête
    Dans la deuxième solution, tant que le moteur n’est pas a l’arrêt, il va produire une fem et un courant va passer. Il transforme l’énergie cinétique en chaleur. Et donc il va être freiné. @yanosh31 indique pour l’ouverture on ne freine pas, mais pour la fermeture oui. La temporisation n’est donc pas au bon endroit. Avec cette solution, il serait sans doute plus simple (une seule fonction d’arrêt) de mettre systématiquement le frein. C’est une proposition.

Dans ce code, je n’aime pas les variables ouvert et clos, pour moi il y en a une de trop. mais c’est toujours ce critère “aimer” qui intervient.


Quelle est la raison de

&& sensorValue < 100

5 lignes avant la fin? Un nuage passe le soir, la porte attend le nuage commence à passer, La porte commence à se refermer, et le nuage s’en va. ) ce moment sensorValue > 100 et l’ordre d’arrêt n’est plus créé. Il me semble en trop.

aujourd’hui je ne vais pas avoir trop de temps mais ce soir je m’y recolle d’ailleurs ce matin en me levant le premier mot qui m’est venu en tête c’est boolean :slight_smile:

je fait juste un point sur ce projet j’aurais pu prendre un programme tout fait d’ailleurs avec mes faibles compétences en prog ca aurait été certainement plus facile et certainement moins long.

mais le but est de faire un programme que je comprenne avec des variable et des fonction que je connais et je suis ici pour en apprendre d’autres

j’irais même au dela en disant que même d’autre méthode m’intéresse du moment que je les comprenne
et que je sache les mettre en forme

je m’aperçois que programmer est parfois ingrat et il faut de la méthode petit a petit après une succession d’échec on fini par y arriver et la … quel bonheur

“&& sensorValue < 100” alors je l’ai changer par if (sensorValuebas == LOW && sensorValue <300)
car au moment de la fermeture si la valeur de la cellule passait au dela de 100 le capteur etait hinibé et la porte ne s’arrêtait plus de descendre

je fait juste un point sur ce projet j’aurais pu prendre un programme tout fait d’ailleurs avec mes faibles compétences en prog ca aurait été certainement plus facile et certainement moins long.

Pas si sûr. Dans un code que l’on a pas écrit, c’est souvent difficile de changer une virgule. Et cela ne dépend pas des compétences, car plus on avance plus on se cherche des choses compliquées.

[ . . . ] Je m’aperçois que programmer est parfois ingrat et il faut de la méthode petit a petit après une succession d’échec on fini par y arriver et la … quel bonheur

Je partage cet opinion. D’autant plus que bien souvent les codes que l’on trouve ne sont pas excellents. J’ai vu une fois dans une bibliothèque officielle:

loop(void) {delay(3000);}

qui ne faite rien de plus que

loop (void) {}

car une fois que la tempo est finie, on la recommence, et on ne fait rien. Dans la deuxième formule non plus. Mais je viens de voir

loop(void) {delay(1000); delay(1000); delay(1000); delay(1000); delay(1000); }

Comme quoi, on n’est jamais bien servi que par soi même!


&& sensorValue < 100" alors je l’ai changer par if (sensorValuebas == LOW && sensorValue <300)
car au moment de la fermeture si la valeur de la cellule passait au dela de 100 le capteur etait hinibé et la porte ne s’arrêtait plus de descendre

C’était dans le code d’achess, il y a effectivement ce problème.

Ne le prends pas mal, j'écrivais "je n'aime pas les while" c'est juste parce que c'est bloquant comme delay(). Si tu fais une surveillance d'entrées analogiques en même temps, tu risques de rater des événements.

Pour en revenir au code d'@achess, c'est simplement une autre approche, mais dans l'état, il y a un problème 3 lignes avant la fin:
delay(1000); // ? ? ?
Quand on arrête un moteur à courant continu, on peut:

  • le débrancher
  • imposer la même tension sur ses deux fils au moins pendant qu'il s'arrête

Les diodes de roue libres sont faites pour ça.

Si le moteur risque de forcer, on peut contrôler le courant qui circule avec un capteur ou une résistance, ou même décaler le fin de course pour que le moteur s'arrête avant la butée. Une lame de métal souple peut faire l'affaire.

yanosh31:
“&& sensorValue < 100” alors je l’ai changer par if (sensorValuebas == LOW && sensorValue <300)
car au moment de la fermeture si la valeur de la cellule passait au dela de 100 le capteur etait hinibé et la porte ne s’arrêtait plus de descendre

C’est pour ça qu’il faut utiliser des booleans, par exemple “moteurTourne” pour ne plus tenir compte de la valeur de la cellule dès que l’action est lancée.

Les diodes de roue libres sont faites pour ça.

Les diodes de roues libres ne sont pas faites pour freiner le moteur. Effectivement si on n’alimente plus le pont, via les diodes de roues libres, le pont sera encore alimenté. Mais cela ne freine pas bien car on n’impose pas le zéro volt aux bornes du moteur. Si le pont en lui même a une consommation négligeable cela ne freine rien du tout.

je n’aime pas les while" c’est juste parce que c’est bloquant comme delay().

Mais dans le programme donné il n’y a qu’un seul capteur à lire, et on peut le mettre dans le while; et encore sa lecture est automatiquement faite si on utilise

while (!(digitalRead( hallhaut )); // J’attends que la porte soit ouverte

&& sensorValue < 100" alors je l’ai changer par if (sensorValuebas == LOW && sensorValue <300)

Oui, mais dans le dernier programme, sautf erreur de ma part, (sensorValuebas == LOW) suffit

j’ai décidé de reprendre le prog du début et en ajoutant les booléennes pour les capteurs parceque le principe me plait énormément et peut être qu’il pourrais éviter les comportement étrange du programme,

je reprend la phrase d’achess
“C’est pour ça qu’il faut utiliser des booleans, par exemple “moteurTourne” pour ne plus tenir compte de la valeur de la cellule dès que l’action est lancée.”

d’ou la question suivante est ce que le fait d’avoir une lecture de la cellule en vrai ou faux pourrais éviter des changement intempestif dans la boucle loop
je reprend le script

sensorValue = analogRead(analogInPin);
if (sensorValue > 300) jour = true;
else jour = false;

mais si je veux l’état nuit je doit rajouter

if (sensorValue < 100) nuit= true;
else nuit= false;

question : si on donne un etat LOW HIGH a la cellule et si l’etat change pendant l’ouverture ou fermeture
cela va t’il interrompre la montéé ou descente de la porte ? si j’ai bien suivi aussi WHILE peut faire cette action

j’ai essayé rapido ça bug mais ne dite rien (je doit trouver)

il y a des choses vraiment intéressante dans le fil de discussion mais je n’arrive pas a tout suivre je vais proceder par etape si vous voulez bien

il y a une chose importante mais j’ai pas reussi a trouver j’aurais voulu dans le port serie l’etat HIGH ou LOW de mes capteurs la c’est du 0 ou 1 et effectivement vous avez raison dans la comprehesion du programme ca peut induire en erreur

j’ai noté aussi la partie pour l’arret du moteur et eviter ainsi l’inertie a la descente je vais faire quelques essai en situation et voir cette option mais si je comprend bien si on inverse le sens du moteur l’espace de quelques milliseconde ca peut faire office de frein

le code épuré et corrigé

  /* script V3 avec l'etape des fdc integré dans les sequences 
  ouverture et fermeture !!!!! PAS MAL DU TOUT!!!!!*/
  
  /* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A0
int sensorValue = 0; // variable ou est stocké la valeur de la cellule

/*la porte*/
const int moteurA = 6; // moteur porte 
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D4 fin de course haut
const int hallbas = 5; // Broche D5 fin de course bas 
boolean sensorValuehaut = HIGH ; // variable de stockage FDC haut renvoie une valeur vrai si dessactivé
boolean sensorValuebas =HIGH ; // variable de stockage FDC bas renvoi une valeur vrai si desactivé 

/*les leds pour verifier l'etat de la porte */
const int LedVerte =9; // LedVerte connectée sur broche D9
const int LedRouge =8; // LedRouge connectée sur broche D8
void setup() {
 
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (LedRouge, OUTPUT); // declare la broche LedRouge comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie 
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  }

  /* parametre de d'ouverture et fermeture de la porte */
  
void ouverture(){ // enclenche l'ouverture de la porte 
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led verte
 digitalWrite (LedRouge, LOW); // on eteind la Led rouge
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)

 if (sensorValuehaut == LOW) // fin de course haut activé 
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 delay(1000); // empeche l'inertie du moteur 
 digitalWrite (ENA, LOW); // desactive le l298
  }

}

void fermeture(){
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led verte
  digitalWrite (LedRouge, HIGH); // on allume la led rouge
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
  
if (sensorValuebas == LOW)// fin de course bas activé
  { 
 digitalWrite (moteurA, LOW); // arret porte
 digitalWrite (moteurB, LOW); // arret porte
 delay(1000); //empeche l'inertie du moteur 
 digitalWrite (ENA, LOW); // desactive le l298
  }
}
 
void loop() {
  
  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(sensorValue); // on imprime la valeur sur le moniteur serie
  Serial.print ("  FDC haut =");
  Serial.print(sensorValuehaut); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.println(sensorValuebas); // on affiche sur le port serie
  
  sensorValue = analogRead(analogInPin); // lecture valeur cellule photoelectrique 
  sensorValuehaut = digitalRead( hallhaut ); // lecture du capteur a Effet Hall
  sensorValuebas = digitalRead( hallbas ); // lecture du capteur a Effet Hall 
  
 /*partie lancement du moteur*/
 
 if (sensorValue > 300) // si la valeur lue est correspondante au jour  
{
ouverture();
}

 if (sensorValue < 100) // si la valeur lue est correspondante a la nuit 
{
fermeture();
}

}

j’ai décidé de reprendre le prog du début et en ajoutant les booléennes pour les capteurs parceque le principe me plait énormément et peut être qu’il pourrais éviter les comportement étrange du programme,

Le fait de mettre des booléens ne change rien au comportement. Ce dernier provient de l’analyse du problème et de sa transcription. Entre ce qu’on veut, et ce que le programme comprend, il y a des différences et cela donne des bugs, des comportements étranges… Une femme disait à son mari informaticien “va au marché et achète un poulet. Et si il y a des œufs tu en prend 12. Comme il y avait des œufs, l’informaticien est revenu avec 12 poulets”.

Mettre des booléen quand on a besoin de booléens facilite la compréhension. Par exemple danc ce codes il y a un capteur “entier” et deux capteurs “booléens”. Écrire si “capteur=true” évite des confusions

d’ou la question suivante est ce que le fait d’avoir une lecture de la cellule en vrai ou faux pourrais éviter des changement intempestif dans la boucle loop

Pas du tout, on peut faire avec ou pas. Mais les choix faits permettent d’avoir un code compréhensible, lisible et améliore la transformation de l’idée en code.

sensorValue = analogRead(analogInPin);
if (sensorValue > 300) jour = true;
else jour = false;

mais si je veux l’état nuit je doit rajouter

if (sensorValue < 100) nuit= true;
else nuit= false;

Obligatoirement.

On peut d’ailleurs se passer de sensorValue:

if (analogRead(analogInPin) > 300) jour = true;
else jour = false;

et pareil pour nuit.
J’ai tendance à supprimer les variables quand on peut

  • on économise des données, et la place manque si le programme est gros. Autant prendre l’habitude plus tôt
  • moins on a de données, moins on a de choses à se souvenir (elle fait quoi cette variable déjà?)

si on donne un etat LOW HIGH a la cellule et si l’etat change pendant l’ouverture ou fermeture
cela va t’il interrompre la montéé ou descente de la porte ?

Avec ton ébauche de code de la première fois non, puisque quand tu décides de fermer tu rentre dans une fonction dont tu sors quand la porte est fermée. Maintenant si la cellule n’a que deux états et que la lumière oscille autour de la limite la porte va s’ouvrir et de refermer sans arrêt.

j’ai essayé rapido ça bug mais ne dite rien (je doit trouver)

Dans ce cas ne poste pas le code. Poste-le si tu ne trouve pas.

il y a une chose importante mais j’ai pas reussi a trouver j’aurais voulu dans le port serie l’etat HIGH ou LOW de mes capteurs la c’est du 0 ou 1 et effectivement vous avez raison dans la comprehesion du programme ca peut induire en erreur

LOW et 0 c’est pareil, du coup si on le passe sur la console série, l machine ne peut pas savoir si il faut mettre 0 ou LOW. Elle met le nombre. Elle pourait avec un booléen afficher true et false au lieu de 1 et 0, mais je pense que c’est pour avoir un code plus petit.

j’ai noté aussi la partie pour l’arret du moteur et eviter ainsi l’inertie a la descente je vais faire quelques essai en situation et voir cette option mais si je comprend bien si on inverse le sens du moteur l’espace de quelques milliseconde ca peut faire office de frein

Si on coupe l’alimentation d’un moteur à courant continu, il va s’arrêter

Si on le court-circuite (même tension des deux côtés: digitalWrite (moteurA, LOW); et digitalWrite (moteurB, LOW); il va s’arrêter encore plus vite, mais quel que soit le temps du “blocage” il ne repart jamais dans l’autre sens

Si on inverse la tension, il va s’arrêter plus vite encore. Mais si le temps est trop court, il risque de continuer à tourner, si le temps est trop long il repart dans l’autre sens!

C’est pour cela que bien souvent on met les 2 côtés à 0V. Ca fonctionne des fois moins bien, mais ça fonctionne toujours.


On débuggera le code si tu en a besoin.

Il reste les variables associées aux pins qui sont des int au lieu de uint8_t (moi j’écris byte par paresse)

const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

Pourquoi ENA n’a pas le même traitement que les autres (const)?

yanosh31:
question : si on donne un etat LOW HIGH a la cellule et si l'etat change pendant l'ouverture ou fermeture
cela va t'il interrompre la montéé ou descente de la porte ? si j'ai bien suivi aussi WHILE peut faire cette action

oui,
Pour que l'action se fasse sans interruption, par exemple :

sensorValue = analogRead(analogInPin);
if (sensorValue > 300) jour = true;
 
if (!moteurTourne && jour) ouverture ();// le moteur ne tourne pas encore

et dans 

void ouverture(){ // enclenche l'ouverture de la porte
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led verte
 digitalWrite (LedRouge, LOW); // on eteind la Led rouge
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)
moteurTourne = true;//après ça la commande d'ouverture n'est plus éxecutée
}

As tu essayé le code que j'ai proposé ?

J'avais programmé un retard de 2 mn comme demandé

“Pourquoi ENA n’a pas le même traitement que les autres (const)?”

je pense que si tu me pose la question c’est que je suis dans le faux
pour moi const int est une variable que l’on ne peux modifier et int oui
pour moi ENA est une variable que l’on modifie avec PWM d’ou le int

Achess je n’avais pas essayé ton code, coupable j’avoue mais j’ai tellement de
version de mon code que j’en ai oublié le tien c’est la que l’expression avoir la tete dans
le guidon prend tout son sens, j’ai pas levé la tête
je viens de l’essayer et oui il fonctionne il y a bien le retard de 2 min

dans ton script tu declare une variable

“bool ouvert;”
je pense qu’elle doit tenir compte de l’état de la porte mais dans le script elle n’est pas associé a quoi que ce soit
dans l’exemple le “boolean sensorValuebas =HIGH ;” viens lire l’entrée D5 correspondant sensorvaluebas
sensorValuebas = digitalRead( hallbas );

Vileroi

je n’ai pas ajouté const uint8_t volontairement car je ne comprend pas le principe
c’est trop compliqué a ce stade je préfère laisser comme tel

petite question comment vous faites pour mettre les message entre les accolades

sur le code d’Achess j’ai essaye de supprimer “sensorValue” par analogRead(analogInPin) mais ca ne fonctionne plus

"Pourquoi ENA n'a pas le même traitement que les autres (const)?"

je pense que si tu me pose la question c'est que je suis dans le faux 
pour moi const int est une variable que l'on ne peux modifier et int oui 
pour moi ENA est une variable que l'on modifie avec PWM d'ou le int 

Achess je n'avais pas essayé ton code, coupable j'avoue mais j'ai tellement de 
version de mon code que j'en ai oublié le tien c'est la que l'expression avoir la tete dans 
le guidon prend tout son sens, j'ai pas levé la tête
je viens de l'essayer et oui il fonctionne il y a bien le retard de 2 min 

dans ton script tu declare une variable 

"bool ouvert;" 
je pense qu'elle doit tenir compte de l’état de la porte mais dans le script elle n'est pas associé a quoi que ce soit 
dans l'exemple le "boolean sensorValuebas =HIGH ;" viens lire l'entrée D5 correspondant sensorvaluebas
sensorValuebas = digitalRead( hallbas ); 


Vileroi

je n'ai pas ajouté const uint8_t volontairement car je ne comprend pas le principe 
c'est trop compliqué a ce stade je préfère laisser comme tel 


petite question comment vous faites pour mettre les message entre les accolades 

sur le code d'Achess j,ai essaye de supprimer "sensorValue"  par analogRead(analogInPin) mais ca ne fonctionne plus [code]  /* script epuré avec les etapes  du code d'achess */
  
  /* la cellule photo*/
const int analogInPin = A0; // cellule photoelectrique sur broche A0


/*la porte*/
const int moteurA = 6; // moteur porte 
const int moteurB = 7; // moteur porte
int ENA = 10; // broche PWM moteur

/* les fin de courses haut et bas */
const int hallhaut = 4; // broche D4 fin de course haut
const int hallbas = 5; // Broche D5 fin de course bas 
int sensorValuehaut = 0 ; // variable de stockage FDC haut
int sensorValuebas = 0 ; // variable de stockage FDC bas

// les variables :
unsigned long chrono = 0;// variable contenant un temps mémorisé en millisecondes.
unsigned long retard = 30000; // 30sec
bool ouvert;
bool clos;
bool tourne = 0; // indique que le moteur tourne

/*les leds pour verifier l'etat de la porte */
const int LedVerte =9; // LedVerte connectée sur broche D9
const int LedRouge =8; // LedRouge connectée sur broche D8


void setup() {
  Serial.begin(9600); // port com
  pinMode (LedVerte, OUTPUT); // declare la broche LedVerte comme une sortie
  pinMode (LedRouge, OUTPUT); // declare la broche LedRouge comme une sortie
  pinMode (moteurA, OUTPUT); // declare la broche comme sortie
  pinMode (moteurB, OUTPUT); // declare la broche comme sortie
  pinMode (ENA, OUTPUT); // declare la broche PWM comme une sortie 
  pinMode( hallhaut, INPUT); // declare la broche comme une entrée
  pinMode( hallbas, INPUT); // declare la broche  comme une entrée
  }

  /* parametre de d'ouverture et fermeture de la porte */
  
void ouverture(){ // enclenche l'ouverture de la porte 
 digitalWrite (ENA, HIGH); // active le L298
 digitalWrite (LedVerte, HIGH); // on allume la Led verte
 digitalWrite (LedRouge, LOW); // on eteind la Led rouge
 digitalWrite (moteurA, HIGH); // ouverture porte
 digitalWrite (moteurB, LOW); // ouverture porte
 analogWrite (ENA,160); // PWM moteur a l'ouverture (0.255)
 tourne = true; // le moteur tourne et l'etat de la cellule n'est pas pris en compte
}

void fermeture(){
  digitalWrite (ENA, HIGH); // active le L298
  digitalWrite (LedVerte, LOW); // on eteint la Led verte
  digitalWrite (LedRouge, HIGH); // on allume la led rouge
  digitalWrite (moteurA, LOW); // fermeture porte
  digitalWrite (moteurB, HIGH); // fermeture porte
  analogWrite (ENA, 100); //PWM moteur a la fermeture (0.255)
  tourne = true; // le moteur tourne et l'etat de la cellule n'est pas pris en compte
}

 void stop()// arret du moteur 
{
  digitalWrite (moteurA, LOW); // arret porte
  digitalWrite (moteurB, LOW); // arret porte
  digitalWrite (ENA, LOW); // desactive le l298
  tourne = false;
}

void loop() {
  
  /* partie affichage sur le moniteur serie*/
  Serial.print("cellule = ");
  Serial.print(analogRead(analogInPin)); // on imprime la valeur de la cellule sur le moniteur serie
  Serial.print(" moteurA = ");
  Serial.print(digitalRead (moteurA) );
  Serial.print(" moteurB = ");
  Serial.print(digitalRead (moteurB));
  Serial.print ("  FDC haut =");
  Serial.print(digitalRead( hallhaut )); // on affiche sur le port serie
  Serial.print("  FDC bas =");
  Serial.println(digitalRead( hallbas )); // on affiche sur le port serie
  
  /*partie lancement du d'ouverture ou fermeture en fonction de la cellule*/
 
 if (!ouvert) // si la valeur lue est correspondante au jour
  { // et fdc non atteint
    if (analogRead(analogInPin) > 300)// jour
    {
      if (!tourne && ((millis() - chrono) > retard)) ouverture();
    }
    else chrono = millis();// RAZ si jour pas maintenu

    if (!sensorValuehaut)//fdc haut atteint
    {
      stop(); // si fin de course haut activé
      ouvert = true; // c'est ouvert
      clos = false; // c'est fermée
    }
  }

  if (!clos)
  {
    if (analogRead(analogInPin) < 100) // si la valeur lue est correspondante a la nuit
    {
      if (!tourne && ((millis() - chrono) > retard))fermeture();
    }
    else chrono = millis();

    if (sensorValuebas == LOW && analogRead(analogInPin) < 100) // si fin de course bas activé et (cellule <100 sinon empeche l'ouverture de la porte)
    {
      stop();
      ouvert = false;
      clos = true;
    }
  }
}