Accéder au contenu principal

ESP8266 - Contrôle de prises X10 en Lua

Dans le billet précédent, j'ai indiqué comment piloter des prises Chacon en RF433. Dans ce billet, je vais montrer comment faire de même avec des prises X10.
Les prises X10 sont apparues il y a maintenant 40 ans (en 1975) et permettent de piloter des prises de courant par courant porteur. Le courant porteur signifie que les prises secondaires reçoivent les commandes à travers les fils électriques. Il faut cependant une prise principale qui reçoit les commandes d'allumage ou d'extinction des prises venant d'une télécommande Radio ou Infrarouge pour les transformées en courant porteur. On retrouve aujourd'hui cette technologie à beaucoup plus haute vitesse dans les modems CPL tels que ceux utilisés par Free par exemple.
Module AM12 (On/Off)
Je me suis intéressé au protocole X10 il y a une vingtaine d'années lorsque Thomson a décidé de se retirer du marché. Je me suis ainsi équipé d'un convertisseur radio TM13, de quelques prises AM12 (on/off), d'une prise variateur LM12, d'une télécommande 8 en 1 infrarouge et radio, d'une douille X10, d'un adaptateur CM11F pour pouvoir envoyer des commandes depuis un PC. Ce système m'a apporté entière satisfaction pendant plusieurs années. Je m'en suis peu à peu éloigné après avoir retrouvé ma famille plongée dans le noir pour n'avoir pas réussi à allumer les prise, à cause de parasites provoqués par l'alimentation à découpage d'un ordinateur portable. 

 Module LM12 (variateur)


Comme les prises Chacon, chaque prise à un code House (de A à P) et un code Unit (de 1 à 16). On peut donc gérer jusqu'à 256 prises. Cependant, avec une même télécommande configurée pour un code maison, on ne peut réellement n'en gérer que 16. Le code House permet de différencier des maisons situées dans le même entourage et d'éviter que votre voisin éteigne volontairement ou non vos lumières.
Convertisseur TM13 radio/CPL
 
Avec l'arrivée des smartphones, des micro-contrôleurs et du Wifi Low cost (ESP8266), l'occasion était trop belle de ressortir mes vieux "jouets" du papier bulle dans lequel je les avaient emballés. Il était temps de réussir à les piloter depuis un PC, un smartphone ou une tablette.

Le protocole Radio

Le convertisseur Radio utilise la fréquence radio 433 Mhz qui est la même que celle utilisée par les prises Chacon. Ayant déjà réussi à émettre sur cette fréquence, il ne me restait donc plus qu'à identifier les données à émettre et à les envoyer. J'ai dû chercher un peu sur le net avant de trouver quelques informations et de faire quelques essais avant de bien comprendre comment ce protocole fonctionne. Les 2 sites suivants m'ont été d'un très grand secours : 
Le premier lien décrit précisément le protocole RF X10 qui s'inspire complètement du protocole InfraRouge des télécommandes Nec. C'est un peu barbare à vu d’œil, mais je vais détailler un peu.
Protocole NEC IR

Il manque cependant sur cette image une première séquence de blanc qui dure 28ms. 
J'utiliserai les termes H lorsque le signal est en Haut et B lorsque le signal est Bas.
Le protocole X10 est donc codé sur 32 bits avec 3 bits de préambule :
Préambule
B - pendant 27 000 us (27 ms)
H - pendant 9 000 us (9 ms)
B - pendant 4 500 us (4,5 ms)
Code House sur 27 000 us
8 bits pour le code House (ex: 01100000)
8 bits pour le complémentaire du code House (ex: 10011111)
Code Unit sur 27 000 us
8 bits pour le code Unit (ex: 00000000)
8 bits pour le complémentaire du code Unit (ex: 11111111)
Fin
H - bit de fin pendant 560 us

Ce protocole est un peu plus complexe que celui du Chacon. Le fait d'envoyer un code et son complémentaire permet d'avoir des trames de longueur identiques et également de vérifier qu'il n'y a pas d'erreur au moment du décodage.
Les données sont envoyées de la manière suivante :

 

Le programme Lua pour envoyer une telle séquence est le suivant.

  0 = H pendant 560 ms, B pendant 560 ms  
            _    
 Waveform: | |__  
 1 = H pendant 560 ms, B pendant 1600 ms  
            _    
 Waveform: | |_____   

 counts = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0}  
   
 waitus = tmr.delay  
   
 HouseB = {A=0x60, B=0x70, C=0x40, D=0x50, E=0x80, F=0x90, G=0xA0, H=0xB0, I=0xE0, J=0xF0, K=0xC0, L=0xD0, M=0x00, N=0x10, O=0x20, P=0x30}  
   
 UnitB={0x00, 0x10, 0x08, 0x18, 0x40, 0x50, 0x48, 0x58}  
   
 ht = {0, 0, 0, 0, 0, 0, 0, 0}  
 ut = {0, 0, 0, 0, 0, 0, 0, 0}   
   
 function intToBits(code, tab)  
  val = code   
  for i = 1, 8 do  
   b = bit.band(val, 0x80)  
   val = bit.lshift(val, 1)  
   tab[i] = (b == 0x80) and 1 or 0   
  end  
 end  
   
 function transmit(pin, tab, n, highOrLow, rep)  
   print("Transmit "..n)  
   start = highOrLow  
   for r = 1, rep do    
    for i=1, n do  
     gpio.write(pin, start)  
     waitus(tab[i])  
     start = (start + 1)%2  
    end  
    tmr.wdclr()   
   end  
 end  
   
 function buildX10Bits(pin, house, unit, sup, on)  
  SHORT = 560  
  LONG = 1100  
   
  -- Lock sequence  
  counts[1] = 28000  
  counts[2] = 8000  
  counts[3] = 4500  
   
  -- House Code and the complementary  
  start = 3  
  startc = 3 + 8*2  
  for i=1, 8 do  
   counts[start + (i*2)-1] = SHORT  
   counts[start + (i*2)]  = house[i]*LONG + SHORT  
      
   comp = (house[i] == 1) and 0 or 1  
   counts[startc + (i*2) - 1] = SHORT   
   counts[startc + (i*2)] = comp*LONG + SHORT  
  end  
    
  -- Unit code and the complementary  
  start = 3 + 8*2 + 8*2  
  startc = 3 + 8*2 + 8*2 + 8*2   
  for i=1, 8 do  
   counts[start + (i*2)-1] = SHORT  
   counts[start + (i*2)]  = unit[i]*LONG + SHORT  
      
   comp = (unit[i] == 1) and 0 or 1  
   counts[startc + (i*2) - 1] = SHORT   
   counts[startc + (i*2)] = comp*LONG + SHORT  
  end  
  counts[start + (3*2)-1] = SHORT  
  counts[start + (3*2)] = (on and 0 or 1)*LONG + SHORT  
  counts[startc + (3*2)-1] = SHORT  
  counts[startc + (3*2)] = (on and 1 or 0)*LONG + SHORT  
    
  counts[4*8*2 + 3 + 1] = SHORT  
  counts[4*8*2 + 3 + 2] = SHORT  
    
  transmit(pin, counts, 4*8*2 + 5, 0, 10)  
 end  
   
 function sendX10(pin, code, on)  
  h = string.sub(code, 1, 1)  
  u = tonumber(string.sub(code, 2))  
  sup = (u > 8) and true or false  
  intToBits(HouseB[h], ht)  
  intToBits(UnitB[u], ut)  
  buildX10Bits(pin, ht, ut, sup, on)  
 end  

Vous remarquerez que l'on ne gère que 8 codes Units. Pour les codes Units de 9 à 16 il faut mettre le bit 2 du code Maison à 1.

Pour allumer la lampe 1, il faudra envoyer les commandes suivantes :
 gpio.mode(7,gpio.INPUT,gpio.FLOAT)  
 sendX10(7, "A1", true) -- Pour allumer la lampe  
 sendX10(7, "A1", false) -- Pour éteindre la lampe  

Commentaires

Posts les plus consultés de ce blog

Utilisez votre tablette Android comme second écran pour Linux (Raspberry Pi, MK908II)

Les tablettes Android atteignent désormais des prix qui défient toute concurrence. On trouve désormais des modèles à 39 € TTC en super marché, soit à peine plus cher que le Raspberry PI, mais avec un écran. Ces modèles souvent mono-core 1Ghz ou 1,4 Ghz avec 512 ou 1Go de mémoire ne sont très probablement pas utilisables pour une utilisation régulière sur Internet et ne sont en aucun point comparables à leur équivalent de marque (Samsung, Sony, LG, HTC, Lenovo, etc). Plusieurs tutoriels indiquent comment connecter utiliser une tablette Android comme second écran ( http://www.linux-magazine.com/Online/Blogs/Productivity-Sauce/Use-an-Android-Device-as-Screen-and-Input-for-Raspberry-Pi ). Ces méthodes utilisent généralement l'USB Tethering qui n'est malheureusement disponible que sur les téléphones ou tablettes avec un accès mobile (3G ou 4G) inclus. Dans ce billet, je vais vous montrer comment se connecter à une tablette en utilisant le mode Debug adb (Android Debug Bridge

Supprimer les partitions Raspberry sur une carte SD sous Windows avec Diskpart

Si vous souhaitez récupérer une ancienne carte SD utilisée pour démarrer un Raspberry pour un autre usage (appareil photo, etc), il vous faudra supprimer les deux partitions créées au moment de l'écriture de l'image sur la carte SD. Vous pouvez voir les partition en sélectionnant Menu Windows/Ordinateur/bouton droit "Gérer". Voici un exemple du résultat final. Vous pouvez supprimer la partition Unix de 7 Gb (ou 4Gb en fonction de la taille de votre carte) en sélectionnant la partition puis en faisant "bouton droit Supprimer". Laissez juste une partition pour pouvoir faire les autres manipulations avec DISKPART. Démarrez l'outil DISKPART en ligne de commande. Une nouvelle fenêtre s'ouvrira. Microsoft DiskPart version 6.1.7601 Copyright (C) 1999-2008 Microsoft Corporation. DISKPART> list disk   N° disque  Statut         Taille   Libre    Dyn  GPT   ---------  -------------  -------  -------  ---  ---   Disque 0    En ligne        238 G octe

Emulateur Raspberry Pi sous Windows

Si vous souhaitez développer ou tester des applications pour Raspberry Pi, vous pouvez, soit compiler directement l'application sur Raspberry, soit la développer sous Linux ou Windows et la compiler pour Raspberry. La seconde solution est souvent plus simple car elle permet de disposer d'un environnement de compilation complet tel qu'Eclipse pour le développement. Une fois l'application développée, il faut la tester sur Raspberry. Là, il faut copier l'application en utilisant un client FTP ou SCP, puis se connecter en SSH et lancer l'exécutable. Il existe un autre moyen de tester une application Raspberry sans avoir à l'allumer. Il suffit de passer par un émulateur tel que QEMU qui permet de lancer un OS pour processeur ARM sous Linux ou Windows. L'émulateur sous Windows 1. Récupérez l'émulateur à l'adresse suivante : http://sourceforge.net/projects/rpi-emulator-win32/ . 2. Dézippés le contenu de l'image Rpi-Occidentalis-v02-qemu.7z av