forum.snootlab.com

Bonjour à tous,

Je suis actuellement en pleine construction de ma maison et se pose aujourd'hui la question de la gestion et de la centralisation des volets roulants Je dispose de 9 volets roulants de marque somfy (5 VR côté jour et 4 VR côté nuit).

En complément du pilotage normal via double inter ou double poussoir dans chaque pièce, je souhaiterais en complément disposer de 2 x (double Inter) ou (bouton poussoir) juste à côté de ma porte d'entrée pour centraliser les VR (côté JOUR et côté NUIT). Et de plus pouvoir piloter l'ensemble via le réseau.

Pensez-vous qu'il est possible de réaliser le projet via un Arduino ?

Suite à la lecture du forum, j'ai vu qu'il était possible de piloter des relais et donc mes VR (attention 220 volts :p)
Par contre, j'ai pas sauté le pas de la commande du matériel car j'ai un gros doute sur la gestion des entrées (double inter ou double bouton poussoir). Si j'ai bien compris impossible de gérer une entrée par thread etc.. j'ai donc peur que mon système ne soit pas réactif. Et de plus un doute sur la distance entre mes entrées et l'arduino, quasiment 50 mètres pour certains.

Merci d'avance pour vos différents retours.

Cdlt,
Sébastien

J'ai le même projet

les moteurs de volets roulant (Ms100 par exemple) sont alimentés en 220v : un fil neutre, un fil terre, un fil pour la monté un fil pour la descente
donc avec deux relais c'est possible, le moteur gère les fin de courses, donc pas de capteur pour les positions intermédiaires
l'arduino peut gérer les commandes avec des boutons poussoirs, ou depuis un Pc ou un smartphone....
je n'ai pas encore commencé le projet mais ça doit être possible avec un bus One-wire pour choisir quel volet commander individuellement...

Bonsoir

Je réfléchis aussi à un projet similaire, avec un peu moins de volets.
Voici où j'en suis:
Il y a moyen de le faire "tout cablé", comme montré là: http://martin.michel47.free.fr/electr/electricite/documents/schemat1.htm#Xv, mais ça fait un peu trop de câbles et de relais, donc je veux le faire avec un système plus intelligent.
Du coup il faut un interrupteur commandé: les relais, ça fait du bruit, je vais le faire avec optotriac + triac.

Problème: la commande 'centralisée' ne doit pas faire un court circuit si on fait simultanément une commande locale (identique ou inverse). Pour éviter ça, j'ai décidé que chaque volet serait commandé par un système unique qui reçoit des ordres de l'interrupteur local + 1 info de commande globale.

Après, je vois deux solutions:
1> Une centrale qui commande plusieurs volets (indépendamment). L'inconvénient est qu'il faut tirer 4 câbles par volet au lieu de 3, et qu'en plus il faut tirer tirer 3 câbles entre chaque interrupteur et la centrale. Mais un seul boitier système...

ou bien
2>Un système de commande au niveau de chaque volet. En plus de la distribution de puissance (3 fils), on amène 1 fil de commande (on prendra la terre commune) qui passent en série à tous les volets. Il faudra alors alimenter chaque boitier localement (soit autant de transfo, de boitiers à dissimuler, et de cartes à re-flasher si on veut changer la logique qu'il y a de volets).

Je prendrai une Arduino comme système de commande - que je choisisse le système centralisé ou réparti. Mais j'avoue que l'idée de multiplier les boitiers (ou les mettre, conso électrique non négligeable, ...) me plaît aussi peu que tirer des kilomètres de câble.

merci eco3x et Bemolu pour vos retours très intéressant.
- mes volets roulants gèrent également les fins de courses.
- les relais font beaucoup de bruit ? dans mon cas, il y aura une boîte dans le plafond côté nuit (10 relais) et une boîte également dans le plafond côté jour (10 relais).

J'ai décidé de franchir le cap, je vais aller m'acheter un Arduino Mega pour simuler le fonctionnement sur platine en espérant que cela soit la réponse à mes besoins. Il existe de multiple solution sur le marché mais vraiment très cher et proprio.
Je vous partage les infos et le code si j'arrive à faire quelque chose dans la semaine.

Je me pose encore la question, si via des boutons poussoirs le système va réussir à être réactif ... pour mon cas 10 volets donc un double bouton poussoir dans chaque pièce soit 20 entrées pour l'Arduino à gérer. Je laisse les pros pour donner leur avis

++
Séb

Voici le schéma de j ai imaginé pour commander 10 volets roulants avec un bus One-wire
et des switch Ds2408 http://www.maximintegrated.com/datasheet/index.mvp/id/3818
2 entrées du switch pour les commandes haut et bas 2 sorties pour commander les relais (ou électronique) qui actionne le moteur.
comme il y a 8 E/S sur un Ds2408 on peut commander 2 volet sur une même façade (proche)
voir même faire des scenario de fermeture programmée, avec des tempo gérer les position intermédiaires, capteur de soleil ...

super l'idée du bus One-wire et je pense beaucoup plus simple

C'est vraiment interessant, mais le problème du câblage reste:

il faut bien faire venir 3 fils supplémentaires au niveau de chaque volet (encore que la masse puisse être prise sur la terre, soit deux fils),

à chaque volet (ou à chaque bouton de commande de volet), il faut mettre un bloc supplémentaire (relais ou triac + périphérique 1-wire

Quelqu'un a une solution pour cacher tout ça derrière dans une boite interrupteur standard?

Bonsoir,

j'ai aussi l'intention d'automatiser la commande de mes volets électriques (marque Harol) mais je termine d'abord un autre projet en cours avec un arduino 2650. Pour l'instant je les actionne avec un interrupteur inverseur. Lors de la construction de ma maison j'avais déjà prévu un câble (4 X 1,5 mm²+terre) depuis chaque boîtier volet vers un même endroit situé dans une cave ; reste la partie commande .

En résumé l'installation se composera comme vous l'avez cité de deux parties :
a) la partie puissance : on a pas beaucoup de choix vu que le volet doit être câblé en 3 fils + terre.
Soit on a la possibilité d'installer la partie puissance à proximité du volet dans un endroit qui doit rester accessible facilement en cas de panne ; ce qui fait diminuer la partie câblage .
Soit on câble à partir de chaque volet vers un point situé dans une gaine technique, une buanderie ou cave ; endroit où sera installée la centrale de commandes.
b) la partie commande : plusieurs solutions sont possibles.
-Comme déjà évoquée : les deux bp raccordés sur une centrale de commande (arduino + interface ). Dans ce cas 1paire + masse commune sont nécessaires à partir de chaque boîtier volet vers la centrale de commandes.Rien n'empêche d 'installer un câble passant de boîtier à boîtier pour autant que ce câble comporte le nombre de paires suffisant : exemple un câble informatique comportant 4 paires pourra couvrir 3 boîtiers (3 paires + masse commune).Un seul câble utilisé anciennement en téléphonie comportant 12 paires pourra couvrir 11 boîtiers ; la connectique devenant délicate à l'intérieur de chaque boîtier.
-La solution d'un clavier installé dans un endroit stratégique de la maison.Un seul câble le reliant à la centrale de commande suffit.
-Un télécommande pourrait aussi être utilisée....à réfléchir.

En technique, les solutions les plus simples sont souvent les plus fiables et pas toujours les plus coûteuses.Et comme je suis plus « technique » que « programmation », autant se faciliter la vie côté arduino.
Déporter la partie commande dans chaque boîtier risque d'être plus délicat et onéreux que de tirer les câbles de puissance vers la centrale de commandes.
Le système d'adressage par bus est une formule sympa mais trop onéreuse par rapport au fait que sur un arduino méga 2650 on dispose de 54 entées/sorties Donc si on veut faire au plus simple on compte 2 entrées et deux sorties par moteur ; 54/4 = 13 moteurs .Cela est vrai si on utilise pas les fonctions sérielles, pwm, bus série SPI et interface I2C. En effet la plupart de ces 54 lignes peuvent être utilisée soit pour une des fonctions citées précédemment ,soit comme entrée /sortie.Par exemple
pour une utilisation de l'arduino par internet un shield internet sera monté sur la carte arduino et les lignes relatives au bus SPI (50à 53) seront réservées.
Par contre des lignes en entrées peuvent être « économisées » simplement en cablant en matrice ; une librairie « clavier » sera alors ajoutée au software .Exemple au lieu de gérer simplement 24 lignes en entrée ,on câble une matrice (6 rangées et 4 colonnes= 10 lignes utilisées) ; ce qui nous fait 34 lignes pour piloter 12 moteurs .Le tout est de savoir les fonctions de l'arduino qui nous seront utiles et ainsi de connaître le nombre disponible.
Le programme reposera sur le principe de la temporisation calculée au plus prêt de la réalité, ce qui apporte un double avantage :
-en cas de dysfonctionnement du fin de course, le moteur arrête peu après
-on peut positionner le volet autrement que totalement fermé ou ouvert.Ce qui peut être pratique pour ne pas surchauffer une pièce avec une vitre exposée en plein soleil..

Tout ceci est une analyse personnelle qui reste ouverte à des remarques constructives.

Enfin connaissez-vous comme « réagit » un moteur Somfy en cas de blocage ; imaginons que « belle maman » a la bonne idée de déposer un objet sur le seuil de la fenêtre vu que vous êtes absents.Vous commandez la descente du volet par internet et le volet bloque sur l'objet.
Soit le moteur ne s'arrête pas et la fin de la temporisation sera la bienvenue..
Soit le moteur s'arrête automatiquement .

Me concernant , les moteurs Harol de l'ancienne génération ne s'arrêtent pas, ce qui ne simplifie pas le projet.
Vous concernant cela reste un point à vérifier.

Espérant vous avoir apporté quelques renseignements utiles..

Salutations

Ci-dessous un petit retour sur mon montage pour la gestion des volets via l'Arduino Mega (cf. photos ci-dessous + le code). J'ai simulé via la platine 10 volets roulants (1 led pour simuler le relais et 1 BP pour actionner la montée et inversement).







Niveau code, il est un peu à chier, il faudra que j'optimise ...

Code: Tout sélectionner

int ledUp[] = {21, A15, A13, A11, A9, A7, A5, A3, A1, 12};
int ledDown[] = {20, A14, A12, A10, A8, A6, A4, A2, A0, 13};

int pushButtonUp[] = { 27, 19, 17, 15, 28, 2, 4, 6, 8, 10 };
int pushButtonDown[] = { 26, 18, 16, 14, 29, 3, 5, 7, 9, 11 };

int pushButtonCentralizedUp[] = { 30, 32 };
int pushButtonCentralizedDown[] = { 31, 33 };

boolean stateUp[] = { false, false, false, false, false, false, false, false, false, false };
boolean stateDown[] = { false, false, false, false, false, false, false, false, false, false };

boolean stateCentralizedUp[] = { false, false };
boolean stateCentralizedDown[] = { false, false };

boolean pushButtonUpEtat[] = { false, false, false, false, false, false, false, false, false, false };
boolean pushButtonUpEtat2[] = { false, false, false, false, false, false, false, false, false, false };
boolean pushButtonDownEtat[] = { false, false, false, false, false, false, false, false, false, false };
boolean pushButtonDownEtat2[] = { false, false, false, false, false, false, false, false, false, false };

boolean pushButtonCentralizedUpEtat[] = { false, false };
boolean pushButtonCentralizedUpEtat2[] = { false, false };
boolean pushButtonCentralizedDownEtat[] = { false, false };
boolean pushButtonCentralizedDownEtat2[] = { false, false };

int lastpushButton[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int lastpushButtonCentralized[] = { 0, 0 };

void setup ()
{
  //init
  for(int i=0; i<10; i++)
  {
    pinMode (ledUp[i], OUTPUT);
    pinMode (ledDown[i], OUTPUT);
    pinMode (pushButtonUp[i], INPUT);
    pinMode (pushButtonDown[i], INPUT);
  }
  pinMode (pushButtonCentralizedUp[0], INPUT);
  pinMode (pushButtonCentralizedDown[0], INPUT);
}

void loop ()
{
  vr(0); // -> VR1
  vr(1); // -> VR2
  vr(2); // -> VR3
  vr(3); // -> VR4
  vr(4); // -> VR5
  vr(5); // -> VR6
  vr(6); // -> VR7
  vr(7); // -> VR8
  vr(8); // -> VR9
  vr(9); // -> VR10
  vrall(0); // -> VRALL ALL
  //delay(100);
}

//function VR
void vr(int index)
{
  if (digitalRead (pushButtonUp[index]) == HIGH)
  {
    pushButtonUpEtat[index] = true;
   
    digitalWrite (ledDown[index], LOW);
   
    if (lastpushButton[index] == 0 || lastpushButton[index] == 2 || (pushButtonUpEtat[index] != pushButtonUpEtat2[index]))
    {       
      stateUp[index] = digitalRead (ledUp[index]);
      stateUp[index] = !stateUp[index];
      pushButtonUpEtat2[index] = true;
      digitalWrite (ledUp[index], stateUp[index]);
    }
    else if (lastpushButton[index] == 2)
    {
      stateUp[index] = true;
      pushButtonUpEtat2[index] = true;
      //Enabled VR UP with HIGH or LOW to depend the last position       
      digitalWrite (ledUp[index], stateUp[index]);   
    }
   
    lastpushButton[index] = 1;
  }
  else if (digitalRead (pushButtonUp[index]) == LOW)
  {
    pushButtonUpEtat2[index] = false;
  } 
 
 if (digitalRead (pushButtonDown[index]) == HIGH)
  {
    pushButtonDownEtat[index] = true;
   
    digitalWrite (ledUp[index], LOW);
    if (lastpushButton[index] == 0 || lastpushButton[index] == 1 || (pushButtonDownEtat[index] != pushButtonDownEtat2[index]))
    {       
      stateDown[index] = digitalRead (ledDown[index]);
      stateDown[index] = !stateDown[index];
      pushButtonDownEtat2[index] = true;
      digitalWrite (ledDown[index], stateDown[index]);
    }
    else if (lastpushButton[index] == 1)
    {
      stateDown[index] = true;
      pushButtonDownEtat2[index] = true;
      digitalWrite (ledDown[index], stateDown[index]);
    }
   
    lastpushButton[index] = 2;
  }
  else if (digitalRead (pushButtonDown[index]) == LOW)
  {
    pushButtonDownEtat2[index] = false;
  }
}


//function VR ALL
void vrall(int index)
{ 
  if (digitalRead (pushButtonCentralizedUp[index]) == HIGH)
  {
    pushButtonCentralizedUpEtat[index] = true;
   
    for(int i=0; i<10; i++)
    {
      digitalWrite (ledDown[i], LOW);
    }
   
    if (lastpushButtonCentralized[index] == 0 || lastpushButtonCentralized[index] == 2 || (pushButtonCentralizedUpEtat[index] != pushButtonCentralizedUpEtat2[index]))
    {
      stateCentralizedUp[index] = !stateCentralizedUp[index];
      stateCentralizedDown[index] = false;
      pushButtonCentralizedUpEtat2[index] = true;
      for(int i=0; i<10; i++)
      {     
        stateUp[i] = stateCentralizedUp[index];
        digitalWrite (ledUp[i], stateCentralizedUp[index]);
      }
    }
    else if (lastpushButtonCentralized[index] == 2)
    {
      stateCentralizedUp[index] = true;
      pushButtonCentralizedUpEtat2[index] = true;
      for(int i=0; i<10; i++)
      {     
        stateUp[i] = stateCentralizedUp[index];
        digitalWrite (ledUp[i], stateCentralizedUp[index]);
      }
    }
   
    lastpushButtonCentralized[index] = 1;
  }
  else if (digitalRead (pushButtonCentralizedUp[index]) == LOW)
  {
    pushButtonCentralizedUpEtat2[index] = false;
  }
 
  if (digitalRead (pushButtonCentralizedDown[index]) == HIGH)
  {
    pushButtonCentralizedDownEtat[index] = true;
   
    //Disabled VR UP
    for(int i=0; i<10; i++)
    {
      digitalWrite (ledUp[i], LOW);
    }
   
    if (lastpushButtonCentralized[index] == 0 || lastpushButtonCentralized[index] == 1 || (pushButtonCentralizedDownEtat[index] != pushButtonCentralizedDownEtat2[index]))
    {
      stateCentralizedDown[index] = !stateCentralizedDown[index];
      stateCentralizedUp[index] = false;
      pushButtonCentralizedDownEtat2[index] = true;

      for(int i=0; i<10; i++)
      {     
        stateDown[i] = stateCentralizedDown[index];
        digitalWrite (ledDown[i], stateCentralizedDown[index]);
      }
    }
    else if (lastpushButtonCentralized[index] == 1)
    {
      stateCentralizedDown[index] = true;
      pushButtonCentralizedDownEtat2[index] = true;

      for(int i=0; i<10; i++)
      {     
        stateDown[i] = stateCentralizedDown[index];
        digitalWrite (ledDown[i], stateCentralizedDown[index]);
      }
    }
   
    lastpushButtonCentralized[index] = 2;
  }
  else if (digitalRead (pushButtonCentralizedDown[index]) == LOW)
  {
    pushButtonCentralizedDownEtat2[index] = false;
  }
}


Zebulon a écrit:b) la partie commande : plusieurs solutions sont possibles.
-Comme déjà évoquée : les deux bp raccordés sur une centrale de commande (arduino + interface ). Dans ce cas 1paire + masse commune sont nécessaires à partir de chaque boîtier volet vers la centrale de commandes.Rien n'empêche d 'installer un câble passant de boîtier à boîtier pour autant que ce câble comporte le nombre de paires suffisant : exemple un câble informatique comportant 4 paires pourra couvrir 3 boîtiers (3 paires + masse commune).Un seul câble utilisé anciennement en téléphonie comportant 12 paires pourra couvrir 11 boîtiers ; la connectique devenant délicate à l'intérieur de chaque boîtier.

Je n'avais pas pensé à ce genre de câble. Jusqu'à quelle longueur peut-on aller en ayant un signal 'lisible' (je veux dire: on ne lit pas une impulsion quand le frigo se met en route (résistance aux interférences) ET on ne rate pas une impulsion (résistance aux pertes en ligne)) ?

Sinon pour économiser un câble par point de commande, (masse commune + Vcc commun + ligne retour) j'avais pensé à un truc du genre "appuis court < 1 seconde" >> montée complète, "appuis long > 1 seconde" descente complète. Si on fait un appuis court avant 5 secondes depuis le dernier appuis >> on arrête le mouvement. Comme ça avec un seul bouton on peut tout commander.

Zebulon a écrit:Enfin connaissez-vous comme « réagit » un moteur Somfy en cas de blocage ; imaginons que « belle maman » a la bonne idée de déposer un objet sur le seuil de la fenêtre vu que vous êtes absents.Vous commandez la descente du volet par internet et le volet bloque sur l'objet.

Je vais essayer de voir.

Zebulon a écrit:Soit le moteur ne s'arrête pas et la fin de la temporisation sera la bienvenue..
Soit le moteur s'arrête automatiquement .

En tous cas, cette idée de temporisation est vraiment bonne, je la garde.

Zebulon a écrit:Espérant vous avoir apporté quelques renseignements utiles..

Oui merci.

Bonsoir,
Bemolu,
1) -si le câble multipaires est utilisé pour raccorder les bp à la centrale de commandes (Arduino par exemple), la longueur de devrait pas avoir trop d'importance : chaque entrée de l'Arduino sera raccordée d'un côté au VCC via une résistance et de l'autre à la masse via le bouton poussoir.Une action sur le bp fait passer l 'état haut de l'entrée à l 'état bas de celle-ci; tout "signal" intempestif et effet de rebondissements peuvent être vaincus softwarement. Rien n'empêche aussi de travailler avec du câble "blindé".
-Par contre j'émettrai quelques réserves (voir craintes) pour transmettre des commandes "analogiques" (commander des relais logés dans le boitier volet par exemple"); ce qui obligerait de mettre des sécurités supplémentaires au niveau des cartes distantes; autant passer alors en numérique.
2) Si un bp par boîtier alors 1 fil + masse commune suffirait effectivement; pour compléter votre (bonne ) réflexion:
Par exemple 1 appui court "1 seconde" serait pour la montée,
deux appuis courts successifs (intervalle de 1 seconde) stoppe le mouvement quel qu'il soit.
1 appui long > 2 secondes serait pour la descente
En continuant la réflexion ci-dessus on peut imaginer une autre solution: le câblage pourrait être réduit au strict minimum; c'est-à-dire qu' un câble de 4 fils de 1,5 mm² + terre entre l'arduino et le boitier volet suffirait .Ce câble est généralement utilisé pour les circuits électriques "va-et-vient".
En effet :
-le fil de terre raccordé au bornier moteur
-1 fil pour la montée (raccordé entre sortie relais 1 ou triac 1 ------------------ bornier moteur)
-1 fil pour la descente (raccordé entre sortie relais 2 ou triac 2-------------------bornier moteur)
-1 fil pour la phase (raccordé sur le bornier moteur et sur une borne du bp)
-1 fil (raccordé sur "détecteur de phase " du côté Arduino --------------------deuxième borne du bp);en cas d'appui sur le bp la phase est "raccordée" sur l'entrée de l'arduino via une petite interface analogique (type pont diviseur + redresseur + phototransistor).
Les parasites pourraient aussi être éliminés par software.Cela implique une petit peu plus d'électronique du côté Arduino mais simplifierait grandement le câblage .....
Idée à creuser..

Sinon pour économiser un câble par point de commande, (masse commune + Vcc commun + ligne retour) j'avais pensé à un truc du genre "appuis court < 1 seconde" >> montée complète, "appuis long > 1 seconde" descente complète. Si on fait un appuis court avant 5 secondes depuis le dernier appuis >> on arrête le mouvement. Comme ça avec un seul bouton on peut tout commander.

Un genre de code Morse · · · — — — · · · par exemple trois appuis court = fermeture générale.
c'est pas mal comme idée, ça pourrait aussi servir pour l'éclairage de la maison.

Zebulon a écrit: En continuant la réflexion ci-dessus on peut imaginer une autre solution: le câblage pourrait être réduit au strict minimum; c'est-à-dire qu' un câble de 4 fils de 1,5 mm² + terre entre l'arduino et le boitier volet suffirait .Ce câble est généralement utilisé pour les circuits électriques "va-et-vient".
En effet :
-le fil de terre raccordé au bornier moteur
-1 fil pour la montée (raccordé entre sortie relais 1 ou triac 1 ------------------ bornier moteur)
-1 fil pour la descente (raccordé entre sortie relais 2 ou triac 2-------------------bornier moteur)
-1 fil pour la phase (raccordé sur le bornier moteur et sur une borne du bp)
-1 fil (raccordé sur "détecteur de phase " du côté Arduino --------------------deuxième borne du bp);en cas d'appui sur le bp la phase est "raccordée" sur l'entrée de l'arduino via une petite interface analogique (type pont diviseur + redresseur + phototransistor).
Les parasites pourraient aussi être éliminés par software.Cela implique une petit peu plus d'électronique du côté Arduino mais simplifierait grandement le câblage .....

Bonne idée, sauf que normalement c'est le neutre qui est direct sur le moteur, et on bascule la phase sur le fil montée ou descene. A force de tourner le problème dans tous les sens, j'ai eu une autre idée qui, avec le même nombre de câble, d'économiser quelques composants, et surtout d'avoir à "lire" du 220 (déjà qu'il faut le commander!):
Avec un seul fil supplémentaire (donc TERRE + NEUTRE + MONTEE + DESCENTE de base pour le moteur et un fil 'COMMANDE), selon le schéma suivant, on lira depuis l'Arduino:
- environ 1024 au repos
- environ 512 si le bouton poussoir "MONT" est utilisé
- environ 0 si le bouton poussoir "DESC" est utilisé

La conso est quasi nulle (grosse résistance).

On peut garder le principe des appuis court long (pour enlever un bouton poussoir, ou déclencher une autre action ...)

Bonjour,
Bemolu:
Pour la solution du BP seul pourquoi pas une solution hardware et software à la fois c’est-à-dire que l’arduino garde en mémoire le « dernier mouvement » (descente ou montée) Je pars toujours du principe que la commande du volet est temporisée.
-une action sur le BP… le volet monte ; une mémoire « mouvement est mise à 1
-une deuxième action sur le bp :
alors que la temporisation est « écoulée « (après 20 sec par exemple) le moteur est commandé pour la descente .(mémoire mouvement mise à 0).En pratique : une action le matin et le volet s’ouvre au maximum. Une action le soir et le volet se ferme entièrement.
alors que la temporisation est toujours en cours (intervalle de temps inférieur à 20 sec) alors le volet s’arrête (mémoire mouvement inchangée); une troisième action inverse le sens de rotation du moteur (mémoire mouvement changée) En pratique cette solution serait utilisée pour arrêter le volet en position intermédiaire.

Cette solution serait plus pratique que la version « Morse »..
Que du bonheur…

Quant à la partie 220V ;
Au point de vue technique, que l’on raccorde le neutre sur la montée ou la descente et la phase sur l’autre fil, ou la phase sur le fil montée ou fil descente et le neutre sur le troisième fil ,le moteur fonctionnera de la même façon. C’est juste une question de règlementation française qui oblige à couper la phase quand le moteur est à l’arrêt.
Comme la « haute » tension ne semble pas être votre terrain de prédilection , il existe aussi la solution avec un seul bp :
-un fil de terre à part qui passe de moteur à moteur jusqu’à une prise proche ou redescendu jusqu’au coffret électrique (voir règlementation en vigueur)
-un câble à 4 fils + terre donc 5 fils disponibles:
-1 fil entre l’arduino (interface HT) ………………et le moteur (montée)
-1 fil entre l’arduino (interface HT) ………………et le moteur (descente)
-1 fil pour le neutre moteur
- fil 4 et 5 pour le BP donc contact libre de potentiel..
Donc un seul câble 4 X 1,5 mm² +terre suffit
Que du bonheur…

Concernant votre schéma :
Cela correspond à la détection de 3 états sur chaque entrée. En théorie le principe est bon mais en pratique :
-sur Arduino ,les entrées à utiliser ne seront plus du type numérique (tout ou rien) mais analogiques qui sont moins nombreuses sur la platine.
-pour ne garder que trois fils, la deuxième résistance sera située au niveau des bp, c’est-à-dire que l’arduino doit mesurer un potentiel de +/- 2,5V à une distance plus ou moins grande : arduino peut interpréter des signaux parasites comme des commandes ????
-surtout ne pas raccorder la terre de l’installation électrique sur la masse de l’arduino. La terre (secteur) peut générer des commandes aléatoires du moteur, des dysfonctionnements de la platine, voire même la détruire .

Conclusion :
En plus du câble 3 X 1,5mm²+ terre ou 2 X 1,5mm² + terre (avec câblage à part de la terre des moteurs) :si vous voulez utiliser une seule paire (de fils petite section ) par boitier (1 fil et une masse commune) alors on peut adopter la solution un bp comme décrit ci-avant (hardware et software); si vous voulez utiliser deux bp, alors une paire de fils (+ masse commune) par boitier est nécessaire ; la commande pour un arrêt sera gérée par software

Que du bonheur…

Avez-vous des contraintes au point de vue câblage: déjà existant ou autres..

Je reste disponible pour tout renseignement complémentaire .


Salutations

Bonjour
Je suis en train de réaliser un projet similaire.

j'ai 5 volets, chacun possède un seul bouton poussoir; vu les longueurs de fil, j'ai 5 générateurs de courant avec des lm317, sur ma carte type "Arduino standalone" fait maison, je rentre sur des optocoupleurs puis les entrées de l'atmega 328, en sortie deux 74hc595 suivi de ULN qui commandent 10 relais G2R1R OMRON peut bruyants.

Un appui de 1 à 3secondes sur un bp ouvre ou ferme le volet correspondant; pendant le mouvement un nouvel appui arrête le volet. Un appui de 5s à 10s ouvre ou ferme tous les volets; une LDR permet de piloter le tout en jour nuit.
je vais voir pour ajouter une mesure de température extérieure et tout fermer si il fait vraiment trop froid.
Voila si ça peu aider.

Bonjour,

je viens de faire l'acquisition d'un Arduino nano pour m'amuser un peu et vous lisant sur ce forum, je vois votre projet de pilotage des volets pourrait être ma première application "utile".

Pour le moment j'ai je dispose de 8 volets électriques que je commande en local. je dispose aussi d'un fil pilote qui les relie et qui arrive sur un bouton "centraliseur" que pour l'instant je n'utilise pas. Au départ je pensais m'équiper en modules yokis mais le prix de ces joujous m'a un peu freiné. De plus, si ils arrivent à le faire avec leurs module, je pense que l'on peut y arriver aussi...

Bref, sachant que je remplacerais tout les interrupteurs inverseurs par des doubles poussoirs, est-il possible de dialoguer par 2 fils ( masse + fil pilote ) vers mes commandes de volets ? J'aime l'idée de ecox3 en 1wire avec le DS2408 mais est-ce que le dialogue s'effectuera correctement en mode 1wire parasite ?

merci de vos remarques.