Archives par étiquette : domotique

Raspberry Camera : Raspicam V2

Chose promise, chose due, voici quelques photos du montage en cours de notre RaspiCam version 2, un système de capture photos tournant sur Raspberry Pi 3. Le premier exemplaire tourne depuis pas mal d’années sur Raspberry Pi 1 et fonctionne toujours. Il était donc temps de faire évoluer un peu la bête.

Les photos donc :

Ici, vous apercevez l’embase PoE étanche, permettant de passer à travers le boîtier de la fausse caméra. Ce boîtier a été commandé sur le roi du travail sous pression et des salaires faibles, j’ai nommé Amazon, pour un peu moins de 20 €. Sur le haut de l’image, on aperçoit le bout métallique de la sonde de température, une sonde qui sort via un trou présent d’origine sur le boîtier.

Ici, vous avez un aperçu de la sortie RJ45 étanche : on y insèrera un CAT5 blindé, on ferme, on presse, et hop, tout est étanche ! Un PoE sera inséré dans le boîtier pour venir alimenter la framboise.

Une vue d’ensemble, à noter les fils d’alimentation du Raspberry Pi 3 pour gagner de la place : pas ou peu possible de venir se brancher en USB sur le côté, la place sera très limitée une fois tous les modules en place, et c’est peu dire… Vous apercevez également le branchement de la sonde de température à même le Raspberry Pi, histoire que rien ne puisse jamais bouger ni se débrancher.
Il s’agit d’une sonde 1Wire dont vous trouverez par exemple une description vraiment bien faite sur l’excellent blog Framboise 314Je ne trouve qu’un petit inconvénient à cette sonde : son inertie en version étanche, le temps sans doute que le métal entourant le capteur à proprement parler ne transmette la chaleur. Mais comme nous ne demandons pas une précision digne d’une mission spatiale, à la rigueur c’est un inconvénient minime.

Il nous reste maintenant à venir assembler tout ce petit monde dans le boîtier de la fausse caméra. Là, j’avoue ne pas encore avoir tout prévu, mais il y a fort à parier que nous allons faire largement appel à la Superglue ou à une solution type Colle 21 pour venir positionner des petits pieds caoutchouc sous différents modules et les positionner sur le boîtier.

A suivre donc, la prochaine étape consistera à venir positionner la caméra puis programmer tout ce petit monde. Il y a également fort à parier qu’une sonde de température plus complexe soit ajoutée, un BMP805 relié cette fois-ci en I2C : elle nous permettra de lire la température dans le boîtier, mais surtout d’obtenir la pression du lieu d’installation, toujours sympa pour mesurer une tendance. En effet, pression > 1013 => beau temps qui vient. Pression < 1013 => sortez les cirés ! C’est ridiculement simple je sais, mais ici, sur le Raspberry Pi 1, cela fonctionne à merveille depuis le début.

 

RaspiCam : RaspberryPi + caméra + sondes

Voici déjà de nombreuses années, en 2014, j’ai développé une solution de timelapse basée sur un Raspberry Pi première génération. Ce système, il fonctionne toujours, placé à l’extérieur depuis le début, sans aucune faille depuis :

Avec les nouveaux matériels, il est peut-être temps de le faire évoluer, que ce soit au niveau matériel ou au niveau des logiciels, des scripts python même.

Ainsi, une nouvelle version à base de Raspberry Pi 3 va prochainement prendre la direction du labo. Dès à présent, le boîtier étanche est trouvé :

Vous l’aurez deviné, c’est toujours une solution de caméra factice qui sera vidée puis remplie avec mes propres matériels : PoE ethernet avec alimentation Usb du Raspberry Pi, sonde de température étanche DS18B20, BMP180 pour obtenir la pression (QNH), etc.

L’idée est d’obtenir une solution simple, avec diffusion d’une image contenant les informations météo de base, voir de venir enregistrer sur un disque externe sur une longue période, un peu façon timelapse.

A suivre donc, le temps d’assembler tout ce petit monde, de réviser les scripts et de lancer les premiers essais.

RaspiDomo : prises télécommandées Di-O Chacon

Cela fait un bon moment que le sujet domotique n’a pas été évoqué, souvenez-vous par exemple de notre RaspiDomo associé à des modules Chacon Di-O destinés à activer des interrupteurs muraux :

chacon-micromodule

Aujourd’hui, c’est une extension qui s’ajoute à notre RaspiDomo de développement, avec cette fois des prises murales télécommandées, avec 2500 W de puissance max, du moins en théorie :

chacon-dio-2500

En théorie oui car dans les faits il semblerait bien que 2000 W soit le maximum exploitable en continu, et que les 500 W supplémentaires ne soient disponibles qu’en consommation de pointe. Nous l’avons testé avec un radiateur électrique de 2300 W à pleine puissance : le module s’active, coupe, s’active, etc. En réduisant la puissance à 2000 W, tout fonctionne bien.

Là encore, la configuration est simple : une fois branché, notre module se met en écoute d’un code. Envoyons simplement une trame depuis un accès ssh de notre Raspberry Pi :

send 0 12325269 1 on

et voici le code 12325269 et l’identifiant 1 attribués à notre module. Pour éteindre, c’est désormais simplissime :

send 0 12325269 1 off 

Refaites la même procédure avec la télécommande livrée avec le pack : débranchez, rebranchez le module, pressez sur le bouton ON numéro 1 une ou deux fois, et voici un second code associé au module (3 maximum).

Ajoutons maintenant un peu de crontab pour activer ou désactiver les modules la nuit par exemple, dans le cas d’un chauffage électrique, et vous pourrez désactiver rapidement et facilement les pièces non utilisées la nuit en hiver : moins de consommation, autant d’argent économisé, une belle idée pour moins de 30 € les trois modules.

Raspberry Pi + H801 : défilement aléatoire en Python

Un petit script en python pour votre Raspberry Pi, suite au premier billet sur le H801 :

# -*- coding: utf-8 -*-
import time
import os
import random
while True:
  color = "%06x" % random.randint(0, 0xFFFFFF)
  somme = "sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbeb" + color + "00005c59d6000 -v 192.168.1.127 > /dev/null"
  os.system(somme)
  time.sleep(0.3)

Sauvegardez le sous le nom led.py et exécutez le avec python3 led.py : vos leds font alors s’allumer de façon totalement aléatoire.

Pensez à modifier l’IP 192.168.1.127 par l’ip de VOTRE module et réglez la pause en modifiant time.sleep(xxx) par xxx secondes, selon vos goûts.

Raspberry Pi + H801 : contrôlez vos LEDs RGB

Le petit H801 proposé sur nombre de boutiques asiatiques est un contrôleur de LEDs RGB (Red, Green Blue) qui va soit générer son propre réseau WiFi, soit venir se connecter au WiFi de votre box.

espleds

Pour très peu d’Euros, vous allez ainsi pouvoir briller en société, venir contrôler un ruban à LEDs au moyen de votre smartphone. Intégrant un ESP8266, l’appareil est en outre reprogrammable à volonté, les exemples ne manquent pas sur internet.

Reste maintenant à venir intégrer ce bijou de technologie chinoise à votre domotique, à pouvoir le contrôler de façon un peu plus simple qu’avec l’application de base d’un smartphone Android. En fouillant un peu sur la toile mondiale, je suis tombé sur ce billet qui dégrossit le fonctionnement de la bestiole, mais hélas cela n’a pas fonctionné ici : les codes d’identification de mon module semblaient différents de ceux initialement utilisés.

Ni une, ni deux, direction Wireshark pour venir analyser les trames UDP diffusées par l’application sur ma tablette Android (192.168.1.181 sur mon réseau local) :

wireshark osx

et plus précisément la trame udp émise du port 30978 vers le port 30977 :

wireshark trame

Bon sang, mais c’est bien sur, la trame doit impérativement débuter par fbeb, suivi par 6 codes hexa correspondant à la couleur.

Sur notre Raspberry Pi, installons sendip et tentons d’éteindre les LEDs :

sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbeb00000000005c59d6000 -v 192.168.1.127

Ici, 192.168.1.127 est l’IP utilisée par notre H801 sur le réseau local WiFi, vous l’adapterez à votre installation propre bien entendu. Pas besoin d’IP source, la seule réception de la bonne trame UDP suffit visiblement à contenter notre H801.

Partant du principe qu’il faut remplacer les 6 codes hexa, voici comme obtenir une LED totalement blanche :

sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbebffffff00005c59d6000 -v 192.168.1.127

ou rouge :

sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbebFF000000005c59d6000 -v 192.168.1.127

ou verte :

sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbeb7AFF0400005c59d6000 -v 192.168.1.127

La recette pour définir la couleur est simple. Partez de ce principe :

sendip -p ipv4 -p udp -us 30978 -ud 30977 -d 0xfbebXXXXXX00005c59d6000 -v 192.168.1.127

ou les XXXXXX (6 fois X) représentent le code couleur hexadécimal que vous allez trouver sur ce site

rgb

Exemple de couleur verte, codée 7AFF04

A vous de jouer désormais, vous allez pouvoir vous amuser sur votre Raspi préféré 😉

Freebox Revolution : allumage via un script .sh

Allumer sa Freebox Revolution à distance ? C’est tout à fait possible, on peut même intégrer un script à lancer dans une application domotique, par exemple pour simuler une présence.

Commençons par récupérer le code de la télécommande de la Freebox en vous rendant dans Réglages, Système, puis Informations. Notez le, et remplacez 123456 dans le script ci-dessous par votre code :

!/bin/bash
sudo curl --data "code=123456&key=power" http://hd1.freebox.fr/pub/remote_control
sleep 8
sudo curl --data "code=123456&key=ok" http://hd1.freebox.fr/pub/remote_control
sleep 5
sudo curl --data "code=123456&key=1&key=4" http://hd1.freebox.fr/pub/remote_control

Dans cet exemple que j’ai appelé tv.sh et autorisé en exécution par un chmod +x tv.sh,  nous allumons la Freebox, attendons 8 secondes que tout soit bien lancé, puis pressons « ok » pour accéder au service TV, attendons 5 secondes que la TV s’active, puis pressons les touches 1 et 4 pour atterrir sur France 4 (chaine 14 de la TNT).

Pour générer l’appui sur d’autres touches, utilisez la liste ci-dessous :

  • red : bouton rouge (B)
  • green : bouton vert (A)
  • yellow : bouton jaune (Y)
  • blue : bouton bleu (X)
  • power : touche rouge on/off
  • list : touche d’affichage de la liste des chaînes
  • tv :  touche verte TV de commutation péritel.
  • 0 à 9 : les touches 0 à 9
  • back : touche jaune en dessous du 7
  • swap : touche en dessous du 9
  • info, mail, help, pip : les touches bleues à droite des numéros de chaîne
  • epg, media, options : les fonctionnalités « secondaires » de ces même touches
  • vol_inc, vol_dec : volume+ et volume-
  • prgm_inc, prgm_dec : prog+ et prog-
  • ok : touche OK
  • up, right, down, left : les touches directionnelles entourant OK
  • mute : couper le son
  • home : touche FREE
  • rec : enregistrement
  • bwd : retour en arrière (<<)
  • prev : précédent (|<<)
  • play : lecture/pause
  • fwd : avance rapide (>>)
  • next :suivant (>>|)

Raspberry Pi 2 domotique : ESP8266 capteur d’ouverture suite (13)

Le capteur d’ouverture présenté dans le précédent billet prend forme. Le voici désormais totalement intégré dans une boite de dérivation :
esp8266_domotique

La boite de dérivation ira s’encastrer dans une cloison en placo, l’installation étant prévu dans une maison en rénovation. Elle comporte l’alimentation 220 V / 3.3v, les bornes électriques, les dominos pour venir raccorder le capteur d’ouverture reed, et un petit ESP8266 version ESP12 programmé en Lua.

Le point d’accès de la photo va lui permettre de relier tous les capteurs ESP12 ensemble, indépendamment de la box internet utilisée : changez de box, les capteurs seront toujours opérationnels, pas besoin de reprogrammer leur réseau WiFi. Les IP sont affectées par le serveur dhcp de la box, mais on peut aussi envisager des IP fixes (gaffe au changement de box dans ce cas…).

Dans le projet de rénovation, plusieurs capteurs d’ouverture vont être implantés, avec le projet d’en ajouter également un sur la sonnette de la porte d’entrée, de façon à être prévenu en notre absence : email + capture d’écran de la caméra rue, par exemple.

Il va falloir désormais s’occuper de gérer le script en Python3 sur le Raspberry Pi utilisé comme serveur, et là, c’est le plus difficile, même si cela reste vraiment passionnant à développer 😉

 

Raspberry Pi 2 domotique : ESP8266 capteur d’ouverture (12)

Transformons un petit ESP8266 (version ESP12) en capteur d’ouverture de porte. Je passe sur le script init.lua destiné à initialiser la connexion Wifi par exemple, vous en trouverez un exemple sur ce billet.

esp12_3

ESP12

Voici le script que j’ai appelé contactESP2.lua, on se retrouve après pour détailler son fonctionnement :

 

-- on active le GPIO4 en entree
gpio.write(2, gpio.LOW)
gpio.mode(2, gpio.INT, gpio.PULLUP)

-- contact porte ferme par defaut
ouvert = 0
cu = nil
-- 
-- nom = nom du capteur
-- porttcp = port TCP d'émission de trame si détection d'ouverture
-- portudp = port UDP d'écoute des trames de status
-- ip = adresse IP du serveur TCP Raspi Domo en écoute
--
nom = "sonde1"
porttcp = 5665
portudp = 5665
ip = "192.168.1.60"

print(nom .. "/n")
function contact(level) -- on lit le contact du gpio4
 etat = gpio.read(2)
 if etat == 1 then
 ouvert = 1
 print('PORTE OUVERTE')
 cu=net.createConnection(net.TCP)
 cu:on("receive",function(cu,c) print(c) end)
 cu:connect(porttcp,ip) -- connexion du port tcp sur l'ip choisie
 cu:send(nom .. "\n") -- envoi du code du capteur suivi d'un retour ligne
 
 tmr.delay(1000000)
 else ouvert = 0
 end
 end

-- configuration port gpio 4 en entree

gpio.trig(2, "both", contact) -- si changement etat on lance la fonction contact

-- si on emet une trame udp "sat"+nom du capteur sur le port udp sélectionné
-- la sonde repond par "ok" suivi du nom du capteur

s=net.createServer(net.UDP) 
s:on("receive",function(s,c)
 print(c)
 if c == "stat" .. nom then
 print('status sonde ok')
 cu=net.createConnection(net.TCP)
 cu:connect(porttcp,ip)
 cu:send("ok".. nom .. "\n")
 end 
 end) 
s:listen(portudp)

 

Et voilà, de retour, c’est long, oui je sais 😉

Branchez un contacteur de porte sur le port GPIO4 de votre ESP 12 (j’ai utilisé cette version pour éviter certains bugs logiciels au boot) d’un coté, sur GND (la masse) de l’autre.

esp8266_porte

ESP12 + capteur d’ouverture

Dans notre exemple, lorsque le contact s’ouvre (= port ouverte), une trame « sonde1 » est envoyée sur l’ip 192.168.1.60 port TCP 5665. Si j’envois une trame « statsonde1 » sur le port UDP 5665, la sonde va me répondre « oksonde1 » sur son port TCP 5665.

Bien entendu, tout se configure :

[checklist]

  • le port TCP
  • le port UDP
  • l’IP du serveur qui va recevoir les trames (j’ai programmé un Raspberry Pi en Python3 pour cela)

[/checklist]

On peut faire différent, et imaginer par exemple recevoir l’impulsion de détection d’un capteur de mouvement, lui aussi alimenté en 3.3v si je ne m’abuse, un peu ce genre de platine :

ir_sensor_motion

Capteur de mouvement

La fonction d’interrogation de la sonde est un gadget, mais cela peut être utile si vous souhaitez demander à votre domotique de surveiller régulièrement le fonctionnement des différents capteurs : c’est mieux qu’un ping, et on peut au besoin envoyer d’autres informations, comme avec cette sonde de température domotique que Blogwifi vous avait présentée par le passé.

L’ESP12 disposant de multiples GPIO, vous devriez pouvoir rajouter d’autres possibilités de détection en parallèle avec le GPIO4. A vous de jouer, n’hésitez pas à faire part de vos expériences dans les commentaires.

 

Raspberry Pi 2 domotique : reboot régulier de la Livebox Play (11)

Si vous utilisez une Livebox Play, vous n’aurez pas manqué de remarquer les bugs de l’appareil, provoquant des plantages réguliers. Cette fois, les techniciens d’Orange ont fait fort, en proposant une box sans la tester jusqu’au bout, chapeau !

Il existe une astuce toutefois, relayée par Blogmotion sur Twitter, une astuce à découvrir sur ce lien : un simple script sh que vous allez lancer régulièrement.

Commencez par copier le contenu du script, puis, depuis un terminal ssh sur le Raspberry Pi, lancez :

nano livebox.sh

puis collez l’intégralité du script. Changez alors le mot de passe à la fin de la seconde ligne, puis sauvegardez par CTRL O. Rendons maintenant le script exécutable :

chmod +x livebox.sh

et allons éditer crontab pour exécuter le script tous les jours à 4 h du matin :

crontab -e

ajoutez la ligne :

00 04 * * * sudo sh /home/pi/livebox.sh &> /dev/null

et sauvegardez.

Et voilà, avec un peu de bricolage certes, on peut espérer que votre box profitera d’une stabilité accrue, en attendant une mise à jour du firmware.livebox play

 

Raspberry Pi 2 domotique : commande via trames TCP (10)

On en a peu parlé ces dernières semaines, mais le développement du Raspberry Pi domotique se poursuit, un peu plus lentement car les journées ne durent que 24h sur notre bonne vielle Terre 😉

Le script de gestion a été totalement revu :

  • utilisation de fonctions, appelées uniquement en cas de besoin (détection trame radio / rfid / TCP)
  • script de réception des trames tcp désormais en tâche de fond, avec lecture du code dans un simple tcp.txt
  • optimisation du code Python3
  • ajout des développements futurs, basés sur les ESP8266 essentiellement

Voyons ici l’évolution de la partie TCP, celle qui reçoit des trames avec un script enregistré dans tcpserv.py :

import socket, os, sys
# Activation serveur TCP
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.close()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# On affecte IP de reception et port d ecoute
server_address = ('192.168.1.124', 5665)
sock.bind(server_address)
# Ecoute des trames entrantes
sock.listen(1)
while True:
    # Attente connexion
    connection, client_address = sock.accept()
    try:
        while True:
            #
            # on ecrit la trame recue dans tcp.txt
            #
            data = connection.recv(16)
            tcp = open('/home/pi/tcp.txt', 'w')
            tcp.write(str(data, encoding='utf8'))
            tcp.close()
            if data:

               break
    finally:
        # Fermeture connexion
        connection.close()

 

Lancez ce script en tâche de fond avec python3 tcpserv.py & et si vous voulez l’avoir dès le démarrage du Raspberry Pi, allez l’ajouter dans /etc/rc.local :

sudo python3 /home/pi/tcpserv.py &

Désormais, CHAQUE trame reçue sur le port 5665, à destination de l’adresse IP 192.168.1.124 (à modifier par celle de votre Pi), sera écrite dans le fichier tcp.txt. Il ne vous reste alors plus qu’à venir lire ce fichier dans votre script python3, et à en tirer des actions.

Dans notre cas, nous testons simplement le contenu de tcp.txt :

  if len(tcp) > 2:
    print(tcp)
    print("appel lecture TCP")
    tcpframe(tcp)
    continue

En plus clair, si, après l’avoir ouvert et lu, tcp.txt contient plus de 2 caractères, alors on appelle la fonction tcpframe(tcp) pour que le contenu soit analysé, une fonction dont voici un exemple :

def tcpframe(code):
  if "porte1" in code:
    print("porte 1 ouverte")
  if "porte2" in code:
    print("porte 2 ouverte")
  if "porte3" in code:
    print("porte 3 ouverte")

  os.system("echo 0 > /home/pi/tcp.txt")

A la fin de l’interprétation de la trame TCP reçue, on efface tout dans tcp.txt, en lui mettant un simple « 0 » (zéro).

Vous suivez à peu près jusqu’à présent ? 🙂

—————————————————

Voyons maintenant comment envoyer simplement des trames TCP, via une application Android (désolé, je ne suis pas utilisateur d’iOS fermé lol), UDP TCP SERVER. Une fois installée, vous allez pouvoir configurer des tas de boutons :

udptcp_raspberry

Dans cet exemple, si je presse SALON ON, une trame salonon est envoyée sur le port 5665, vers mon Raspberry Pi 192.168.1.124, qui va alors allumer le salon en lançant la bonne commande. Idem pour l’Alarme, que j’active et désactive à volonté.

Ma prochaine étape sera alors de venir programmer des ESP8266 pour, là encore, utiliser l’envoi de trames TCP : ouverture de porte, température, etc. A suivre donc…