Projet de domotique pour la maison - Volet battant avec arduino

J'ai fait le choix de me lancer dans la construction de système de motorisation de mes volets battants à cause des motorisations actuelle qui tombent en panne les uns après les autres.

J'avais à l'origine opté pour des motorisations Voltec filaires fonctionnant en 230 V avec une commande local via des intérupteurs et une commande centrale de fermeture/ouverture de la marque Legrand fonctionnant en courant porteur.

Le problème est que le remplacement des moteurs de mes motorisations actuelles coûte la moitié d'un système neuf. Alors je me suis mis à la recherche d'un système fait maison et je suis tombé sur le site de Jacques mais visiblement son site est fermé.
Je l'ai contacté est on sait mit à la recherche un moto-réducteur à vitesse lente qui pourrait convenir. Après de longue recherche bien pénible, on a choisi Ce moto-réducteur (Réf: TS-42GZ495-1622 - 3 rpm - 12V).

J'ai choisi Aliexpress pour le prix et en plus il est possible de trouver le moteur et le réducteur séparément. Le lien vers Aliexpresse pour commander le motoréducteur change souvent et peut indiquer que le produit n'est plus disponible.
C'est possible aussi de le commander sur le site du fabriquand Tsinymotor où via leurs adresses de contact Contact du fabriquant.

En dessous les photos de l'ensemble de pièces modélisé avec Fusion 360, en cliquant dessus vous pouvez voir les différentes pièces en plus gros.

Des mises à jour sont encore en cours, je suis en cours de rédaction de la partie mécanique et suivra la partie électronique car je travaille encore dessus.
Pour la responsivité du site, c'est fonctionnel sur les smartphones mais reste encore à voir pour les tablettes.
A la base, j'avais prévu d’utiliser un bus de donné pour la communication entre carte mais je me suis orienté sur le wifi et Bluetooth.

cliquer pour agrandir — Mécanisme vue générale

Support moteur

* Fixation des supports moto-réducteurs:
1 - J'ai réalisé un guide de perçage pour emplacement des trous sur le mur (Support perçage mur pour support moto-réducteur). Il y a une fenêtre carrée qui indique le côté du volet et pour la partie haute je les positionnais à 1 cm du linteau.
2 - Pour le perçage, j'ai au préalable utilisé un foret à béton de 8 mm mais dans le cas d'enduit à gratté le trou est trop gros et la cheville tourne sur elle-même. Donc je conseille d’utiliser un foret à béton de 7 mm dans l'enduit puis de finir avec un tournevis de diamètre 8 mm et un marteau.
3 - Une fois les perçages réalisés, il faut utiliser trois chevilles de 8 x 40 mm et récupéré 3 vis penture de 7 x 30.
4 - C'est là que sa deviens compliqué, le visage est relativement compliqué sans utilisation de la clé à cliquer pour embouts avec manche rotatif. J'ai tenté d'autre solution mais rien trouvé de plus adapté. Pour le serrage, il faut utiliser la clé et un embout T30.
* Montage des moto-réducteurs :
1 - Pour la fixation des moteurs, peu de chose à faire. Il suffit de mettre le moto-réducteur en place et utiliser les vis M3 x 8 mm en inox A4 et une clé hexagonale de 2 mm.

Bras

Bouchon support moteur

Fixation sur volet

Clavette

Voici les deux cartes électronique pour le pilotage des deux moteurs, de la commande manuel et le bus I2c

Pour suivre le choix de l'alimentation
Pour suivre la mesure de courant et le codeur

1 - Affectation des boutons de commande

Pour débuter, il faut affecter les entrées numériques qui vont servir aux commandes via les boutons poussoir.
Enfin ces premières variables sont là surtout pour que ça soit plus claire dans le reste du code.
Alors on va donc connecter sur la pin 2 le bouton ouverture, sur la pin 3 le bouton fermeture et sur la pin 4 le bouton arrêt.


						
							1int ouverture = 2;
						
						
							2int fermeture = 3;
						
						
							3int arret = 4;

2 - Mémorisation de appuis sur les boutons

Dans cette section on va voir comment mémorisé état du bouton quand on appuis.
Ce qui faut savoir quand on appuis sur un bouton poussoir et que le signal arrive sur la carte Arduino.
Un phénomène de rebond ce produit est donc au lieu d'avoir l'information de appuis, on se retrouve avec plusieurs infos de 0 ou 1.
Ce qu'il faut c'est mémorisé l'état appuyer une fois que l'on obtient un 1. C'est ce que l'on voit dans le code suivant.
Pour une explication plus précise: La chaine de Eric Peronnin


						
							1 int etat_bt_ouverture = 0;
						
						
							2 int bt_ouverture_non_appuier = 0;
						
						
							3 int ouverture_demande = 0;
						
						
							4 
						
						
							5 int etat_bt_fermeture = 0;
						
						
							6 int bt_fermeture_non_appuier = 0;
						
						
							7 int fermeture_demande = 0;
						
						
							8 
						
						
							9 int etat_bt_arret = 0;
						
						
							10int bt_arret_non_appuier = 0;
						
						
							11int arret_demande = 0;

3 - Affectation des variables pour arrêt des moteurs

Les deux variables suivantes vous servir à stocker état du volet quand il sera en buté ouvert ou fermé.
La dernière variable indique la valeur de l'intensité d'arrêt des moteurs.
Cette valeur doit être adapter en fonction de vos volets mais aussi en cas de vent.


						
							1int arret_moteur_droit = 0;
						
						
							2int arret_moteur_gauche = 0;
						
						
							3int courant_arret = 1300;

4 - Affectation des variables pour le pilotage des moteurs

Le code suivant va affecter les entrées du module L298N sur les sorties numériques de la carte Arduino.
On va donc affevter in1 sur la pin 6, in2 sur la pin 7, in3 sur la pin 8 et in4 sur la pin 9.


						
							1int in1 = 6;
						
						
							2int in2 = 7;
						
						
							3int in3 = 8;
						
						
							4int in4 = 9;

5 - Affectation des pins et du type de entrée/sortie

La fonction setup() va servir pour la déclaration entrée et sortie physique utilisé de la carte Arduino.
Les trois première pinMode sont pour les boutons poussoir en entrée numérique avec l'activation de la résistance de Pullup interne.
Une résistance de Pullup interne sert à éviter de mettre une résistance physique sur le circuit imprimer.
Donc pour le commun des trois bouton poussoir sa sera à mettre à la masse (GND).
Pour plus explication sur Résistance de rappel («pull-up» ou «pull-down»).
Les quatre pinMode suivant sont pour le pilotage des moteurs avec des sorties numérique.
La dernière ligne sert seulement pour développement afin de voir dans le moniteur série du logiciel Arduino print et println.


						
							1 void setup();
						
						
							2 {
						
						
							3 pinMode(ouverture, INPUT_PULLUP);
						
						
							4 pinMode(fermeture, INPUT_PULLUP);
						
						
							5 pinMode(arret, INPUT_PULLUP);
						
						
							6 pinMode(in1, OUTPUT);
						
						
							7 pinMode(in2, OUTPUT);
						
						
							8 pinMode(in3, OUTPUT);
						
						
							9 pinMode(in4, OUTPUT);
						
						
							10Serial.begin(9600);
						
						
							11}

6 - Fonction qui gère la rotation des moteurs

La fonction pilot_moteur() va servir au pilotage des moteurs et de leurs sens de rotation et d'arrêt.
Sur ce point il faut faire attention à la construction du moteur et au branchement des moteurs sur la carte L298.
Donc je vous conseille de faire des tests avec une batterie 12V indépendante afin de déterminé c'est information.
Les quatre premières variables servent à état des interrupteurs pour la rotation des moteurs.
La dernière variable à indiquer si on veut ouvrir, fermé ou arrêté.


						
							1 int pilot_moteur(int v_in1, int v_in2, int v_in3, int v_in4, int etat);
						
						
							2 {
						
						
							3 // in1 et in2 pour le volet gauche
						
						
							4 // in3 et in4 pour le volet droit
						
						
							5 // etat => 1 ouverture / 2 fermeture / 0 arrêt
						
						
							6 if(etat == 1);
						
						
							7 {
						
						
							8 digitalWrite(in3, v_in3);
						
						
							9 digitalWrite(in4, v_in4);
						
						
							10delay(500);
						
						
							11digitalWrite(in1, v_in1);
						
						
							12digitalWrite(in2, v_in2);
						
						
							13}
						
						
							14else if(etat == 2);
						
						
							15{
						
						
							16digitalWrite(in1, v_in1);
						
						
							17digitalWrite(in2, v_in2);
						
						
							18delay(500);
						
						
							19digitalWrite(in3, v_in3);
						
						
							20digitalWrite(in4, v_in4);
						
						
							21}
						
						
							22else
						
						
							23{
						
						
							24digitalWrite(in1, v_in1);
						
						
							25digitalWrite(in2, v_in2);
						
						
							26digitalWrite(in3, v_in3);
						
						
							27digitalWrite(in4, v_in4);
						
						
							28}
						
						
							29}

7 - Fonction qui génre l'arrêt des moteurs sur détection de courant (mA)


						
							1 int arret_sur_courant(float analog_A0, float analog_A1);
						
						
							2 {
						
						
							3 float tension_A0 = (analog_A0 * 5000) / 1023;
						
						
							4 float courant_A0 = (tension_A0 - 2483) / 184;
						
						
							5 float courant_milliampere_A0 = abs(courant_A0 * 1000);
						
						
							6 
						
						
							7 float tension_A1 = (analog_A1 * 5000) / 1023;
						
						
							8 float courant_A1 = (tension_A1 - 2483) / 184;
						
						
							9 float courant_milliampere_A1 = abs(courant_A1 * 1000);
						
						
							10
						
						
							11if(courant_milliampere_A0 > courant_arret);
						
						
							12{
						
						
							13Serial.println("--------------------------------");
						
						
							14Serial.print("Le courant du moteur gauche est ");
						
						
							15Serial.print(courant_milliampere_A0);
						
						
							16Serial.print(" mA - ");
						
						
							17Serial.println(analog_A0);
						
						
							18Serial.println("--------------------------------");
						
						
							19digitalWrite(in1, LOW);
						
						
							20digitalWrite(in2, LOW);
						
						
							21arret_moteur_gauche = 1;
						
						
							22}
						
						
							23
						
						
							24if(courant_milliampere_A1 > courant_arret);
						
						
							25{
						
						
							26Serial.println("--------------------------------");
						
						
							27Serial.print("Le courant du moteur droit est ");
						
						
							28Serial.print(courant_milliampere_A1);
						
						
							29Serial.print(" mA - ");
						
						
							30Serial.println(analog_A1);
						
						
							31Serial.println("--------------------------------");
						
						
							32digitalWrite(in3, LOW);
						
						
							33digitalWrite(in4, LOW);
						
						
							34arret_moteur_droit = 1;
						
						
							35}
						
						
							36
						
						
							37if(arret_moteur_gauche == 1 && arret_moteur_droit == 1);
						
						
							38{
						
						
							39ouverture_demande = 0;
						
						
							40fermeture_demande = 0;
						
						
							41arret_moteur_gauche = 0;
						
						
							42arret_moteur_droit = 0;
						
						
							43}
						
						
							44}

8 - Fonction qui génre les boutons avec arrêt automatique


						
							1 void loop();
						
						
							2 {
						
						
							3 // Gestion du bouton ouverture
						
						
							4 etat_bt_ouverture = digitalRead(ouverture);
						
						
							5 if(etat_bt_ouverture != bt_ouverture_non_appuier)
						
						
							6 {
						
						
							7 if(etat_bt_ouverture == LOW && ouverture_demande == 0 && fermeture_demande == 0 && arret_demande == 0)
						
						
							8 {
						
						
							9 Serial.println("J'appuie sur le bouton ouverture");
						
						
							10ouverture_demande = 1;
						
						
							11pilot_moteur(LOW, HIGH, LOW, HIGH, 1);
						
						
							12}
						
						
							13delay(50);
						
						
							14}
						
						
							15bt_ouverture_non_appuier = etat_bt_ouverture;
						
						
							16
						

						
							17// Gestion du bouton fermeture
						
						
							18etat_bt_fermeture = digitalRead(fermeture);
						
						
							19if(etat_bt_fermeture != bt_fermeture_non_appuier)
						
						
							20{
						
						
							21if(etat_bt_fermeture == LOW && ouverture_demande == 0 && fermeture_demande == 0 && arret_demande == 0)
						
						
							22{
						
						
							23Serial.println("J'appuie sur le bouton fermeture");
						
						
							24fermeture_demande = 2;
						
						
							25pilot_moteur(HIGH, LOW, HIGH, LOW, 1);
						
						
							26}
						
						
							27delay(50);
						
						
							28}
						
						
							29bt_fermeture_non_appuier = etat_bt_fermeture;
						
						
							30
						

						
							31// Gestion du bouton arrêt
						
						
							32etat_bt_arret = digitalRead(arret);
						
						
							33if(etat_bt_arret != bt_arret_non_appuier)
						
						
							34{
						
						
							35if(etat_bt_arret == LOW && arret_demande == 0)
						
						
							36{
						
						
							37Serial.println("J'appuie sur le bouton arret");
						
						
							38arret_demande = 1;
						
						
							39ouverture_demande = 0;
						
						
							40fermeture_demande = 0;
						
						
							41pilot_moteur(LOW, LOW, LOW, LOW, 0);
						
						
							42delay(2000);
						
						
							43arret_demande = 0;
						
						
							44}
						
						
							45delay(50);
						
						
							46}
						
						
							47bt_arret_non_appuier = etat_bt_arret;
						
						
							48
						
						
							49arret_sur_courant(analogRead(0), analogRead(1));
						
						
							50}