ESP8266 et émetteur 433 MHz en LUA pour prise télécommandée Chacon

J'ai déjà réussi, il y a quelques années à allumer des prises télécommandées Chacon en C# avec un Fez Panda II. Le programme peut être récupéré sur le site de GHI Electronics. Une version pour RPi en C++ faite par le même auteur est disponible à l'adresse http://code.google.com/p/rc-switch/source/browse/tags/v0.5/RCSwitch.cpp. Couplé avec un récepteur Bluetooth, cela m'a par exemple permis de tester l'allumage de lumières depuis une tablette.

Le challenge était de faire la même chose avec un ESP8266, en Wifi. Il existe depuis quelques mois un module nommé "rc" (pour Remote Control) dans le firmware de l'ESP8266. Ce module est censé permettre la prise en charge des différents protocoles utilisés par ces prises radiocommandées à 433 MHz en France (ou 315 Mhz au US). Ce module n'est malheureusement pas encore bien documenté et n'est pas encore utilisable pour notre cas. Nous allons voir comment l'implémenter en LUA.

Le principe est d'envoyer une série de codes dépendants du Canal et de l'Adresse de chaque prise. Pour les prises Chacon, le code est composé de 13 valeurs qui se décomposent de la manière suivante:

Un code peut avoir 4 états : "F" (floating), "0" (LOW), "1" (HIGH), "S" (SYNC)
+-----------------------------+-----------------------------+-------+-------+-----------+----------+
| 4 bits adresse              | 4 bits canal                | 1 bit | 1 bit | 2 bits    | 1 bit    |
| Addresse de  la prise       | Canal de la prise           | NU    | NU    | on / off  | SYNC     |
| 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | 1=0FFF 2=F0FF 3=FF0F 4=FFF0 | F     | F     | FF /F0    | S        |
+-----------------------------+-----------------------------+-------+-------+-----------+----------+

Ainsi, pour allumer la lampe d'adresse 1 de canal 1, il faut envoyer la séquence : 0FFF0FFFFFFFS.

La seconde étape consiste à convertir ces valeurs en signaux envoyés à la prise électrique. Dans le cas des prises Chacon, la tempo minimale est de 375 micro secondes (je la noterai T).

Un 0 correspondra à la séquence suivante :
HIGH pendant 1*T , LOW pendant 3*T, HIGH pendant 1*T, LOW pendant 3*T.
  _     _
 | |___| |___

Un 1 (non utilisé dans le cas du Chacon) utilisera la séquence suivante :
HIGH pendant 3*T, LOW pendant 1*T, HIGH pendant 3*T, LOW pendant 1*T.
  ___   ___
 |   |_|   |_

Un F utilisera la séquence suivante :
HIGH pendant 1*T, LOW pendant 3*T, HIGH pendant 3*T, LOW pendant 1*T
  _     ___
 | |___|   |_
Un S utilisera la séquence suivante:
HIGH pendant 1*T, LOW pendant 31*T.
  _
 | |_______________________________

Pour ce montage, j'ai utilisé:
- Un ESP8266 au format XBEE, nommé Wee (4€ chez IteadStudio)

- Un XBee Carrier de SeeedStudio, (15€ chez HackSpark, mais livré avec un petit panneau solaire, une batterie Lipo, inclus un convertisseur USB/Série, un convertisseur de tension 5V-->3,3V et 2 connecteurs Grove)

- Un émetteur RF433 MHz (3 € environ chez IteadStudio, existe également directement en Grove)

- Un prise Grove vers 3 connecteurs femelles
- Des prises Chacon (15€ les 3 dans mon HyperMarché)

Vous pouvez bien évidemment adapter cette liste en fonction des équipements dont vous disposez déjà. Notez également que SeeedStudio va bientôt commercialiser une nouvelle carte nommée Wio Link basée sur un Esp8266 et disposant de 6 connecteurs Grove. Je l'attend avec impatience.

Le programme Lua suit exactement le protocole décrit précédemment.

 local M  
 do  
 -- Using GPIO 7  
 pin = 7  
 Delay=375  
 waitus = tmr.delay  
 local gpio = gpio  
 getCodeWord=function(nAddressCode, nChannelCode, bStatus)  
  code = {"0FFF", "F0FF", "FF0F", "FFF0" }  
  if ((nAddressCode < 1) or (nAddressCode > 4) or (nChannelCode < 1) or (nChannelCode > 4)) then  
    return ""  
  end  
  return code[nAddressCode]..code[nChannelCode].."FF"..((bStatus == true) and "FF" or "F0").."S"  
 end  
 send=function(sCodeWord)  
  s = {'', '', '', '', '', '', '', '', '', '', '', '', ''}  
  for j=1,13 do  
   s[j] = string.sub(sCodeWord, j, j)  
  end  
  for nRepeat = 1, 10 do   
   for i = 1, 13 do  
    if (s[i] == '0') then  
      send0()  
    elseif ((s[i] == 'F')) then  
      sendF()  
    elseif ((s[i] == 'S')) then  
      sendSync()  
    end  
   end  
  end  
 end  
 --  
 -- Sends a "0" Bit  
 -- Waveform: | |___| |___  
 --  
 send0=function()  
  gpio.write(pin, gpio.HIGH)  
  waitus(Delay * 1)  
  gpio.write(pin, gpio.LOW)  
  waitus(Delay * 3)  
  gpio.write(pin, gpio.HIGH)  
  waitus(Delay * 1)  
  gpio.write(pin, gpio.LOW)  
  waitus(Delay * 3)  
 end  
 --  
 -- Sends a "F" Bit  
 --      _   ___  
 -- Waveform: | |___|  |_  
 --  
 sendF=function()  
  gpio.write(pin, gpio.HIGH)  
  waitus(Delay * 1)  
  gpio.write(pin, gpio.LOW)  
  waitus(Delay * 3)  
  gpio.write(pin, gpio.HIGH)  
  waitus(Delay * 3)  
  gpio.write(pin, gpio.LOW)  
  waitus(Delay * 1)  
 end  
 --  
 -- Sends a "S" Bit  
 --      _   
 -- Waveform: | |_______________________________  
 --  
 sendSync=function()  
  gpio.write(pin, gpio.HIGH)  
  waitus(Delay * 1)  
  gpio.write(pin, gpio.LOW)  
  waitus(Delay * 31)  
 end  
 local switchOn=function(nAddressCode, nChannelCode)  
  s = getCodeWord(nAddressCode, nChannelCode, true)  
  print("Switch On "..s)  
  send(s)  
 end  
 local switchOff=function(nAddressCode, nChannelCode)  
  s = getCodeWord(nAddressCode, nChannelCode, false)  
  print("Switch Off "..s)  
  send(s)  
 end  
 M = {  
  switchOn = switchOn,  
  switchOff = switchOff,  
 }  
 end  
 return M  

Enregistrez le dans un fichier RF433.lua par exemple et chargez le dans l'ESP8266 avec LuaLoader ou tout autre outil. Compilez le pour gagner en place et en vitesse.
L'utilisation est très simple :

 gpio.mode(7, gpio.OUTPUT)  -- Changez le pour GPIO si besoin
 rf433=require("RF433")  
 rf433.switchOn(1, 1)   -- Allume la prise
 rf433.switchOff(1, 1)  -- Eteint la prise

Pour d'autres prises, il vous faudra probablement adapter le programme et notamment jouer avec la variable Delay.

Je parlerai de la partie Wifi un peu plus tard. Mais il y a déjà là de quoi s'amuser un peu.