Domotique

Toutes mes applications de domotique sont liées les unes aux autres par un protocole de communication radio. J’ai regroupé l’ensemble sous le titre « Home Supervisor » dans cette section.

L’objectif est la mise en place d’un protocole de communication radio à usage domotique. Il doit être simple et ouvert, de manière à pouvoir intégrer facilement de nouveau composants.

Il s’agit d’une communication numérique radio de porteuse 433 MHz. Chaque bit est persistant pendant 1,024 ms, soit une fréquence de 976,5625 Hz par bit, soit 122 Hz par octet. Cette période peu banale est en fait très facilement mesurable car elle va pouvoir correspondre à un débordement de Timer sur 8 bit moyennant un prescaller, ce qui va faciliter grandement le codage des logiciels et la fiabilité des transmission.

Lorsque aucune transmission n’a lieu, le récepteur radio reçoit une succession de 0.

Un récepteur possède une adresse. Lorsqu'il reçoit son adresse, il se met en attente d’une instruction lui permettant de changer son état.

Les adresses des récepteurs sont codées sur 8 bits et varient de 0x01 à 0x7E.
L’adresse 0x00 est interdite.
L’adresse 0x7F est utilisée pour lancer des commandes en broadcast.

Voici le prototype d’une trame :

Chaque octet utile est précédé d’un octet de synchronisation (S) valant 0x01. Cet octet à pour but de permettre au récepteur de se recaler sur l’émetteur au cas où les horloges ne seraient pas exactement les mêmes. A la fin des instructions, en cas de perturbation qui gênerait la lecture de l’état de repos, les récepteurs ignoreront toutes données jusqu’à réception d’une succession d’au moins 8 uns témoignant du commencement d’une nouvelle transmission. Par sécurité, l’émetteur enverra deux séries de 0xFF.
Les octets sont envoyés en commençant par le bit de poids fort.
L’adresse commence toujours par un zéro, de manière à ce qu’aucune donnée ne puisse avoir la valeur 0xFF, valeur réservée au début de transmission.

Les codes des instructions occupent 1 octet.

Cette instruction permet de demander au récepteur de rétablir l’alimentation secteur.

• Adresse : adresse actuelle du récepteur
• 0x01 : code de l’instruction

Cette instruction permet de demander au récepteur de couper l’alimentation secteur.

• Adresse : adresse actuelle du récepteur
• 0x02 : code de l’instruction

L’objectif de cette brique est d’encapsuler l’utilisation de la radio. Elle devra fournir des primitives de haut niveaux correspondant aux diverses instructions radio :

void RADIO_ActiveState(unsigned char Slave);
void RADIO_InactiveState(unsigned char Slave);

La brique aura besoin d’un timer. Nous utiliserons le Timer 0 commun à tous les PIC. On tâchera de faire fonctionner le microcontrôleur avec un quartz de 4MHz, soit 1 MIPS. Ce timer 8 bits, prescallé à 4, fournira alors une interruption toutes les 1,024 ms, ce qui permettra de cadencer l’envoi des bits.

La conception USDP en langage UML a été faite. Le schéma ci-dessous présente le diagramme statique de classes issu de cette conception :

J’ai réalisé un logiciel extrêmement simple pour valider la brique. Il tourne sur un PIC 12F629.

Le microcontrôleur est cadencé par son quartz interne de 4 MHz. Deux broches seront utilisées comme sortie pour les deux sorties radio (data et alimentation). 2 broches sont utilisées en entrée.

Au démarrage, le soft regarde l’état des broches d’entrée. Suivant l’état de ces broches, le soft fait un appel à l’une des 2 primitives de la brique radio.

L’objectif de cette brique est d’encapsuler l’utilisation de la radio.

La brique aura une primitive d’entrée :

RADIO_EVENT RADIO_Reception(unsigned char Address) ;

La brique aura besoin d’un timer. Nous utiliserons le Timer 0 commun à tous les PIC. On tâchera de faire fonctionner le microcontrôleur avec un quartz de 4MHz, soit 1 MIPS. Ce timer 8 bits, prescallé à 4, fournira alors une interruption toutes les 1,024 ms, ce qui permettra de cadencer l’envoi des bits.

Lors des phases de synchronisation, il prescallera le Timer 0 sur 32 de manière à avoir une interruption tous les octets.

Par sécurité, chaque bit sera lu 5 fois. La brique ne validera un bit que si les 5 lectures sont identiques.

La conception USDP en langage UML a été faite. Le schéma ci-dessous présente le diagramme statique de classes issu de cette conception :

Pour utiliser la brique, il faut appeler la méthode RADIO_Reception(), en passant en paramètre l’adresse du récepteur. La brique renvoi l’instruction qui a été reçue, ou RADIO_EVENT_VOID si la trame n’était pas pour cette adresse ou en cas d’erreur.

Créer un logiciel pour permettre la validation de la brique revient à concevoir un récepteur. En conséquence, la validation de la brique se fera en même temps que celle du premier récepteur.

Un Commander est une radiocommande locale permettant de piloter jusqu’à 4 récepteurs.

4 adresses sont mémorisées, l’adresse de broadcast 0x7F pouvant être l’une de ces adresses, de même que l’adresse de sortie d’usine 0x00, de sorte que le commander n’a pas à faire de vérification concernant la validité des adresses.

Un commander peut piloter soit un seul des récepteurs, soit l’ensemble des 4 récepteurs mémorisés simultanément.
Les adresses sont stockées en dur dans le commander. Toutefois, il faudra prévoir de pouvoir les mettre à jour facilement via reprogrammation. Cette fonctionnalité ne dois pas être accessible à l’utilisateur.

Un commander possède 3 boutons poussoirs :

• Activer : ce bouton vert permet de lancer la commande d’activation aux récepteurs présélectionnés.
• Désactiver : ce bouton rouge permet de lancer la commande de désactivation aux récepteurs présélectionnés.
• Sélection : ce bouton noir ou blanc permet de présélectionner le ou les récepteurs à piloter.

Un commander possède 4 LED rouge permettant de visualiser quels sont les récepteurs à piloter :

• 1 seule LED allumée : 1 seul récepteur présélectionné.
• Toutes les LED allumées : tous les récepteurs présélectionnés.

Lorsque l’utilisateur appui sur l’un des boutons, ceci provoque la mise en route du commander. Par défaut, à chaque démarrage, c’est la première adresse qui est sélectionnée.

Si la première touche pressée est :

• Activer : La première LED s’allume, et la commande est immédiatement envoyée à la première adresse.
• Désactiver : La première LED s’allume, et la commande est immédiatement envoyée à la première adresse.
• Sélection : La deuxième qui s’allume pour présélectionner le second slave.

En cas d’appuis simultanées, des boutons, les ordres de priorité sont : Désactiver, Activer, Sélection.
Aucun appui n’est pris en compte si le précédent bouton n’a pas été relâché.

Si dans une limite de 4 secondes, aucune action n’est effectuée, le commander s’arrête. Ce compte à rebours de 4 secondes est lancé dès le lâché du dernier bouton pressé.

Si dans une limite de 4 secondes, un autre bouton est pressé, il est traité et un nouveau compte à rebours de 4 secondes est initié, et ainsi de suite jusqu’à ce qu’aucun bouton ne soit plus actionné.

Le module d’émission radio sera un module Aurel TX-SAW 433. Il s’alimente en 12V, et se commande avec un signal TTL.

En conséquence, la source d’alimentation sera une petite pile de 12V. Etant donnée sa petite capacité, il faudra que l’ensemble du montage ne soit pas du tout alimenté au repos. Ce sont les boutons qui provoqueront la mise sous tension.
Le circuit radio, bien qu’alimenté directement en 12V, se pilote avec un signal TTL. Il faudra donc un régulateur 5V.

Le Commander sera géré par un microcontrôleur PIC. C’est lui qui commandera l’ensemble des composants du montage.

Dressons l’inventaire des ressources nécessaires concernant le microcontrôleur :

• 4 sorties pour les LED
• 1 sortie pour la communication avec le module radio
• 1 sortie pour piloter l’alimentation du module radio
• 1 sortie pour piloter l’auto alimentation du montage après le lâché des boutons.
• 3 entrées pour les boutons poussoirs

Soit un total de 7 sorties et 3 entrées.

Le microcontrôleur doit en outre pouvoir mémoriser de façon non volatile les 4 adresses. Cependant elles doivent pouvoir être modifiées par programmation. On préconisera de la mémoire de type EEPROM. Il faudra 4 octets pour mémoriser les 4 adresses.

Notre choix se portera sur le PIC 16F628A.

Voici le schéma complet du Commander :

RAPPEL1 et RAPPEL2 sont deux résistances permettant d’accélérer la chute des tensions d’alimentation après coupure des transistors PNP.

• 1 Pile 12V GP23 + Coupleur à fil
• 1 module radio AUREL AC-RX 433 + support barrette 15 contacts
• 3 boutons poussoirs (1 bleu ou vert, 1 rouge, 1 noir)
• 2 Transistors BC547
• 3 Transistors BC557
• 4 LED rouges
• 1 PIC 16F628A + support DIL18
• 2 Résistances 10 kOhm ¼ W
• 5 Résistances 330 Ohm ¼ W
• 2 Résistances 560 Ohm ¼ W
• 5 Résistances 1 MOhm ¼ W
• 1 Régulateur 7805
• 1 Condensateur papier 330 nF
• 2 Condensateur papier 100 nF
• 3 diodes Zener 5,1V
• 1 fil d’antenne de 15 cm
• 4 straps

Voici le layout complet du système (vue côté composants) :

Voici le brochage du pic 16F628A :

Remarque : toutes les broches « - » seront paramétrées en entrée, et reliées à VSS.

C’est forcément un appui sur l’un des boutons qui provoque la mise sous tension du microcontrôleur. La première chose à faire est le maintient de l’auto alimentation. Ensuite, il faut procéder à la lecture du bouton, en sachant qu’un filtrage est peut-être nécessaire. Le plus simple est d’attendre 10ms après le déclenchement de l’auto maintient de l’alimentation.

4 adresses de 1 octet chacune (Adresses 0x00 à 0x03) sont à stoker en mémoire EEPROM.

Deux temps doivent pouvoirs être mesurés : 10 ms et 4 secondes.
Sachant que le microcontrôleur est cadencé à 1 MIPS, 8 débordements du Timer 1 prescallé sur 8 correspondent à 4,2 secondes. Etant donné que l’on se fiche de la précision de ce compteur de 4 secondes, cela ira très bien.
Quant à 10 ms, on utilisera le Timer 2 prescallé sur 16, et on comptera ses débordements. En conséquence, on fera un appel synchrone qui ajoutera 1250 à la valeur dur Timer 1, et attendra que ce dernier atteigne cette valeur.

La fonction principale main fonctionnera comme une tâche d’OS. Un octet sera utilisé en flags pour matérialiser l’arrivée des messages asynchrones sur la tâche.

Voici l’inventaire de ces flags :

• 0b00000001 : Fin de timeout 4 secondes

Les boutons seront détectés par scrutation. Nous aurons par contre à utiliser l’interruption débordement de Timer 1 pour la mesure des 4 secondes.
La brique d’émission radio utilise enfin l’interruption Timer 0.

La conception USDP en langage UML a été faite. Les 2 schémas ci-dessous présentent les diagrammes statiques de classes issus de cette conception :

J’ai fait une validation en observant et en mesurant les signaux de sortie du microcontrôleur avec un oscilloscope.

Le slave est un interrupteur de courant commandé par radio.
Il s’intégrera dans un boîtier standard de coupure secteur.

Son adresse est en dure en mémoire EEPROM. On peut facilement la changer lors de la programmation, ou par reprogrammation de la mémoire EEPROM. Par défaut, elle vaut 0x00.

Lorsqu’il reçoit une suite de 8 « 1 » consécutifs, il considère qu’il s’agit du début d’une transmission radio. A la suite de l’octet de synchronisation, il lit l’adresse.
Si l’adresse reçue est la bonne, le slave réceptionne les instructions et les interprète.
Si l’adresse reçue n’est pas la bonne, le slave de remet en attente d’une suite de 8 « 1 » consécutifs, ce qui ne peut pas arriver tant que la dernière communication n’est pas terminée.

Deux LED matérialiseront l’état du slave :

• Une LED verte indiquera un état actif
• Une LED rouge indiquera un état inactif

Le boîtier est de faible dimension et impose que la carte électronique ait des dimensions inférieurs ou égales à 6,5 x 4,5 cm.

Il s’agit d’un module AUREL AC-RX, alimenté en 5V et fournissant en sortie un signal TTL.
L’état de repos de sortie est l’état bas.

2 LEDS sont à piloter par le microcontrôleur.
Afin de minimiser le nombre de broches de commande du microcontrôleur, nous allons réaliser la commande des LED avec seulement une seule broche.

Le schéma a été encapsulé dans un sous circuits dont voici le schéma :

Ce montage est intéressant car il permet de ne pas forcément implanter les LEDS selon les besoins : on pourra par exemple ne mettre qu’une LED verte pour ne pas générer de lumière lors du non fonctionnement du montage.

Le slave va être commandé par un microcontrôleur PIC.

Dressons l’inventaire des ressources nécessaire concernant le microcontrôleur :

• 1 sortie pour le pilotage des LEDS
• Un courant de sortie supérieur à 15 mA sur 1 broche pour les LEDS
• 1 sortie pour le pilotage de la coupure secteur
• 1 entrée pour la réception radio
• 1 octet au moins de mémoire EEPROM pour mémorisation de l’adresse

Tout ceci nous amène à sélectionner le PIC16F629.
Son petit boîtier DIL8 convient parfaitement à notre application. Il dispose d’assez de broches, d’une bonne taille de mémoire de programme, et de mémoire EEPROM.
Il est en outre capable de délivrer 25 mA par broche, et un maximum de 125 mA pour l’ensemble des broches.
Enfin, ce microcontrôleur possède un quartz interne de fréquence 4MHz, avec une précision de 1%, ce qui est amplement suffisant pour notre application, et favorisera davantage la réduction du coût et de l’encombrement du montage.

Voici la schéma complet du slave :

Résistances :

• 4 Résistances 330 Ohm ¼ W
• 1 Résistance 560 Ohm ¼ W

Condensateurs :

• 1 condensateur polyester type C368 400V 470nF pas 15mm
• 1 condensateur chimique radial 220µF 16V
• 2 condensateurs papier 100nF

Composants actifs :

• 1 Triac BTA12 400V 12A
• 1 microcontrôleur PIC 12F629 en boîtier DIL8
• 1 module de réception radio AUREL AC-RX + support barrette 15 contacts
• 1 régulateur 7805 (boîtier TO-220)

Optoélectronique :

• 1 LED Verte
• 1 LED Rouge
• 1 Optotriac MOC3043

Diodes :

• 4 diodes 1N4001 ou 1N4007
• 1 diode Zener 11V 1N5348

Connecteurs & supports :

• 1 support de CI tulipe DIL6
• 1 support de CI tulipe DIL8
• 1 porte fusible à câbler isolé (pour fusible 1A 5x20mm)

Divers :

• 1 fusible de 1A 5x20mm
• 1 fil d’antenne de 15 cm

Voici le layout complet du slave :

On utilisera le quartz interne du microcontrôleur. Il fonctionne à 4MHz, soit 1 MIPS.

Voici le brochage du pic 12F629 :

Remarque : toutes les broches « - » seront paramétrées en entrée, et reliées à VSS.

En l’absence de communication radio, le slave est en sommeil. L’absence de communication radio provoque l’arrivée d’une continuité de « 0 ».
L’arrivée d’un « 1 » sur la liaison radio provoque le réveil du microcontrôleur via l’interruption externe INT.
Le slave appellera alors la primitive RADIO_Reception() de la brique radio.
Cette fonction renverra le code de l’instruction reçue ou bien un code d’erreur. En cas d’erreur, le Slave retournera en mode sommeil après réactivation des interruptions INT.
En cas d’instruction reçue, la slave exécutera l’instruction en demandant le cas échéant les paramètres à la brique radio.

La brique radio utilise le Timer 0.

L’octet est à stoker en mémoire EEPROM. On utilisera l’adresse 0x00.

La fonction principale main fonctionnera comme une tâche d’OS. Un octet sera utilisé en flags pour matérialiser l’arrivée des messages asynchrones sur la tâche.

Voici l’inventaire de ces flags :

• 0b00000001 : Une interruption INT a eu lieu

Voici la liste des interruptions que nous allons utiliser :

• Interruption externe INT pour détecter l’arrivée du premier bit radio
• Débordement du Timer 0 pour la brique radio

La conception USDP en langage UML a été faite. Les 2 schémas ci-dessous présentent les diagrammes statiques de classes issus de cette conception :

J’ai pu valider le montage en stimulant l’entrée du microcontrôleur avec un signal très propre issu d’un autre microcontrôleur.

L’objectif de cette itération est de faire fonctionner ensemble un Commander et un Slave. Cette étape, si elle n’a pas marché du premier coup fonctionne très bien aujourd’hui.

Les principaux problèmes concernent les perturbations hertziennes dues au nombre important d’applications de domotique qui utilisent la même gamme de fréquence. Cela se traduisait par des allumages ou des extinctions intempestives du slave alors qu’aucune action n’avait été demandée. Pour résoudre ce problème, j’ai du augmenter la robustesse du protocole de communication.

A présent, c’est le contraire, le protocole est très (trop ?) robuste, et en cas de perturbation, les ordres ont du mal à être transmis. Bon mais ca fonctionne globalement pas mal, même si un compromis entre robustesse et fiabilité de transmission est peut-être à revoir.

Un master est une radiocommande séquentielle. Il peut envoyer des commandes radio à un groupe de récepteurs. Le nombre de récepteurs pilotables est variable, et peut aller jusqu’à toutes les adresses HS disponibles, c’est-à-dire 126 (0x7E). 0x7F n’est pas interdit, mais ne nécessite pas d’autres adresses puisqu’il mémorise tout le monde.

Le master possède un bouton unique. A chaque appui, il active ou désactive les slaves qu’il connaît.

Afin d’indiquer quelle est la commande envoyée, le master possède 2 leds qui s'allument comme suit :

• Led Rouge : la commende d’extinction a été envoyée.
• Led Verte : la commande d’allumage a été envoyée.

Le master est alimenté par une pile de 9V. A l’arrêt, il ne devra absolument rien consommer.

Le master s’arrête tout seul après 4 secondes d’inactivité.

Le groupe d’adresses est stocké en dur dans le soft, mais doit être facilement modifiable par reprogrammation. On préconisera donc l’espace EEPROM.

Le module d’émission radio sera un module Aurel TX-SAW 433. Il s’alimente en 12V, et se commande avec un signal TTL. On peut l'alimenter en 9V sans problème.

La source d’alimentation sera une pile de 9V. Le microcontrôleur sera alimenté en 5V, il faudra donc un régulateur 5V.

Le Master sera géré par un microcontrôleur PIC. C’est lui qui commandera l’ensemble des composants du montage.

Dressons l’inventaire des ressources nécessaires concernant le microcontrôleur :

• 1 sortie pour la communication avec le module radio
• 1 sortie pour piloter l’alimentation du module radio
• 1 sortie pour piloter l’auto alimentation du montage après le lâché des boutons
• 1 entrée pour le bouton poussoir
• 2 sorties pour le pilotage des leds

Soit un total de 5 sorties et 1 entrée.

Il faudra en outre prévoir 101 octets de mémoire EEPROM :

• 1 octet pour stocker la dernière commande envoyée
• 100 octets pour stocker le groupe d’adresse

Notre choix se portera sur le PIC 12F629.

• 1 Pile 9V + Coupleur à fil
• 1 module radio AUREL TX-SAW 433 + support barrette 15 contacts
• 1 bouton poussoir (1 rouge)
• 2 Transistors BC547
• 3 Transistors BC557
• 2 LED (1 rouge, 1 verte)
• 1 PIC 12F629 + support DIL8
• 2 Résistances 10 kOhm ¼ W
• 3 Résistances 330 Ohm ¼ W
• 3 Résistances 1 MOhm ¼ W
• 2 Résistances 560 Ohm ¼ W
• 1 Régulateur 7805
• 1 Condensateur papier 330 nF
• 2 Condensateur papier 100 nF
• 1 diode Zener 5,1V
• 1 fil d’antenne de 15 cm
• 3 straps

On utilisera le quartz interne du microcontrôleur. Il fonctionne à 4MHz, soit 1 MIPS.

Voici le brochage du pic 12F629 :

Remarque : toutes les broches « - » seront paramétrées en entrée, et reliées à VSS.

Au repos, l’alimentation est complètement coupée. L’appui sur le bouton provoque la mise sous tension. Tout d’abord, le microcontrôleur valide l’auto maintient de son alimentation. Ensuite il regarde la dernière commande envoyée, positionne les leds, envoie la commande à toutes les adresses qu’il connaît, et enfin, sauvegarde la dernière commande envoyée. Au bout de 4 secondes sans inactivité, l’auto maintient est invalidé. Si dans ce laps de 4 secondes le bouton est de nouveau enclenché, le fonctionnement reprend et le compteur de 4 secondes est relancé.

La brique radio utilise le Timer 0.
Le bouton aura besoin d’un compteur de 10 ms pour gérer son antirebond. Nous utiliserons le timer 1 prescallé sur 8, et nous compterons 1250 incrémentation.
Pour le timeout de 4 secondes, nous utiliserons aussi le Timer 1 prescallé sur 8, et nous compterons 8 débordements. C’est grossièrement 4s, mais la précision n’est pas fondamentale dans ce cas.
Etant donné qu’un nouvel appui clavier arrête le Timeout de 4 secondes, nous pouvons utiliser sans problème le même timer pour ces deux cas.

La dernière commande envoyée est à stoker en mémoire EEPROM. On utilisera l’adresse 0x7F.

Les adresses à piloter sont stockées en mémoire EEPROM. On utilisera les adresses EEPROM allant de 0x00 à 0x7C. D’un point de vu algorithmique, le master enverra la commande à toutes les adresses stockées à partir de 0x00, et s’arrêtera lorsque cette adresse vaudra 0xFF. Si toutes les adresses sont utilisées, il trouvera forcément un 0xFF à l’adresse EEPROM 0x7E.

La fonction principale main fonctionnera comme une tâche d’OS. Un octet sera utilisé en flags pour matérialiser l’arrivée des messages asynchrones sur la tâche.

Voici l’inventaire de ces flags :

• 0b00000001 : Une inactivité a été détectée

Voici la liste des interruptions que nous allons utiliser :

• Débordement du Timer 0 pour la brique radio
• Débordement du Timer 1 pour la gestion de l’inactivité

Voici les diagrammes de classes issus des différentes phase de modélisation :

On valide la master fonctionnellement de la même manière que le Commander.

L’insersion dans un système HS ne pose aucun problème.