Bonjour
Je suis sur une réalisation d'un automatisme de volets battants.
La partie mécanique fonctionne en manuel.
Elle se compose de 2 bras commandés par 2 motoréducteurs 12v.
Je désire piloter le système via Wifi et Smart home ou Tuya.
Pour réaliser la partie électrique et électronique, j'ai utilisé le logiciel Proteus 8.
Pour l'instant j'ai réussi à écrire un code qui fonctionne en virtuel sous VSM Proteus.
j'ai 4 commandes par bouton poussoir:
- Ouverture
- Fermeture
- Stop
- Ouverture partielle (en "Tuile")
La détection de fin de course se fait par le biais des sorties SENSA et SENSB du L298n et shunt .
la simulation fonctionne parfaitement sauf pour la fonction "Tuile":
Pour cette fonction mise en "tuile" je veux: (lignes 118 à 129 du code)
1 - faire un stop.
2 - fermer complètement (jusqu'à butée; des fois que les volets ne soient pas totalement fermés .
3 - ouvrir pendant 3 secondes (qui correspond à l'ouverture voulue avec mon système.
4 - stopper les moteurs.
Pour l'instant la rotation en fermeture du point 1 ne dure que environ 1/2 seconde avant de passer en ouverture au lieu d'attendre la détection de buttée des moteurs.
Quelqu'un a-t'il une idée du bug
cordialement
Alain
ci dessous le code complet de mon système
/*****************************************************************************************************************/
/* INITIALISATION DES BROCHES*/
// Association des entrées du L298N, aux sorties utilisées sur notre Arduino Uno //
#define borneENA 12 // On associe la borne "ENA" du L298N à la pin D10 de l'arduino
#define borneENB 13 // On associe la borne "ENB" du L298N à la pin D5 de l'arduino
#define borneIN1 8 // On associe la borne "IN1" du L298N à la pin D9 de l'arduino
#define borneIN2 7 // On associe la borne "IN2" du L298N à la pin D8 de l'arduino
#define borneIN3 6 // On associe la borne "IN3" du L298N à la pin D7 de l'arduino
#define borneIN4 5 // On associe la borne "IN4" du L298N à la pin D6 de l'ard
//Affectation des boutons de commande
int bp_ouverture = 2;
int bp_fermeture = 3;
int bp_arret = 4;
int bp_tuile = A2;
//Affectation des led pour la maquette de developpement
int led_ouv = 9 ;
int led_fer = 10 ;
int led_stop = 11;
int led_tuile = A3;
//Traitement des valeurs de sortie SENS_A et SENS_B du L298N sur-intensité en butée de chaque volet
// deux variables stockeront la valeur lue sur les broches analogiques
float val_A0 = 0;
float val_A1 = 0;
//deux variables stockeront la valeur des conversions des précédentes valeurs en tension
float U_A0 = 0;
float U_A1 = 0;
//******************************************************************************************************************************//
// SETUP //
//*******//
void setup()
//3 première pinMode pour les boutons poussoir en entrée numérique et activation de la résistance de Pullup interne.
//avec le Pullup interne pour éviter de mettre une résistance sur le circuit imprime
{
pinMode(bp_ouverture, INPUT_PULLUP);
pinMode(bp_fermeture, INPUT_PULLUP);
pinMode(bp_arret, INPUT_PULLUP);
pinMode(bp_tuile, INPUT_PULLUP);
// Configuration des pins de l'Arduino en "sortie" (elles attaquent les entrées du module L298N)
pinMode(borneENA, OUTPUT);
pinMode(borneENB, OUTPUT);
pinMode(borneIN1, OUTPUT);
pinMode(borneIN2, OUTPUT);
pinMode(borneIN3, OUTPUT);
pinMode(borneIN4, OUTPUT);
// Configuration des pins vers les led
pinMode (led_ouv, OUTPUT);
pinMode (led_fer, OUTPUT);
pinMode (led_stop, OUTPUT);
pinMode (led_tuile, OUTPUT);
//cette ligne sert seulement pour développement afin de visualiser avec les moniteurs connectés Arduino print et println//
// sur les sorties tx et rx / 0 et 1 //
Serial.begin(9600);
}
//******************************************************************************************************************************//
// Boucle principale : LOOP qui appèle les sous fonctions //
void loop()
{
// lecture de la valeur d'intensité moteur Droit
val_A0 = analogRead(A0);
// conversion en tension de la valeur lue
U_A0 = (val_A0 * 5.0) / 1024;
// lecture de la valeur d'intensité moteur gauche
val_A1 = analogRead(A1);
// conversion en tension de la valeur lue
U_A1 = (val_A1 * 5.0) / 1024;
if (U_A0 >2) // arret moteur 1 si surintensité
{
stop_A();
}
else if (U_A1 >2) // arret moteur 2 si surintensité
{
stop_B();
Serial.println("fin de course b");
}
// ouverture volets
if (digitalRead (bp_ouverture) == LOW)
{
stop();
digitalWrite(led_ouv, HIGH);
delay(500);
ouverture1(); //appel fonction ouverture
}
// fermeture volets
else if
(digitalRead (bp_fermeture) == LOW)
{
stop();
digitalWrite(led_fer, HIGH);
delay(500);
fermeture1(); //appel fonction fermeture
}
// arret total des volets dans leur position actuelle
else if
(digitalRead (bp_arret) == LOW)
{
stop();
delay(500);
digitalWrite(led_stop, HIGH);
delay(500);
stop();
Serial.println("arret total");
}
// Mise en tuile des volets avec fermeture complete préalable (des fois quils soient ouverts ou deja en tuile)
else if (digitalRead (bp_tuile) == LOW)
{
stop();
delay(500);
digitalWrite(led_tuile, HIGH);
{
fermeture1 ();
delay(500);
ouverture1 ();
delay(3000); //Temps de mise en tuile, determine le degre d'ouverture (ici 3 secondes)
stop();
Serial.println("arret total");
}
}
else
{digitalWrite(led_ouv, LOW);
}
{digitalWrite(led_fer, LOW);
}
{digitalWrite(led_stop, LOW);
}
{digitalWrite(led_tuile, LOW);
}
}
//****************************************************************************************************************************//
// Sous-Fonctions : ouverture1, fermeture1 ,stopA, stopB, stop total et lecture surintensité ()
//*****************************************************************************************************************************//
void ouverture1() {
// Configuration du L298N en "ouverture", pour les moteurs. Selon sa table de vérité, il faut que :
digitalWrite(borneIN1, HIGH); // L'entrée IN1 doit être au niveau haut
digitalWrite(borneIN2, LOW); // L'entrée IN2 doit être au niveau bas
digitalWrite(borneIN3, HIGH); // L'entrée IN3 doit être au niveau haut
digitalWrite(borneIN4, LOW); // L'entrée IN4 doit être au niveau bas
digitalWrite(borneENA, HIGH); // Active l'alimentation du moteur 1
delay(500); // attend 0.5 secondes pour decaler les battants
digitalWrite(borneENB, HIGH); // Active l'alimentation du moteur 2
Serial.println("ouverture");
}
void fermeture1()
// Configuration du L298N en "Fermeture", pour les moteurs. Selon sa table de vérité, il faut que :
{
digitalWrite(borneIN1, LOW); // L'entrée IN1 doit être au niveau bas
digitalWrite(borneIN2, HIGH); // L'entrée IN2 doit être au niveau haut
digitalWrite(borneIN3, LOW); // L'entrée IN3 doit être au niveau bas
digitalWrite(borneIN4, HIGH); // L'entrée IN4 doit être au niveau haut
digitalWrite(borneENB, HIGH); // Active l'alimentation du moteur 1
delay(500); // attend 0.5 secondes pour decaler les battants
digitalWrite(borneENA, HIGH); // Active l'alimentation du moteur 2
Serial.println("fermeture");
}
// Configuration du L298N stop, pour arreter les moteurs. Selon sa table de vérité, il faut que :
void stop ()
{
digitalWrite(borneIN1, LOW); // L'entrée IN1 au niveau bas
digitalWrite(borneIN2, LOW); // L'entrée IN2 au niveau bas
digitalWrite(borneIN3, LOW); // L'entrée IN3 au niveau bas
digitalWrite(borneIN4, LOW); // L'entrée IN4 au niveau bas
digitalWrite(borneENA, LOW); // desactive l'alimentation du moteur 1
digitalWrite(borneENB, LOW); // desactive l'alimentation du moteur 2
}
// Configuration du L298N , pour arreter le moteurs 1 . Selon sa table de vérité, il faut que :
void stop_A ()
{
digitalWrite(borneENA, LOW); // desactive l'alimentation du moteur 1
digitalWrite(borneIN1, LOW); // L'entrée IN1 au niveau bas
digitalWrite(borneIN2, LOW); // L'entrée IN2 au niveau bas
Serial.println("fin de course A");
delay(1000);
stop();
}
// Configuration du L298N , pour arreter le moteurs 2 . Selon sa table de vérité, il faut que :
void stop_B ()
{
digitalWrite(borneENB, LOW); // desactive l'alimentation du moteur 2
digitalWrite(borneIN3, LOW); // L'entrée IN3 au niveau bas
digitalWrite(borneIN4, LOW); // L'entrée IN4 au niveau bas
Serial.println("fin de course B");
delay(1000);
stop();
}
/* Lecture de la valeur d'intensité des moteur Droit et gauche sur les sorties SENSE du L298N
sur 2 Shunts de 0.5 Ohm limitées par une zenzr dz 4.7volt et une resistance de 10k */
void intens()
{
val_A0 = analogRead(A0); // lecture de la valeur d'intensité moteur Droit
// conversion en tension de la valeur lue
U_A0 = (val_A0 * 5.0) / 1024;
// lecture de la valeur d'intensité moteur gauche
val_A1 = analogRead(A1);
// conversion en tension de la valeur lue
U_A1 = (val_A1 * 5.0) / 1024;
if (U_A0 >2) // arret moteur 1 si surintensité > à 2 Amp
{
stop_A();
Serial.println("fin de course B");
}
else if (U_A1 >2) // arret moteur 2 si surintensité > à 2 Amp
{
stop_B();
Serial.println("fin de course A");
}
}
