PB programmation L293D + arduino

Bonjour,

Je suis en train de faire une porte de poulailler automatique sauf que j'aimerais supprimer le fin de course bas par une temporisation
plus précisément le programme que j'ai actuellement fonctionne avec 2 fins de course haut et bas quand l'un ou l'autre est actionné lors de la fermeture ou l'ouverture de la porte celui ci arrête le moteur.
Je souhaiterais enlever le fin de course bas et arrêté le moteur lorsque j'ouvre la porte avec une temporisation.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
int commande_haut = 4; // Déclaration broche Bouton fermeture
int commande_bas = 5; // Déclaration broche Bouton ouverture
int fin_de_course_haut = 6; // Capteur fin de course haut
int fin_de_course_bas = 7; /// Capteur fin de course bas
int MotorPin1 = 8;  // Déclaration broche IN1 L293D
int MotorPin2 = 9;  // Déclaration broche IN2 L293D
int MotorPin3 = 10; // Déclaration broche IN3 L293D
int MotorPin4 = 11; // Déclaration broche IN4 L293D
 
int LuminositePin = A0; // Déclaration broche LDR
int Luminosite = 0; // Variable de la luminosité
 
int Tour = 0;
int delayTime = 10; // Temps entre chaque pas 10ms
int Seuil_Jour = 350; // Variable de luminosité seuil pour le jour
int Seuil_Nuit = 50; // Variable de luminosité seuil pour la nuit
int Tempo_luminosite = 10000; // Temporisation luminosité 10 secondes = 10000ms
 
boolean porte_fermee = false; //Déclaration variable porte fermée
boolean porte_ouverte = false; //Déclaration variable porte ouverte
boolean fdch = false; // Déclaration variable Fin de Course Haut
boolean fdcb = false; // Déclaration variable Fin de Course Bas
boolean etat_bp_h = false, etat_bp_b = false; // Déclaration des variables bas et haut
boolean mem_h = false, mem_b = false, mem_fdch = false,  mem_fdcb = false; // Déclaration des mémoires
boolean mem_mouvement = false; // Déclaration de la mémoire mouvement
boolean mem_lumiere = false; // Déclaration de la mémoire lumière
boolean mem_init = false; // Déclaration de la mémoire initialisation
boolean Detecte_lumiere = false; // Déclaration variable détection lumière
boolean Jour = true; // Déclaration variable Jour = 1 | Nuit = 0
boolean Initialisation = false; // Déclaration variable initialisation
 
// État d'activation de la tempo
boolean tempoActive = false;
 
// Temps à l'activation de la tempo
unsigned long tempoDepart = 0;
 
void setup() {
  Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
  pinMode(commande_haut, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée BP haut
  pinMode(commande_bas, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée BP bas
  pinMode(fin_de_course_haut, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée Fin de course haut
  pinMode(fin_de_course_bas, INPUT_PULLUP); // Déclaration entrée pull-up sur entrée Fin de course bas
  pinMode(MotorPin1, OUTPUT); // Déclaration de la sortie A- Moteur
  pinMode(MotorPin2, OUTPUT); // Déclaration de la sortie A+ Moteur
  pinMode(MotorPin3, OUTPUT); // Déclaration de la sortie B- Moteur
  pinMode(MotorPin4, OUTPUT); // Déclaration de la sortie B+ Moteur
 
  Lance_initialisation();
}
 
 
void Lance_initialisation() {
  Fermer_porte_Initialisation();
}
 
 
void loop() {
  Luminosite = analogRead(LuminositePin);
  if (Initialisation) {
Serial.println(Luminosite); // Affichage sur le moniteur série du texte
    if (Luminosite >= Seuil_Jour)
    {
      Detecte_lumiere = true;
    }
    if (Luminosite <= Seuil_Nuit)
    {
      Detecte_lumiere = false;
     }
    if (Detecte_lumiere != mem_lumiere) {
      tempoActive = true;
      tempoDepart = millis();
      Serial.println("La lumière lance tempo"); // Affichage sur le moniteur série du texte
    }
    if (Detecte_lumiere && tempoActive && ((millis() - tempoDepart) >= Tempo_luminosite))
    {
      Jour = true;
      Serial.println("Il fait jour"); // Affichage sur le moniteur série du texte
      tempoActive = false;
      if (!fdcb  && !porte_ouverte) {
        Ouvrir_porte();
      }
    }
    mem_lumiere = Detecte_lumiere;
 
    if (!Detecte_lumiere && tempoActive && (millis() - tempoDepart) >= Tempo_luminosite)
    {
      Jour = false;
      Serial.println("Il fait nuit"); // Affichage sur le moniteur série du texte
      tempoActive = false;
      if (!fdch  && !porte_fermee){
      Fermer_porte();
    }}
    mem_lumiere = Detecte_lumiere;
  }
 
  etat_bp_h = !digitalRead(commande_haut); // Inverse de la lecture sur entrée BP haut
  etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
  fdch = !digitalRead(fin_de_course_haut); // Inverse de la lecture sur entrée Fin de course haut
  fdcb = !digitalRead(fin_de_course_bas); // Inverse de la lecture sur entrée Fin de course bas
 
  if (fdch != mem_fdch) // Changement d'état du fin de course haut (front montant ou descendant)
  {
    if (fdch) 
    {
      Serial.println("Porte fermée !"); // Affichage sur le moniteur série du texte
    }
    if (!fdch)
    {
      Serial.println("Porte non fermée"); // Affichage sur le moniteur série du texte
    }
  }
  if (fdcb != mem_fdcb) // Changement d'état du fin de course bas (front montant ou descendant)
  {
    if (fdcb) 
    {
      Serial.println("Porte ouverte !"); // Affichage sur le moniteur série du texte
    }
    if (!fdcb)
    {
      Serial.println("Porte non ouverte"); // Affichage sur le moniteur série du texte
    }
  }
  mem_fdcb = fdcb; // Mémorisation du nouvel état du fin de course bas
 
  if (etat_bp_h != mem_h) // Changement d'état du bouton poussoir haut (front montant ou descendant)
  {
    Serial.println("Appui BP Haut"); // Affichage sur le moniteur série du texte
    if (etat_bp_h && !etat_bp_b && !fdch && !porte_fermee) // Appui sur BP haut mais pas sur le bas
    {
      Fermer_porte(); // Lancer la fonction sens normal
    }
  }
  mem_h = etat_bp_h; // Mémorisation du nouvel état du bouton haut
  if (etat_bp_b != mem_b) // Changement d'état du bouton poussoir bas (front montant ou descendant)
  {
    if (etat_bp_b && !etat_bp_h && !fdcb && !porte_ouverte) // Appui sur BP bas mais pas sur le haut
    {
        Ouvrir_porte();
    }
  }
  mem_b = etat_bp_b; // Mémorisation du nouvel état du bouton bas
}
 
 
void Fermer_porte_Initialisation() {
      delay(5000);
  while (!fdch) {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);
      Serial.println("Fermer porte"); // Affichage sur le moniteur série du texte
      fdch = !digitalRead(fin_de_course_haut);
      etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
      if (fdch)
      {
        Serial.println("Porte en haut"); // Affichage sur le moniteur série du texte
        Arret();
        porte_fermee = true;
        porte_ouverte = false;
        Initialisation = true;
        break;
      }
  }
}
 
void Fermer_porte() {
  while (!fdch) {
      digitalWrite(MotorPin1, HIGH);
      digitalWrite(MotorPin2, LOW);
      digitalWrite(MotorPin3, HIGH);
      digitalWrite(MotorPin4, LOW);
      delay(delayTime);
      Serial.println("Fermer porte"); // Affichage sur le moniteur série du texte
 
      fdch = !digitalRead(fin_de_course_haut);
      etat_bp_b = !digitalRead(commande_bas); // Inverse de la lecture sur entrée BP bas
      if (fdch || etat_bp_b)
      {
        porte_fermee = true;
        porte_ouverte = false;
        Serial.println("Porte en haut"); // Affichage sur le moniteur série du texte
        Arret();
        break;
      }
  }
}
 
void Ouvrir_porte() {
  while (!fdcb) {
    digitalWrite(MotorPin1, LOW);
    digitalWrite(MotorPin2, HIGH);
    digitalWrite(MotorPin3, LOW);
    digitalWrite(MotorPin4, HIGH);
    delay(delaytime);
    Serial.println("Ouvrir porte"); // Affichage sur le moniteur série du texte
 
   fdcb = !digitalRead(fin_de_course_bas);
   etat_bp_h = !digitalRead(commande_haut); // Inverse de la lecture sur entrée BP haut
      if (fdcb || etat_bp_h)
      {
        porte_fermee = false;
        porte_ouverte = true;
        Serial.println("Porte en bas"); // Affichage sur le moniteur série du texte
        Arret();
        break;
      }
  }
}
 
 
void Arret() {
  digitalWrite(MotorPin1, LOW);
  digitalWrite(MotorPin2, LOW);
  digitalWrite(MotorPin3, LOW);
  digitalWrite(MotorPin4, LOW);
  tempoActive = 0;
}

Si vous pouvez garantir que vous partirez toujours du fin de course d’en haut et que votre porte fonctionnera toujours de la même façon (votre moteur tourne toujours pareil et la porte ne bloque pas) alors c’est envisageable. Vous déclarez alors combien de ms sont nécessaires pour fermer la porte

Code:

const unsigned long dureeDeFermeture = 40000ul; // 40 secondes

Vous notez l’heure de départ de la commande de fermeture et le fait que vous êtes en train de fermer (quand la porte touche le fin de course du haut et le moteur démarre)
Code:

1 2 unsigned long tempsDebut = millis(); bool enTrainDeFermer = true;
Vous remplacez dans le code l’attente du fin de course du bas par un test sur le temps écoulé
Code:

1 2 3 4 5 if (enTrainDeFermer && (millis() - tempsDebut > dureeDeFermeture)) { // on est en bas .... arrêter le moteur enTrainDeFermer = false; // noter que c’est bon, la fermeture est effectuée. }
PS: le code que vous avez n’est pas très propre, vous l’avez récupéré sur internet? Il y a peut être des trucs plus adaptés (par exemple ici - très Bonne série d’articles sur le sujet).

Modif

Effectivement je vais garder mon fin de course bas, car le moteur aura des variations de puissance et cela ne sera pas juste a tout les coups.
J'aimerais mettre un fin de course NC, alors que le programme actuel et fait pour un FDC NO, et je ne vois pas comment faire dans le programme ?!

J'aimerais savoir aussi si il est possible de rajouter un mode veille sur l'arduino Uno pour que cela consomme le moins possible ?!

Merci.

tout cela est possible

pour le NC au lieu du NO ça ne joue que sur la valeur lue (HIGH ou LOW) par défaut

dans votre code vous faites

Code:

fdcb = !digitalRead(fin_de_course_bas); // Inverse de la lecture sur entrée Fin de course bas

si vous inversez l'état, il suffit de retirer le ! pour que la logique appliquée ensuite sur la variable fdcb soit aussi inversée

pour le mode sleep, il faut bosser un peu plus... étudier le deep sleep des Arduinos, décider ce qui doit réveiller votre Arduino, gérer les interruptions etc... faudrait vous faire la main en lisant et pratiquant sur des petits tutos spécifiques ce qui est mentionné dans le lien que j'ai partagé - cf la partie 1.5. La consommation

Dans le lien que j'ai partagé l'option retenue est un petit panneau solaire, ça semble le plus simple parce que même si vous faites du deep sleep, le moteur lui va consommer pas mal lors des mouvements et il faudra bien trouver un moyen de recharger...

Merci pour ton aide précieuse, effectivement je ne fait que débuter je viens de recevoir mon 1er arduino et itinitiation au langage C.

je vais opter pour un panneau solaire équipé d'un chargeur.
Dure dure mais avec différent essais j'y suis arriver. ci joint les modif, je ne suis pas sure que cela soit très propre mais cela fonctionne.

Code:

boolean fdcb = true; // Déclaration variable Fin de Course Bas

Code:

fdcb = digitalRead(fin_de_course_bas); // Inverse de la lecture sur entrée Fin de course bas
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void Ouvrir_porte() { while (!fdcb) { digitalWrite(MotorPin1, LOW); digitalWrite(MotorPin2, HIGH); digitalWrite(MotorPin3, LOW); digitalWrite(MotorPin4, HIGH); Serial.println("Ouvrir porte"); // Affichage sur le moniteur série du texte fdcb = digitalRead(fin_de_course_bas); etat_bp_h = !digitalRead(commande_haut); // Inverse de la lecture sur entrée BP haut if (fdcb || etat_bp_h) { porte_fermee = false; porte_ouverte = true; Serial.println("Porte en bas"); // Affichage sur le moniteur série du texte Arret(); break; } } }

bravo

profitez en pour modifiez le commentaire qui ne sert plus à rien

Code:

fdcb = digitalRead(fin_de_course_bas); // Inverse de la lecture sur entrée Fin de course bas

Merci. pour infos j'ai fait exactement fait sur le lien ci dessous avec quelques modifs comme utilisé un moteur dc au lieu du pas a pas.

https://electrotoile.eu/fabrication-...ue-arduino.php