Archives par étiquette : GPiO

X96 : ajoutez des GPIO avec un FT232H

Le X96 est certes une solution super sympa pour réaliser un p’tit serveur linux, des applications domotiques, mais si vous avez besoin d’interfacer un peu plus de choses, pourquoi ne pas ajouter une extension GPIO ? En clair, des entrées et des sorties configurables et activables à volonté, sur un port série, à l’aide d’un module FT232H.

Pour le moment, ne branchez pas votre FT232H. Nous allons créer un fichier :

nano /etc/udev/rules.d/11-ftdi.rules

et nous venons y placer ce qui suit :

SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6001", GROUP="plugdev", MODE="0666"
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6011", GROUP="plugdev", MODE="0666"
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6010", GROUP="plugdev", MODE="0666"
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6014", GROUP="plugdev", MODE="0666"
SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6015", GROUP="plugdev", MODE="0666"

Sauvegardez avec un CTRL-O, puis CTRL-X pour sortir. La règle se mettra en place une fois le FT232H branché.

Installons maintenant les différents modules nécessaires :

pip3 install pyftdi
pip3 install adafruit-blinka

et positionnons la variable d’environnement :

export BLINKA_FT232H=1

Branchez le FT232H sur l’un des ports USB et vérifions qu’il soit bien reconnu :

Python3
from pyftdi.ftdi import Ftdi
Ftdi().open_from_url('ftdi:///?')

Le résultat doit montrer la détection du module USB :

Available interfaces: 
 ftdi://ftdi:232h:1:2/1   (Single RS232-HS)

Relançons de nouveau python3 puis demandons :

import os
os.environ["BLINKA_FT232H"]

La réponse sera 1 si tout est correctement configuré.

Nous allons pouvoir créer le fichier blink.py :

import time 
import board 
import digitalio 

led = digitalio.DigitalInOut(board.C0) 
led.direction = digitalio.Direction.OUTPUT 

while True: 
   led.value = True 
   time.sleep(0.5) 
   led.value = False 
   time.sleep(0.5)

Venez relier une LED entre la masse GND et le port AC0 du FT232H, en prenant soin d’insérer une résistance d’1 kOhm en série sur la ligne + de la LED :

Exécutez le script Python :

python3 blink.py

et voici logiquement votre LED qui clignote ! Votre premier test sur le GPIO USB est terminé, à très vite pour des billets plus poussés sur le sujet 😉

Domoticz : relais KS0212

La petite carte 4 relais dont nous avons parlé dans le précédent billet s’interface fort bien avec Domoticz.

Il vous faudra par contre éditer /etc/init.d/domoticz.sh et ajouter :

# Configuration GPIO
/usr/bin/gpio export 4 out
/usr/bin/gpio export 22 out
/usr/bin/gpio export 6 out
/usr/bin/gpio export 26 out
/usr/bin gpio exports

puis redémarrer le Raspberry Pi.
Le premier relai sera sur le GPiO 4, le second 22, puis 6, et finalement 26.

Dans Setup, Hardware, créez un GPIO comme suit :

Vous allez alors pouvoir créer manuellement vos switches en y associant le GPIO voulu, 4, 6, 22, ou 26. Pensez à le tester en cas de doute :

Au final, tous vos GPIO seront présents sur le tableau de bord Domoticz :

ESP8266 ESP12 : map des ports GPIO

Il n’est pas toujours aisé d’associer les ports GPIO physiques d’un ESP12 à la valeur à utiliser en programmation d’un script LuA. Voici le brochage d’un ESP12 :

et voici les correspondances que j’ai pu trouver, du moins pour les GPIO utilisables sur ce module :

PORT PHYSIQUE GPIO	PORT SCRIPT LUA
0	3
2	4
4	2
5	1
12	6
13	7
14	5
15	8
16	0

Par exemple, si vous branchez une LED sur le GPIO15 (broche +) et sur la masse (GND), via une résistance de 2k2, vous pouvez utiliser ce script LuA pour la faire clignoter :

gpio.mode(8, gpio.OUTPUT)
gpio.write(8, gpio.LOW)
for i = 1, 4 do
 gpio.write(8, gpio.HIGH)
 tmr.delay(100000)
 gpio.write(8, gpio.LOW)
 tmr.delay(100000)
end

Si vous utilisez la broche GPIO4, dans le script vous remplacerez 8 par 2 :

gpio.mode(2, gpio.OUTPUT)
gpio.write(2, gpio.LOW)
for i = 1, 4 do
 gpio.write(2, gpio.HIGH)
 tmr.delay(100000)
 gpio.write(2, gpio.LOW)
 tmr.delay(100000)
end

Simple non ?

ESP-12 : présentation

Suite de la série des essais avec l’ESP8266, cette fois-ci avec l’ESP-12, toujours plus petit :

ESP-12

On peut difficilement faire plus petit, enfin si, mais pas avec autant de GPiO intégrés, 9 au total, donc 8 utilisables si j’ai bien suivi.

On peut soit envisager de se relier directement, soit utilisé le kit commandé en Asie, avec une platine sur laquelle vous allez souder l’ESP12 et venir ajouter des connecteurs « à taille humaine » pour vos branchements ultérieurs :

Kit ESP-12

Perception de la loupe, et en avant la soudure, avec patience et douceur. Quelques minutes plus tard, voici la bestiole raccordé dignement :

Vous noterez l’antenne WiFi stripline sur le haut du module, et une petite LED cms chargée de vous donner quelques indications de fonctionnement.

Reste désormais à tester, sans doute avec NodeMCU, mais ce sera l’objet d’un prochain billet.

ESP8266 : GPiO « HIGH » au démarrage, la solution

Nombre de messages sur les forums font état de niveaux hauts (HIGH) sur les ports GPiO des ESP8266, conduisant à des situations pas forcément enviables si vous y avez raccordé des relais. En clair, vous vous retrouvez avec du 3,3 Vcc sur chaque broche de GPIO un fois l’ESP8266 sous tension. Bien entendu, on peut venir rétablir la situation avec un init.lua qui commandera aux ports de se couper, mais vous aurez toujours une demi seconde d’activation, cela ne changera rien.

Sur ce billet, nous avons vu comment commander un relai, au moyen d’un transistor 2N2222 et quelques résistances :

Nous allons y ajouter un inverseur, toujours avec un 2N2222 :

Branchez le GPiO sur IN, puis la commande du relai (schéma au début du billet) sur OUT. Vous enchainez donc deux montages à base de 2N2222. Pour activer le relai, il faudra valider un port sur LOW et non HIGH : 0 V sur le GPiO => relai activé ! Simple non ?

On peut envisager un montage avec un circui intégré inverseur, plus compact, mais pour juste un ou deux relais, l’intérêt est peu évident. Les bricoleurs pourront réaliser une platine avec l’inverseur et le 2N2222, tout ça en CMS : compact, simple, mais nécessitant un peu de matériel pour produire le montage.

ESP8266, Nodemcu, Lua : commande de relais via trames UDP

Suite des essais avec l’ESP8266 déjà présenté sur Blogwifi, associé désormais à une platine munie de 2 relais :

J’ai relié l’un des deux relais de la platine via un transistor 2N2222, branché comme suit :

Vue la petite taille, tout a été soudé en l’air sur la platine relai comme vous pouvez le voir en détail ci-dessous :

Les différents fils sont :

Rouge : +5Vcc (en bas à gauche de l’ESP8266)
Bleu : GND (en bas à gauche de l’ESP8266)
Vert : GPiO3 (broche D3 de la platine en haut à droite)

Le brochage de la platine de démonstration ESP8266 est le suivant :

Oui, la broche D3 correspond à GPIO4 alors que je vous parle du 3 dans le billet. En fait, il faut toujours considérer le GPIOxx avec xx comme étant Dxx. Par exemple, GPIO5 sera la broche D5, GPIO4 la broche D4, etc. J’ai passé plusieurs heures à chercher sur ce détail plutôt agaçant 🙂

Et voici le script LUA que vous allez pouvoir utiliser pour envoyer EXTON ou EXTOFF via une trame UDP sur le port 5000 :

wifi.sta.config("mon_reseau_wifi","password")
wifi.sta.connect()
tmr.delay(1000000)
print(wifi.sta.getip())
gpio.mode(3, gpio.OUTPUT)
port=5000
srv=net.createServer(net.UDP)
srv:on("receive", function(srv, pl)
   print("Commande recue")
   print(pl)
   if pl=="EXTON\n" then gpio.write(3, gpio.HIGH)  end
   if pl=="EXTOFF\n" then gpio.write(3, gpio.LOW) end
   end)
srv:listen(port)

Insérez bien entendu les paramètres de votre propre réseau WiFi sur la toute première ligne.

Désormais, envoyez EXTON et le relai collera. EXTOFF et le relai se coupera.

Un détail toutefois : les GPIO sont activés (+ 3.3 Vcc) systématiquement au redémarrage. Résultat, le relai colle ! Il faut donc prévoir un script qui se lance tout seul et ira remettre à zero les GPIO utilisés. Pensez-y, sinon surprise 😉

Raspberry Pi 2 domotique : GPiO et interrupteur (4)

Le montage étant terminé, il est temps de venir tester les entrées de notre Raspberry Pi 2, à commencer par celle servant à activer/désactiver l’alarme. Si vous avez déjà un peu pratiqué l’utilisation d’interrupteurs sur des ports GPiO, vous avez sans doute remarqué que, laissé libre (sans connexion), le port GPiO a tendance à envoyer des 1 ou des 0 de façon un peu aléatoire, pas pratique donc pour notre projet.

La solution ? Venir câbler deux résistances comme ceci :

Ainsi, lors de la fermeture et l’ouverture de votre switch, plus de phénomènes bizarres, les 0 et les 1 sont nets, précis.

Sortons le fer à souder, et réalisons notre montage en gagnant un maximum de place :

Avec un bout de gaine thermo-rétractable, nous obtenons alors un ensemble facile à intégrer sur notre projet :

Maintenant, il ne nous reste plus qu’à patienter jusqu’à la livraison de la platine de contrôle d’accès, sans doute une petite dizaine de jours encore. Une fois livrée, nous allons vérifier le type d’impulsion qu’elle délivre lorsqu’un badge RFID est reconnu, puis nous l’interfacerons avec le logiciel de gestion de l’alarme, en Python 3.

Blog WiFi / 3G / 4G / Hotspots

!! Le spécialiste du wifi et du sans fil sur un blog !!