Pilotage volet roulant 24V

Bonjour,

Après un premier post dans la mauvaise rubrique, j'ai été jeter un oeil aux règles du forum, désolé pour le mauvais emplacement la première fois...

Voici donc ma problématique

Je possède deux fenêtres de toit avec des volets roulants fonctionnant en 24Vdc, la montée ou la descente s'effectue par inversion de polarité. Je souhaiterais piloter ces volets à l'aide d'un bouton poussoir mural double (ouverture/fermeture). Le fabricant propose uniquement un boîtier un peu onéreux fonctionnant avec une commande à pile pour piloter ses volets, or je voudrais vraiment passer par mon bouton mural classique.

Je pense que ça doit être faisable avec un Arduino et 2 relais, le soucis est que mes connaissances en Arduino sont très limitées, ça fait bien longtemps que je n'ai pas fais joujoux avec la carte, et surtout je manque de temps pour m'en occuper, étant en pleine restauration de ma maison... Pour la partie câblage cela ne devrait pas me poser de soucis. Pour l'inversion de polarité, je brancherait mes relais et volets comme sur l'image ci-dessous :

Ma question est donc la suivante, y a t'il une âme charitable qui pourrait m'écrire un petit bout de programme pour gérer mes volets?? Si personne n'est motivé, je comprendrais.

Si quelqu'un est partant, voici le fonctionnement qu'il me faudrait :

Appui bref sur le bouton ouverture ou fermeture, j'active le relais 1 ou le relais 2 pendant 30 secondes (temps de course complète du volet). Si nouvel appui sur un bouton durant ces 30 secondes, arrêt du relais alimenté. Si appui sur un bouton supérieur à 2 secondes, le relais n'est activé que durant le temps d'appui.

Je possède 2 volets, il y aurait donc 2 boutons doubles et 4 relais.

Merci d'avance pour votre aide

je ne suis pas sûr que vos "boutons doubles" soient adaptés:

sur mon boitier fenêtre de toits (j'ai celui du fabriquant - Vélux pour ne pas les nommer) il y a un bouton 3 positions associé

  • je le mets en haut, ça ouvre
  • je le mets au milieu, ça arrête
  • je le mets en bas, ça ferme

mais le boitier doit détecter quand le volet "force" (en bout de course ouverture ou fermeture ou s'il y a un obstacle) pour couper le moteur, même si le bouton est "en bas"

--> il ne faut pas que les relais, mais aussi regarder la consommation de courant / trouver un moyen de savoir quand ça bloque et intégrer cela dans votre électronique + boucle de contrôle

J-M-L:
je ne suis pas sûr que vos “boutons doubles” soient adaptés:

sur mon boitier fenêtre de toits (j’ai celui du fabriquant - Vélux pour ne pas les nommer) il y a un bouton 3 positions associé

  • je le mets en haut, ça ouvre
  • je le mets au milieu, ça arrête
  • je le mets en bas, ça ferme

mais le boitier doit détecter quand le volet “force” (en bout de course ouverture ou fermeture ou s’il y a un obstacle) pour couper le moteur, même si le bouton est “en bas”

→ il ne faut pas que les relais, mais aussi regarder la consommation de courant / trouver un moyen de savoir quand ça bloque et intégrer cela dans votre électronique + boucle de contrôle

Merci pour votre réponse.

J’ai également les volets du fabricant Velux. Je pense qu’un capteur fin de course est intégré au mécanisme du volet car lorsque j’alimente en direct le moteur, celui ci s’arrête une fois fermé ou ouvert, on entend bien le ronronnement du moteur s’arrêter.
Je pense donc que la solution avec les relais devraient suffire puisque les fins de course semblent intégrés

Ok c’ets sans doute pas fin de course d’un point de vue en haut ou en bas (chez moi si j’entrouvre la fenêtre le volet roulant n’étant pas solidaire mais fixé sur le toit, il ne pourra descendre que jusqu’à un certain point — donc il doit détecter cela mais c’est effectivement possible que ce soit au niveau du moteur et pas de la commande

Pourquoi vous embêter alors avec plusieurs boutons et un arduino ? Un bouton 3 positions (pas momentané) devrait suffire

the_darkprince: Merci pour votre réponse.

J'ai également les volets du fabricant Velux. Je pense qu'un capteur fin de course est intégré au mécanisme du volet car lorsque j'alimente en direct le moteur, celui ci s'arrête une fois fermé ou ouvert, on entend bien le ronronnement du moteur s'arrêter. Je pense donc que la solution avec les relais devraient suffire puisque les fins de course semblent intégrés

Bonsoir en appliquant directement aux bornes du moteur CC un +/- 24V ou en appliquant le 24V +/- sur la connexion qui va vers l'ensemble volet moteur ?

Artouste: Bonsoir en appliquant directement aux bornes du moteur CC un +/- 24V ou en appliquant le 24V +/- sur la connexion qui va vers l'ensemble volet moteur ?

Oui, c'est ça.

J-M-L: Ok c’ets sans doute pas fin de course d’un point de vue en haut ou en bas (chez moi si j’entrouvre la fenêtre le volet roulant n’étant pas solidaire mais fixé sur le toit, il ne pourra descendre que jusqu’à un certain point — donc il doit détecter cela mais c’est effectivement possible que ce soit au niveau du moteur et pas de la commande

Pourquoi vous embêter alors avec plusieurs boutons et un arduino ? Un bouton 3 positions (pas momentané) devrait suffire

Les boutons 3 positions à accrochage ne fonctionnent pas, ils ne permettent pas d'inverser la polarité aux bornes du moteur, il y a seulement un commun et un contact montée et un autre descente malheureusement

Je me permets de revenir vers vous car à ce jour je n'ai toujours pas résolu mon problème. J'ai bien tenté de me replonger un peu dans la programmation de mon Arduino, mais il faudrait que je reprenne toutes les bases et je n'ai malheureusement pas le temps en ce moment... Quelqu'un aurait un petit moment pour se pencher sur un bout de programme ? Je suis prêt à payer un petit quelque chose en remerciement ou envoyer une bouteille d'épine maison :D

J'ai un peu potassé le programme, j'ai légèrement modifié la manière dont ça doit fonctionner, voilà ce que ça donne:

Je souhaiterais donc créer un programme qui fonctionne de la manière suivante:

Je possède 2 volets roulants.

Je possède deux bouton poussoir double montée, descente (BP_M1 : Bouton montée volet 1, BP_D1 bouton descente volet 1, BP_M2 : bouton montée volet 2, BP_D2 : bouton descente volet 2)

Pour inverser la polarité aux bornes des moteurs, j'utiliserai des relais, 1 par bouton poussoir, donc 4 relais (relay_M1 : relais montée volet 1, relay_D1 relais descente volet 1, relay_M2 : relais montée volet 2, relay_D2 : relais descente volet 2)

lorsque j'appuie sur un bouton, je souhaite actionner le relais correspondant durant 30 secondes (temps de course complet du volet)

Je souhaite que si le volet est déjà en mouvement, un appui sur un bouton stop le volet.

voilà ce que j'ai fais pour le moment comme programme, mais ça ne semble pas fonctionner, est-ce que je suis sur la bonne voie ou bien ai-je tout faux??

const int relay_M1 = 2;  //relais montée volet 1
const int relay_D1 = 3;  //relais descente volet 1
const int relay_M2 = 4;  //relais montée volet 2
const int relay_D2 = 5;  //relais descente volet 2
const int BP_M1 = 6;     //bouton montée volet 1
const int BP_D1 = 7;     //bouton descente volet 1
const int BP_M2 = 8;     //bouton montée volet 2
const int BP_D2 = 9;     //bouton descente volet 2
int etatBP_M1;
int etatBP_D1;
int etatBP_M2;
int etatBP_D2;
unsigned long temps;


void setup()
{
  pinMode(relay_M1, OUTPUT);
  pinMode(relay_D1, OUTPUT);
  pinMode(relay_M2, OUTPUT);
  pinMode(relay_D2, OUTPUT);
  pinMode(BP_M1, INPUT_PULLUP);
  pinMode(BP_D1, INPUT_PULLUP);
  pinMode(BP_M2, INPUT_PULLUP);
  pinMode(BP_D2, INPUT_PULLUP);
  etatBP_M1 = HIGH;
  etatBP_D1 = HIGH;
  etatBP_M2 = HIGH;
  etatBP_D2 = HIGH;
  temps = millis();

  
}

void loop()
{
  
 //BP_M1 relay_M1

  etatBP_M1 = digitalRead(BP_M1);
       if (etatBP_M1 == LOW )
       {
        temps = millis(); // on demarre le comptage
        digitalWrite(relay_M1,HIGH); // on active la sortie
       }       
      if (millis()-temps >= 30000) // on active le relay_M1 pendant 30 secondes
      {
           digitalWrite(relay_M1,LOW); //on éteint le relay_M1      
       }  


//BP_D1 relay_D1
       if ( digitalRead(BP_D1) == LOW )
       {
        temps = millis(); // on demarre le comptage
        digitalWrite(relay_D1,HIGH); // on active la sortie
       }       
      if (millis()-temps >= 30000) // on active le relay_D1 pendant 30 secondes
      {
           digitalWrite(relay_D1,LOW); //on éteint le relay_D1       
       } 


//BP_M2 relay_D2
       if ( digitalRead(BP_M2) == LOW )
       {
        temps = millis(); // on demarre le comptage
        digitalWrite(relay_M2,HIGH); // on active la sortie
       }       
      if (millis()-temps >= 30000) // on active le relay_M2 pendant 30 secondes
      {
           digitalWrite(relay_M2,LOW); //on éteint le relay_M2       
       } 


//BP_D2 relay_D2
       if ( digitalRead(BP_D2) == LOW )
       {
        temps = millis(); // on demarre le comptage
        digitalWrite(relay_D2,HIGH); // on active la sortie
       }       
      if (millis()-temps >= 30000) // on active le relay_D2 pendant 30 secondes
      {
           digitalWrite(relay_D2,LOW); //on éteint le relay_D2       
       } 


//appui sur BP_M1 ou BP_D1 pendant que le relay_M1 ou le relay_D1 est activé = relay_M1 et relay_D1 retombent à 0

       if ((BP_M1 == LOW || BP_D1 == LOW && relay_M1 == HIGH || relay_D1 == HIGH));
       {
        digitalWrite(relay_M1,LOW);
        digitalWrite(relay_D1,LOW);
       }

//appui sur BP_M2 ou BP_D2 pendant que le relay_M2 ou le relay_D2 est activé = relay_M2 et relay_D2 retombent à 0

       if ((BP_M2 == LOW || BP_D2 == LOW && relay_M2 == HIGH || relay_D2 == HIGH));
       {
        digitalWrite(relay_M2,LOW);
        digitalWrite(relay_D2,LOW);
       }
}

Merci d'avance pour votre aide !! :grin:

Pourquoi ne pas continuer dans l'autre post?

vous mélangez les temps dans votre code et vous confondez des N° de pin avec l'état de la pin dans
if ((BP_M1 == LOW || BP_D1 == LOW && relay_M1 == HIGH || relay_D1 == HIGH));(et il ya un point virgule assassin à la fin de cette ligne...). Le mieux c'est de mettre le mot PIN dans le nom de la constante qui porte un N° de pin, genre const byte relay_M1_PIN = 2;  // pin de contrôle du relais montée volet 1

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement) et pour simplifier votre gestion des boutons (en supposant qu'ils sont momentanés ?), éventuellement utilisez la librairie de @bricoleau

La machine à état pourrait simplement ressembler à cela (deux fois, car les volets sont indépendants)
machine.png
J'ai rajouté ici le fait que si vous appuyez sur le bouton descendre alors que le volet est en train de monter, ça inverse la course directement (idem dans l'autre sens)

J'ai tapé cela ici, donc pas sûr que ça fonctionne ni même ne compile, mais ça ressemblerait alors à cela pour un seul volet:

const byte relay_M1_PIN = 2;  // pin de contrôle du relais montée volet 1
const byte relay_D1_PIN = 3;  // pin de contrôle du relais descente volet 1
const byte BP_M1_PIN = 6;     // pin de contrôle du bouton montée volet 1
const byte BP_D1_PIN = 7;     // pin de contrôle du bouton descente volet 1

#include <simpleBouton.h> // http://forum.arduino.cc/index.php?topic=375232.0
simpleBouton BP_M1(BP_M1_PIN);   //Cablage : pin---BP---GND
simpleBouton BP_D1(BP_D1_PIN);   //Cablage : pin---BP---GND

unsigned long chronoVolet1;
const unsigned long trenteSecondes = 30000UL;

enum : byte {REPOS, MONTE, DESCEND} etatVolet1;

void actualiserBoutons()
{
  BP_M1.actualiser();
  BP_D1.actualiser();
}

void reposVolet1()
{
  digitalWrite(relay_M1_PIN, LOW); //on éteint le relay_M1
  digitalWrite(relay_D1_PIN, LOW); //on éteint le relay_D1
  etatVolet1 = REPOS;
}

void monteVolet1()
{
  digitalWrite(relay_D1_PIN, LOW);
  delay(50); // pour s'assurer que les 2 relais ne sont pas actifs en même temps 
  digitalWrite(relay_M1_PIN, HIGH);
  chronoVolet1 = millis();
  etatVolet1 = MONTE;
}

void descendVolet1()
{
  digitalWrite(relay_M1_PIN, LOW);
  delay(50); // pour s'assurer que les 2 relais ne sont pas actifs en même temps 
  digitalWrite(relay_D1_PIN, HIGH);
  chronoVolet1 = millis();
  etatVolet1 = DESCEND;
}

void actualiserVolet1()
{
  switch (etatVolet1) {
    case REPOS: // 2 évènements possibles bouton Monter ou Descendre
      if (BP_M1.vientDEtreEnfonce()) monteVolet1();
      else if (BP_D1.vientDEtreEnfonce()) descendVolet1();
      break;

    case MONTE:// 3 évènements possibles bouton Monter ou Descendre ou timeOut
      if (millis() - chronoVolet1 >= trenteSecondes) reposVolet1();
      else if (BP_M1.vientDEtreEnfonce()) reposVolet1();
      else if (BP_D1.vientDEtreEnfonce()) descendVolet1();
      break;

    case DESCEND:// 3 évènements possibles bouton Monter ou Descendre ou timeOut
      if (millis() - chronoVolet1 >= trenteSecondes) reposVolet1();
      else if (BP_M1.vientDEtreEnfonce()) monteVolet1();
      else if (BP_D1.vientDEtreEnfonce()) reposVolet1();
      break;
  }
}

void setup()
{
  Serial.begin(115200);
  pinMode(relay_M1, OUTPUT);
  pinMode(relay_D1, OUTPUT);
  reposVolet1();
  actualiserBoutons();
}

void loop()
{
  actualiserBoutons();
  actualiserVolet1();
}

Pour généraliser à plusieurs volets, le mieux serait de ne pas dupliquer le code mais de mettre des tableaux et utiliser un indice du tableau pour les fonctions (ou d'encapsuler cela dans une classe)

machine.png

Merci beaucoup pour ta réponse J-M-L,
Je vais prendre le temps de bien décortiquer ton code pour essayer de bien tout saisir, ça dépasse largement tout ce que j’ai pu coder jusqu’à présent…
Je reviens vers toi pour te dire si ça fonctionne et si j’ai besoin d’éclaircissements!

Salut ,

grace a un tuto de@J-M-L j ' ai fait un projet similaire en bien des points facilement adaptable et fonctionnel pour volets roulants .

il s' agit d' un programme tout fait , pour 8 volets initialement , mais modifiable avec une constante .

la montée , la descente , le stop et la centralisation des volets est gerée . le timer est prereglée a 30sec , avec fin de course integrée dans le moteur .

c ' est pilotable via navigateur internet .( donc pas de bouton prevu dans le programme et il faut un shield ethernet ou wifi sur l' arduino ) .

mais le code est deja tout pret . le programme n ' est pas gere en tant que machine etat et reste accessible a des debutants comme nous :) , il y a des commentaire en francais pour expliquer comment cela fonctionne .

je vous donne le lien si ca peut vous aider : https://forum.arduino.cc/index.php?topic=493039.0

Bon courage .

bonjour , dark

y a un “truc” qui va pas entre votre schémas et votre discourt

vous décrivez un pont en h avec 2 relais …
2 position , ok…

mais 3 position ( plus ,moins , arrêt ) , c’ est "improbable , a moins que vous
ayez une référence d’ un composant de ce type ?

normalement un pont en h c’est plus tôt 4 MOSFET , transistor , voir relais…
ou deux relais deux position + 1 relais simple coupure en aval = soit 3 relais.

Bonjour,

Pourquoi ajouter un troisième relais? Le schéma initial fonctionne très bien.

bonjour kamil

si vous regarder attentivement le shemas que dark a posté

le moteur a ses deux bornes a la masse.

mais même s'il le cable differament au niveaux des polarités

même au repos les relais alimentent le moteur dans un sens .

s'il veut arrêter le volet a mi hauteur , donc sans utiliser les fin de courses intégrées au moteurs

il faut un autre relais .

avec 2 relais , il n'y aura pas de coupure "mi ouvert" ou "mi fermé".

Il suffit de mettre les deux bornes du moteur à la masse pour l’arrêter.

Re bonjour , ces moteurs de volets ont 4 fils ?

un comun , une terre ? , un pour montee , un pour descente ?

@ kamil ; oups exact , vous avez raison ; +1 et +1 schemas .

je comprends pas pourquoi il est necessaire de brancher comme sur le schema , n ' est il pas plus simple de passer le commun ou masse du 24 V en direct ( je veux dire sans passer par les relais ) et d ' envoyer le 24 Volts avec les relais selon que l ' on veut monter ou descendre ?

j ' ai peut etre rien compris :)

iznobe: je comprends pas pourquoi il est necessaire de brancher comme sur le schema , n ' est il pas plus simple de passer le commun ou masse du 24 V en direct ( je veux dire sans passer par les relais ) et d ' envoyer le 24 Volts avec les relais selon que l ' on veut monter ou descendre ?

j ' ai peut etre rien compris :)

En fait les moteurs de mes volets ne possèdent que 2 fils et changent de sens en inversant la polarité. Je pense donc être obligé de passer par des relais pour se faire. Si effectivement j'avais eu un fil pour la montée et un pour la descente j'aurais pu avoir une masse permanente sur un commun et envoyer un 24 sur la fonction souhaité