DIY - Domotique: Automatisation des volets roulants

Hello tous,

J'ai pour objectif d'automatiser tout ce que je peux dans ma maison, donc je vais commencer par le plus simple, à savoir les volets roulants

D'origine on a un interrupteur à 3 positions qui commande les deux directions, côté moteurs on a donc 3 fils un fil neutre et deux phases l'une pour la montée, l'autre pour la descente.

J'ai opté pour un relai bi-canal piloté par un NodeMCU qui expose 3 endpoints:

• /blinds_up pour monter les volets
• /blinds_down pour descendre les volets
• /stop pour arrêter tout mouvement

Un serveur permettra de contrôler tous les devices de la maison, et permettra également de programmer certaines actions, par exemple: ouvrir les volets à 8h et les fermer à 20h.

mDNS permet de broadcaster un service, de lui attribuer un nom de domaine et de faire des recherches par type de devices. L'idée étant qu'en cas de coupure de courant tous les devices soient découvrables sans pour autant leur attribuer une adresse ip fixe, afin de pouvoir remonter l'architecture sans intervention manuelle.

Matériel

Hi-Link HLK- PM01 ~ 1.50 euros

Relay 2 canaux 5v ~1.50 euros

Nodemcu Lolin ~5 euros

On a donc un total d'environ 8 euros pour ce projet.

Schéma de connexion

Logiciels

TBD

FloSimRace a écrit :

Beau projet Shinuza

J'y connais pas grand chose en programmation (c'est plus la thermique du bâtiment mon truc) mais pourquoi ne pas intégrer un capteur de luminosité pour contrôler l'heure d'ouverture et de fermeture des volets ? Par exemple :

• Pièce de vie : ouverture et fermeture suivant la luminosité
• Pièce de nuit : ouverture à heure fixe (à l'heure du réveil par exemple) et fermeture en fonction de l'heure de couché ou de la luminosité (priorité à celui intervenant le plus tôt)

Je sais pas si c'est plus compliqué mais ça permettrait une modularité entre l'hiver et l'été sans avoir à changer les consignes. Après, faut un bon "étalonnage" et une bonne valeur de consigne pour la luminosité.

Je peux tout à faire faire ce genre de chose, l'idée c'est de faire de IoT as a service. Donc je peux tout à faire remonter des évenements depuis des devices dédiés à la température ou à la luminosité.

momoclic a écrit :

Les volet roulant dont tu dispose autorisent un branchement aussi simple ?

Méfie toi avec les fins de course ou avec la télécommande !

Comment comptes-tu centraliser ta domotique ?

J'avais regardé des trucs genre Home Automation mais ça m'inspire absolument pas confiance. Je vais procéder par itération, on verra si je passe sur une autre solution par la suite.

Pour l'instant j'ai besoin d'une device discovery (gérée par mDNS), gestion d’évènements et d'automatisation (gérée par Celery), un contrôle direct des devices + programmation des évenements (flask + celery).

Pour les fins de courses, je vais forcer le stop au bout d'un certain temps, je ne peux pas mettre de stop mécaniques, donc on va faire des faire des stops logiciels

Stribond a écrit :

Effectivement, je ne vois pas dans ton schéma la détection de ta fin de course. Si elle est mal faite est-ce qu'il n'y a pas un risque d’abimer le moteur ?

C'est juste une question de novice. Dans mon appart précédent, il fallait que j'arrête manuellement les volets quand ils avaient fini de descendre ou de monter, sinon on entendait le moteur ronfler indéfiniment. Ce qui n'est pas le cas dans ma maison actuelle ....

Effectivement y'a ce soucis là, d'ailleurs les nouveaux interrupteurs se maintiennent dans leur position jusqu'à que l'on appuie sur stop donc il faut faire attention. Y'a une certaine tolérance quand même. Je peux déduire la position du volet de manière peu précise en calculant la durée d'un cycle complet, le problème c'est que je n'ai pas de feedback au moment où le relai est effectivement fermé. Mais je pense qu'il y a des solutions.

En tout cas, la partie device est faite, il reste à faire le câblage et la tour de contrôle.

/*
   Copyright (c) 2015, Majenko Technologies
   All rights reserved.

   Redistribution and use in source and binary forms, with or without modification,
   are permitted provided that the following conditions are met:

 * * Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.

 * * Redistributions in binary form must reproduce the above copyright notice, this
     list of conditions and the following disclaimer in the documentation and/or
     other materials provided with the distribution.

 * * Neither the name of Majenko Technologies nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <pins_arduino.h>
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

const char* ssid = "...";
const char* password = "...";
const int port = 3030;
const String RESULT_OK = "{\"ok\": true}";
const String RESULT_METHOD_NOT_ALLOWED = "{\"error\": \"method not allowed\"}";

// Instanciate server
ESP8266WebServer server ( port );

void setup ( void ) {
  // Initiate pins
  pinMode(D7, OUTPUT);
  pinMode(D8, OUTPUT);
  pinMode(D2 , OUTPUT);

  // Initiate wifi
  Serial.begin ( 115200 );
  WiFi.mode ( WIFI_STA );
  WiFi.begin ( ssid, password );
  Serial.println ( "" );

  // Wait for connection
  while ( WiFi.status() != WL_CONNECTED ) {
    delay ( 500 );
    Serial.print ( "." );
  }

  // Set led high when wifi is connected
  digitalWrite(D2 , HIGH);
  Serial.println ( "" );
  Serial.print ( "Connected to " );
  Serial.println ( ssid );
  Serial.print ( "IP address: " );
  Serial.println ( WiFi.localIP() );

  // Set up mDNS responder:
  if (!MDNS.begin("esp8266")) {
    Serial.println("Error setting up MDNS responder!");
    while (1) {
      delay(1000);
    }
  }
  Serial.println("mDNS responder started");

  // Add service to MDNS-SD
  MDNS.addService("http", "tcp", port);
  // Add TXT record, those are merely metadata we will use to discover services
  MDNS.addServiceTxt("http", "tcp", "device_type", "blinds");

  // Mount endpoints
  server.on ( "/", handleRoot );
  server.on ( "/blinds_up", blindsUp );
  server.on ( "/blinds_down", blindsDown );
  server.on ( "/stop", blindsStop );
  server.onNotFound ( handleNotFound );
  server.begin();
  Serial.println ( "HTTP server started" );
}

void loop ( void ) {
  server.handleClient();
}


/* Handlers */
void handleRoot() {
  server.send ( 200, "text/html", "Welcome!" );
}

void handleNotFound() {
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += ( server.method() == HTTP_GET ) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";

  for ( uint8_t i = 0; i < server.args(); i++ ) {
    message += " " + server.argName ( i ) + ": " + server.arg ( i ) + "\n";
  }

  server.send ( 404, "text/plain", message );
}

void blindsUp() {
  if (ensurePostMethod()) {
    digitalWrite ( D7, HIGH );
    digitalWrite ( D8, LOW );
    server.send ( 200, "application/json", RESULT_OK);
  }
}

void blindsDown() {
  if (ensurePostMethod()) {
    digitalWrite ( D7, LOW );
    digitalWrite ( D8, HIGH );
    server.send ( 200, "application/json", RESULT_OK);
  }
}

void blindsStop() {
  if (ensurePostMethod()) {
    digitalWrite ( D7, LOW );
    digitalWrite ( D8, LOW );
    server.send ( 200, "application/json", RESULT_OK);
  }
}

bool ensurePostMethod() {
  if (server.method() != HTTP_POST) {
    server.send ( 405, "application/json", RESULT_METHOD_NOT_ALLOWED);
    return false;
  }
  return true;
}

Ce sketch Arduino:

• Connecte le device au wifi
• Publie un broadcast mDNS avec les métadata nécessaire au filtrage du service
• Expose une API, pour l'instant pas protégée, qui permet d'interagir avec le device

Demain cablâge et mise ne place d'une version basique de la tour de contrôle.

Patrice Virlin a écrit :

Cool ton histoire de domotique. Un truc quand même : faut gérer les différentes coupures de courant, coupure secteur, coupure parce que ta femme a mis les doigts dans la prise et coupure de personnes mal intentionnées qui en veulent à ton patrimoine.

C'est pour ça que les devices sont discoverable. Ils se connectent au réseau des qu'ils sont sous tension et publient leur champ d'action. Reste au contrôleur de faire la découverte, la classification et la gestion.