Création d'un prototype de centrale domotique

Depuis un certain temps, je souhaite domotiser mon logement, mais comme il est trop facile d'acheter des modules tout prêts, j'ai choisi de créer ma propre centrale de domotique.

Après avoir lu l'article publié sur framboise314.fr, j'ai souhaité reprendre le mode de fonctionnement fondé sur des cartes à relais pilotant des appareils conventionnels. L'inconvénient est que le câblage de ce système doit être prévu dès le départ pour permettre cette installation. Chaque équipement doit être câblé directement et individuellement sur la carte à relais.

Ce système permet d'utiliser des interrupteurs conventionnels et autorise, moyennant un recâblage, de repasser aisément dans un mode de fonctionnement plus classique.

Habitant dans un appartement en location, j'ai donc fabriqué un prototype dans une boîte de rangement me permettant de créer la partie logicielle et d'expérimenter le système en attendant de pouvoir câbler mon logement à ma guise.

Vous pourriez me dire que ce serait plus facile en utilisant des modules sans-fil, mais non, j'aime le câblage, alors que cela ne facilite pas la mise en œuvre.

Le but de ce prototype est de simuler l'installation cible que je souhaiterais avoir.

Voici les caractéristiques de mon prototype :

• 8 relais alimentant 5 prises de courant pilotables sur lesquelles sont branchés les équipements. Les 3 relais restants me permettent d'expérimenter le fonctionnement d'appareils futurs (thermostat, volets roulants, etc.).
• 5 interrupteurs simulant ceux installés dans une maison.
• Une sortie permettant de brancher un bandeau LED.
• Le bus I2C est brassé sur une prise RJ45 me permettant de concevoir des modules externes raccordables facilement.

Fonctionnement de la centrale domotique

Le système est séparé en plusieurs briques :

L'espace de stockage partagé

Il s'agit d'un système de fichiers partagé avec les différents Raspberry Pi. L'état de chaque entrée et sortie est traduite par la présence ou non d'un fichier dans cet espace de stockage. Ce système permet d'avoir une installation pouvant grandir en ajoutant des Raspberry Pi supplémentaires afin d'augmenter le nombre d'entrées/sorties gérées. Plus précisément, il s'agit d'un tmpfs afin de limiter le nombre de cycles d'écriture sur les cartes SD. Il est partagé en NFS.

L'API

Écrite en PHP, elle assure toute l'intelligence du système. Elle est appelée par la brique d'entrée/sortie lorsqu'une entrée est activée et par une tâche cron toutes les minutes afin de déclencher les tâches planifiées. Chaque élément (étage, pièce, équipement, script) peut être appelé par l'API avec une URL dédiée.

Le démon d'entrée/sortie

Écrit en Python, ce démon pilote les périphériques (relais, bandeau LED, interrupteurs, etc.) et l'espace de stockage. Il crée ou supprime les fichiers dans le répertoire in en fonction de l'état des entrées et active ou désactive les sorties en fonction de la présence ou non des fichiers dans le répertoire out.

Le client Web

Ecrit en HTML, CSS et JS, il interroge l'API et propose une interface utilisateur simple et intuitive.

L'architecture du système se schématise comme suit :

Chaque équipement est piloté en central, ce qui implique un câblage spécifique dans le cas où le système est déployé sur un logement :

Lampes et prises de courant

Chaque lampe et chaque prise de courant sont pilotées par un relais dédié. La phase part du bornier et entre dans la borne COM du relais. La borne NO (normalement ouvert) part vers la lampe ou la prise de courant.

Le câblage obtenu est le suivant :

Volets roulants

Un volet roulant filaire dispose de 4 fils :

• Phase montée du volet
• Phase descente du volet
• Neutre
• Terre

Chaque phase est raccordée individuellement à un relais. Le neutre et la terre sont directement raccordés aux borniers.

L'allumage exclusif de chacune des phases est assuré logiciellement. Lorsque la fermeture est demandée, le relais d'ouverture est éteint, puis le relais de fermeture est allumé.

Le câblage obtenu est le suivant :

Thermostat

Le contact du thermostat est assuré par un relais. La fermeture et l'ouverture du contact sont déclenchées par la température de consigne à laquelle est ajoutée ou soustraite une marge de 1°C :

La sonde de température est assurée par l'un des capteurs météo de la maison.

Le câblage obtenu est le suivant :

Lecteur audio

Le lecteur audio est un client pour un serveur MPD. Dans ce prototype, le serveur MPD est le Raspberry Pi lui-même.

Bandeau LED

Le bandeau LED est composé de plusieurs LED RGB réglables individuellement. Chaque LED est associée à une puce WS2812B pilotable depuis un port GPIO du Raspberry Pi.

Station météo

La sonde météo BME280 connectée en I2C permet d'obtenir des informations concernant la température, l'humidité et la pression atmosphérique. Pour ce prototype, elle est déportée afin que les mesures ne soient pas faussées par la chaleur dégagée par le Raspberry Pi. Pour cela, j'ai utilisé une prise RJ45 sur laquelle est brassé le bus I2C pour faciliter la connexion :

Configuration de l'API

La configuration de l'API se fait dans un fichier JSON. Elle décrit la configuration des étages, des pièces et des équipements. On y retrouve également les scripts et les tâches planifiées.

Voici un exemple de configuration :

Fichier de configuration de l'API

{
	"floors":[
		{
			"name":"Rez-de-chaussée",
			"rooms":[
				{
					"name":"Cuisine",
					"icon":"kitchen",
					"color":"red",
					"items":[
						{
							"type":"Lamp",
							"name":"Spots",
							"relay":{
								"no":"spotsCuisine"
							}
						},
						{
							"type":"Lamp",
							"name":"Hotte",
							"relay":{
								"no":"lampeCuisine"
							}
						},
						{
							"type":"PowerPlug",
							"name":"Lave-vaisselle",
							"relay":{
								"no":"laveVaisselle"
							}
						},
						{
							"type":"PowerPlug",
							"name":"Cafetière",
							"relay":{
								"no":"cafetiere"
							}
						}
					]
				},
				{
					"name":"Salon",
					"icon":"livingroom",
					"color":"yellow",
					"items":[
						{
							"type":"Lamp",
							"name":"Spots",
							"relay":{
								"no":"spotsSalon"
							}
						},
						{
							"type":"Lamp",
							"name":"Lampadaire",
							"relay":{
								"no":"lampeSalon"
							}
						},
						{
							"type":"Shutter",
							"name":"Volet",
							"relayUp":{
								"no":"voletSalonOuverture"
							},
							"relayDown":{
								"no":"voletSalonFermeture"
							}
						},
						{
							"type":"RoomWeather",
							"name":"Capteur météo",
							"no":"meteoSalon"
						}
					]
				}
			]
		},
		{
			"name":"Premier étage",
			"rooms":[
				{
					"name":"Chambre",
					"icon":"bedroom",
					"color":"blue",
					"items":[
						{
							"type":"Lamp",
							"name":"Lampe de chevet",
							"relay":{
								"no":"lampeChevetChambre"
							}
						},
						{
							"type":"Shutter",
							"name":"Volet",
							"relayUp":{
								"no":"voletChambreOuverture"
							},
							"relayDown":{
								"no":"voletChambreFermeture"
							}
						},
						{
							"type":"LedStrip",
							"name":"Bandeau LED",
							"label":"bandeauLED"
						}
					]
				}
			]
		}
	],
	"inputs":{
		"interSpotsCuisine":{
			"call":"/0/0/0/tooglePower"
		},
		"interLampeCuisine":{
			"call":"/0/0/1/tooglePower"
		},
		"interScenarioNuit":{
			"call":"/nuit"
		},
		"interOuvertureVoletsSalon":{
			"call":"/0/1/2/open"
		},
		"interFermetureVoletsSalon":{
			"call":"/0/1/2/close"
		},
		"interScenarioMatin":{
			"call":"/matin"
		},
		"interLampeSalon":{
			"call":"/0/1/1/tooglePower"
		},
		"interSpotsSalon":{
			"call":"/0/1/0/tooglePower"
		}
	},
	"scripts":{
		"matin":{
			"name":"Scénario matin",
			"steps":[
				{"action":"run","object":"/0/0/3","method":"powerOn","args":{}},
				{"action":"run","object":"/0/1/2","method":"open","args":{}},
				{"action":"run","object":"/1/0/0","method":"powerOn","args":{}},
				{"action":"run","object":"/1/0/1","method":"open","args":{}}
			],
			"hidden":false
		},
		"nuit":{
			"name":"Scénario nuit",
			"steps":[
				{"action":"run","object":"/0/0/0","method":"powerOff","args":{}},
				{"action":"run","object":"/0/0/1","method":"powerOff","args":{}},
				{"action":"run","object":"/0/0/2","method":"powerOn","args":{}},
				{"action":"run","object":"/0/0/3","method":"powerOff","args":{}},
				{"action":"run","object":"/0/1/0","method":"powerOff","args":{}},
				{"action":"run","object":"/0/1/1","method":"powerOff","args":{}},
				{"action":"run","object":"/0/1/2","method":"close","args":{}},
				{"action":"run","object":"/1/0/0","method":"powerOn","args":{}},
				{"action":"run","object":"/1/0/1","method":"close","args":{}}
			],
			"hidden":false
		}
	},
	"plannedTasks":{
		"arretLaveVaisselle":{
			"trigger":{
				"and":[
					{"==":["hour",23]},
					{"==":["minute",0]}
				]
			},
			"call":"/0/0/2/powerOff"
		},
		"reveil":{
			"trigger":{
				"and":[
					{"==":["holyday",false]},
					{"==":["hour",7]},
					{"==":["minute",0]}
				]
			},
			"call":"/matin/"
		}
	},
	"items":[
		{
			"type":"Thermostat",
			"name":"thermostatChaudiere",
			"relay":{
				"no":"thermostatChaudiere"
			},
			"temperatureSensorUrl":"/0/1/3"
		}
	],
	"latitude":48.855,
	"longitude":2.2944,
	"timezone":1
}

Les scripts

Les scripts permettent d'appeler séquentiellement différentes adresses de l'API. Il est également possible de définir une pause entre deux appels.

Programmation d'événements

Dans la configuration du serveur, il est possible de créer des tâches planifiées selon la configuration du système. Les paramètres pouvant être utilisés sont les suivants :

• L'état des entrées/sorties
• Le temps (heure, minute, lever, azimut ou coucher du Soleil)
• La date (jour, mois, année, jours ouvrés)

Il est possible de combiner les conditions d'exécution avec les opérateurs ET et OU, et également de comparer les valeurs avec les opérateurs "égal", "différent", >, >=, <, <=, incluses ou exclues d'une liste de valeurs.

Voici un exemple de configuration permettant d'allumer la lampe de chevet (selon la configuration ci-dessus) à 7:00 tous les jours ouvrés :

"reveil":{
	"trigger":{
		"and":[
			{"==":["holyday",false]},
			{"==":["hour",7]},
			{"==":["minute",0]}
		]
	},
	"call":"/1/0/0/powerOn"
}

Calcul de l'heure de lever, d'azimut et de coucher de Soleil

N'ayant pas de box Internet et souhaitant un système le plus indépendant possible des API externes, j'ai donc voulu implémenter un calcul de l'heure de lever, d'azimut et de coucher du Soleil pour, par exemple, fermer les volets en fin de journée.

Pour cela, je me suis basé sur la feuille de calcul fournie par l'Agence américaine d'observation océanique et atmosphérique qui permets de calculer ces heures à partir de la latitude, la longitude et la date du jour.

Le calcul s'effectue comme suit. Les paramètres choisis sont les heures de lever, d'azimut et de coucher du Soleil pour aujourd'hui à la Tour Eiffel, exprimés en heure locale :

Tout d'abord, le calcul se fait avec les jours julien et les siècles juliens. Pour cela, on effectue la conversion en appliquant les règles suivantes :

• Soit Y l'année, M la valeur numérique du mois (1=janvier, 2=février, etc.) et D le jour.
• Si la date est au mois de janvier ou février, on retire 1 à Y et on ajoute 12 à M.
• On effectue les opérations suivantes en ne retenant que la valeur entière des divisions :
• a = Y/100 = 20
• b = a/4 = 5
• c = 2-a+b = -13
• e = 365,25×(Y+4716) = 2460689
• f = 30,6001×(M+1) = 428
• JJ = c+D+e+f-1524,5 = 2459602,5
• SJ = (JJ-2451545)/36525 = 0,22060232717317

Le calcul des heures se fait comme suit. Soit l_a la latitude, l_o la longitude et f_h le fuseau horaire du point à calculer. La lettre des variables correspond à la colonne de la feuille de calcul d'origine :

La conversion d'une fraction de jour julien (noté f_JJ) en heure lisible se fait comme suit :

• heures = valeur entière(24×f_JJ)
• minutes = valeur entière(1440×(f_JJ-heures/24))
• secondes = valeur entière(86400×(f_JJ-heures/24-minutes/1440))

Pour la journée du dimanche 23 janvier 2022, les heures sont les suivantes :

Lever du Soleil

08:32:41

Azimut du Soleil

13:02:29

Coucher du Soleil

17:32:17

L'utilisation de ces heures dans les scripts se fait en vérifiant que les booléens sunrise (lever de Soleil), sunnoon (azimut) et sunset (coucher de Soleil) soient vrais.

Calcul des jours fériés mobiles

En plus des fêtes fixes (8 mai, 14 juillet, 11 novembre, etc.), nous avons des fêtes dites mobiles (car leurs dates varient chaque année). C'est le cas pour Pâques, le Lundi de Pâques, l'Ascension et la Pentecôte. Cependant, il est possible de déterminer, à partir de la date de Pâques, la date du Lundi de Pâques (le lendemain), de l'Ascension (40 jours après Pâques) et de la Pentecôte (50 jours après Pâques).

Pour calculer la date de Pâques, on utilise l'algorithme de Butcher-Meeus. Pour cela, on applique les opérations suivantes. Les valeurs données sont celles pour l'année 2022 :

• Si m = 3, le dimanche de Pâques est le (j + 1) mars.
• Si m = 4, le dimanche de Pâques est le (j + 1) avril.

Pour l'année 2022, les dates des jours fériés mobiles sont :

Pâques

Dimanche 17 avril 2022

Lundi de Pâques

Lundi 18 avril 2022

Ascension

Jeudi 26 mai 2022

Pentecôte

Dimanche 5 juin 2022

Matériel

Pour concevoir ce prototype, j'ai utilisé les éléments suivants. Je donne cette liste à titre indicatif et vous êtes libres de l'adapter à votre guise :

J'ai également utilisé un cordon d'alimentation standard pour tout alimenter. Le choix de ce modèle de Raspberry Pi est motivé par la présence du module WiFi inclus qui me permet de créer un réseau qui lui est propre (et aussi parce que j'en avais un inutilisé sous la main).

L'outillage nécessaire pour réaliser ce prototype est le suivant :

• Perceuse
• Fer à souder
• Pince à dénuder
• Pince coupante
• Tournevis
• Bistouri

Câblage des composants

Voici le câblage final des différents composants du prototype :

Le code

Le système est composé de trois briques logicielles. La communication entre l'API et le démon d'entrée/sortie est assurée par le système de fichiers partagé. Cela permet de partager simplement l'état du système entre plusieurs Raspberry Pi et avoir ainsi un système extensible à volonté : on ajoute des Raspberry Pi avec des modules ad-hoc pour augmenter le nombre d’éléments pilotés.

Le client Web appelle l'API pour connaître l'état du système et envoyer des ordres. Cela me permet de créer différents systèmes pouvant dialoguer avec le système de domotique en appelant l'API pour ajouter des fonctionnalités.

Le démon d'entrée/sortie

Il s'agit d'une boucle qui lit l'état des entrées du module I/O I2C (adresse 0x21) et qui, en fonction de la configuration renseignée dans le fichier io.json, crée les fichiers adéquats dans le répertoire in. A l'inverse, si le fichier adéquat existe dans out, la sortie ad-hoc sur le second module (adresse 0x20) est activée. C'est également durant cette boucle que les valeurs de température, d'humidité et de pression atmosphérique sont lues, si le champ roomWeather est renseigné. Enfin, le bandeau LED est piloté en fonction des paramètres du fichier dans le répertoire out.

Voici un schéma de fonctionnement du démon d'entrée/sortie :

Voici un exemple de configuration :

{
	"in":{
		"1":"interSpotsCuisine",
		"2":"interLampeCuisine",
		"3":"interScenarioNuit",
		"4":"interOuvertureVoletsSalon",
		"5":"interFermetureVoletsSalon",
		"6":"interScenarioMatin",
		"7":"interLampeSalon",
		"8":"interSpotsSalon"
	},
	"out":{
		"1":"spotsCuisine",
		"2":"spotsSalon",
		"3":"laveVaisselle",
		"4":"lampeCuisine",
		"5":"cafetiere",
		"6":"lampeSalon",
		"7":"voletSalonOuverture",
		"8":"voletSalonFermeture"
	},
	"roomWeather":"meteoSalon",
	"ledStrip":{
		"label":"bandeauLED",
		"leds":60
	}
}

L'API

L'API représente chaque élément (objet, étages, pièces, tâches, etc.) sous la forme d'objets. Chaque objet est capable d’être appelé par une URL sous la forme suivante : /etage/piece/objet/methode (exemples : /0/0/0/powerOn pour allumer les spots de la cuisine, /1/0/powerOff pour éteindre tous les équipements de la chambre). Si la méthode n'est pas mentionnée, il s'agit de la méthode returnData qui est appelée. Elle permet de retourner l'état de l'objet.

Il est possible d'obtenir l'état de tous les objets enfants en appelant l'objet parent. Cela limite les appels de l'API.

Voici un exemple de retour fait par l'API. Ici, il s'agit de l'état de l'ensemble du système (/returnData) :

Réponse de l'API

{
	"url": "/",
	"floors": [
		{
			"url": "/0",
			"id": 0,
			"name": "Rez-de-chaussée",
			"rooms": [
				{
					"url": "/0/0",
					"id": 0,
					"name": "Cuisine",
					"icon": "kitchen",
					"color": "red",
					"items": [
						{
							"url": "/0/0/0",
							"id": 0,
							"name": "Spots",
							"scripts": [],
							"relay": {
								"no": "spotsCuisine",
								"status": false
							},
							"status": false,
							"type": "Lamp",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/0/0/1",
							"id": 1,
							"name": "Hotte",
							"scripts": [],
							"relay": {
								"no": "lampeCuisine",
								"status": true
							},
							"status": true,
							"type": "Lamp",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/0/0/2",
							"id": 2,
							"name": "Lave-vaisselle",
							"scripts": [],
							"relay": {
								"no": "laveVaisselle",
								"status": true
							},
							"status": true,
							"type": "PowerPlug",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/0/0/3",
							"id": 3,
							"name": "Cafetière",
							"scripts": [],
							"relay": {
								"no": "cafetiere",
								"status": false
							},
							"status": false,
							"type": "PowerPlug",
							"defaultMethod": "tooglePower"
						}
					],
					"scripts": []
				},
				{
					"url": "/0/1",
					"id": 1,
					"name": "Salon",
					"icon": "livingroom",
					"color": "yellow",
					"items": [
						{
							"url": "/0/1/0",
							"id": 0,
							"name": "Spots",
							"scripts": [],
							"relay": {
								"no": "spotsSalon",
								"status": false
							},
							"status": false,
							"type": "Lamp",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/0/1/1",
							"id": 1,
							"name": "Lampadaire",
							"scripts": [],
							"relay": {
								"no": "lampeSalon",
								"status": false
							},
							"status": false,
							"type": "Lamp",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/0/1/2",
							"id": 2,
							"name": "Volet",
							"scripts": [],
							"relayUp": {
								"no": "voletSalonOuverture",
								"status": false
							},
							"relayDown": {
								"no": "voletSalonFermeture",
								"status": false
							},
							"type": "Shutter",
							"opened": true
						},
						{
							"url": "/0/1/3",
							"id": 3,
							"name": "Capteur météo",
							"scripts": [],
							"type": "RoomWeather",
							"temperature": 22.8,
							"humidity": 47.5,
							"pressure": 991.3,
							"call": "/0/1/3/updateWeather"
						}
					],
					"scripts": []
				}
			],
			"scripts": []
		},
		{
			"url": "/1",
			"id": 1,
			"name": "Premier étage",
			"rooms": [
				{
					"url": "/1/0",
					"id": 0,
					"name": "Chambre",
					"icon": "bedroom",
					"color": "blue",
					"items": [
						{
							"url": "/1/0/0",
							"id": 0,
							"name": "Lampe de chevet",
							"scripts": [],
							"relay": {
								"no": "lampeChevetChambre",
								"status": false
							},
							"status": false,
							"type": "Lamp",
							"defaultMethod": "tooglePower"
						},
						{
							"url": "/1/0/1",
							"id": 1,
							"name": "Volet",
							"scripts": [],
							"relayUp": {
								"no": "voletChambreOuverture",
								"status": false
							},
							"relayDown": {
								"no": "voletChambreFermeture",
								"status": false
							},
							"type": "Shutter",
							"opened": true
						},
						{
							"url": "/1/0/2",
							"id": 2,
							"name": "Bandeau LED",
							"scripts": [],
							"type": "LedStrip",
							"label": "bandeauLED",
							"colors": [],
							"mode": "plain"
						}
					],
					"scripts": []
				}
			],
			"scripts": []
		}
	],
	"scripts": [
		{
			"label": "matin",
			"name": "Scénario matin"
		},
		{
			"label": "nuit",
			"name": "Scénario nuit"
		}
	],
	"inputs": [
		{
			"no": "interSpotsCuisine",
			"status": false,
			"call": "/0/0/0/tooglePower"
		},
		{
			"no": "interLampeCuisine",
			"status": false,
			"call": "/0/0/1/tooglePower"
		},
		{
			"no": "interScenarioNuit",
			"status": false,
			"call": "/nuit"
		},
		{
			"no": "interOuvertureVoletsSalon",
			"status": false,
			"call": "/0/1/2/open"
		},
		{
			"no": "interFermetureVoletsSalon",
			"status": false,
			"call": "/0/1/2/close"
		},
		{
			"no": "interScenarioMatin",
			"status": false,
			"call": "/matin"
		},
		{
			"no": "interLampeSalon",
			"status": false,
			"call": "/0/1/1/tooglePower"
		},
		{
			"no": "interSpotsSalon",
			"status": false,
			"call": "/0/1/0/tooglePower"
		}
	],
	"items": {
		"2": {
			"type": "Thermostat",
			"relay": {
				"no": "thermostatChaudiere",
				"status": false
			},
			"temperatureSet": 21,
			"temperatureSensorUrl": "/0/1/3",
			"scripts": []
		}
	}
}

Ce mode de fonctionnement permet à n'importe quel script ou application de s'interfacer avec le système de domotique sans avoir à recréer d'interface particulière.

Une tâche cron est exécutée toutes les minutes et appelle l'API via une méthode particulière. Cette méthode vérifie les paramètres de chaque tâche planifiée décrite dans la configuration et les exécute si toutes les conditions sont remplies.

Le client Web

Le client Web est optimisé pour une utilisation sur mobile. La mise à jour de l'état des objets (allumage d'une lampe, fermeture d'un volet, etc.) est transmise à chaque client connecté à l'API par Server Side Events. Une mise à jour de l'état du système est également envoyée toutes les minutes pour maintenir la connexion.

Les icônes utilisées par le client sont de ma création. Elles sont disponibles au téléchargement au format SVG et sous licence CC BY-SA :

Icônes au format SVG

Création de modules Wi-Fi

Afin de palier au principal défaut de ce prototype, à savoir la nécessité de prévoir le câblage en amont de ce système, j'ai entrepris de créer des modules Wi-Fi basés sur le microcontrolleur ESP8266.

Le choix de ce microcontrolleur a été motivé par son prix modeste et ses grandes possibilités d'utilisation.

Sonde de température extérieure

Afin de mesurer la température extérieure, j'ai entrepris de créer une sonde de température et d'humidité à partir d'une sonde AM2320 que j'avais utilisé pour la centrale, avant de passer au BME280 m'offrant en plus la pression atmosphérique.

Voici un schéma du câblage :

Une fois connecté au réseau Wi-Fi émis par ma centrale domotique, le microcontrolleur fournit une interface HTTP qui renvoie au format JSON les mesures de température (en °C) et d'humidité :

{'temperature':19.54,'humidity':54.21}

Voici le code source du microcontrolleur. Ne pas oublier d'inclure la librairie pour l'IDE Arduino de la puce AM2320 :

#include <AM2320.h>
#include <ESP8266WiFi.h>

AM2320 sensor;
const char* ssid = "SSIDduWiFi";
const char* password = "MotDePasseDuWiFi";

WiFiServer server(80);
void setup() {
	sensor.begin(0,2);	// Initie le bus I2C (GPIO 0 : SDA, GPIO 2 : SCL)
	delay(10);
	WiFi.begin(ssid, password);
	while (WiFi.status() != WL_CONNECTED) {
		delay(500);
	}
	server.begin();
}

void loop() {
	WiFiClient client = server.available();
	if (!client) {
		return;
	}
	 
	while(!client.available()){
		delay(1);
	}
	 
	String request = client.readStringUntil('\r');
	client.flush();

	if (sensor.measure()) {
		client.println("HTTP/1.1 200 OK");
		client.println("Content-Type: application/json");
		client.println("");
		client.print("{'temperature':");
		client.print(sensor.getTemperature());
		client.print(",'humidity':");
		client.print(sensor.getHumidity());
		client.println("}");
	} else {
		int errorCode = sensor.getErrorCode();
		switch (errorCode) {
			case 1: 
				client.println("HTTP/1.1 500 Internal Server Error");
				client.println("Content-Type: application/json");
				client.println("");
				client.println("{'error':'Sensor offline'}"); 
				break;
			case 2: 
				client.println("HTTP/1.1 500 Internal Server Error");
				client.println("Content-Type: application/json");
				client.println("{'error':'CRC failed'}"); 
				break;
		}
	}
	delay(1);
}

Bouton connecté

Pour effectuer certaines opérations sans à avoir à utiliser son smartphone, j'ai utilisé un bouton poussoir en saillie dans lequel sont câblées une carte ESP-01 et deux piles AAA pour l'alimenter. Lorsque le bouton poussoir est pressé, le microcontrolleur ESP8266 est réinitialisé. Le programme effectue les opérations suivantes :

1. Se connecter au réseau Wi-Fi émis par la centrale domotique
2. Appel de l'URL sur l'API
3. Mise en veille prolongée (deep sleep mode) afin d'économiser un maximum d'énergie

Voici le câblage du bouton connecté :

Voici le code source du microcontrolleur :

#include <ESP8266WiFi.h>

const char* ssid = "SSIDduWiFi";
const char* password = "MotDePasseDuWiFi";
const char* host = "10.250.0.1";


void setup() {
	WiFi.begin(ssid, password);
	while (WiFi.status() != WL_CONNECTED) {
		delay(5);
	}
	WiFiClient client;
	if (client.connect(host, 8080)) {
		client.print(String("GET /button1/callInput") + " HTTP/1.1\r\n" +
			"Host: " + host + "\r\n" +
			"Connection: close\r\n" +
			"\r\n"
		);
		while (client.connected() || client.available()) {
			if (client.available()) {
				String line = client.readStringUntil('\n');
			}
		}
		client.stop();
	}
	ESP.deepSleep(0);
}

void loop() {}

Variateur de lumière connecté

Une possibilité que j'ai souhaitée ajouter à mon système est de pouvoir modifier l'intensité lumineuse des éclairages. C'est pourquoi j'ai choisi d'utiliser un variateur à courant continu en PWM avec détection du passage à zéro (lien vers la fiche produit fournie à titre indicatif).

Le principe de fonctionnement de ce système est de générer une tension de sortie en fonction d'un signal de consigne dit signal PWM. Ce signal alterne un niveau haut et niveau bas en fonction de la puissance voulue. Dans notre cas, le signal alternatif de la prise électrique est modulé par le signal PWM généré par l'ESP8266 pour obtenir la tension de sortie désirée. De plus, le signal PWM est, ici, synchronisé avec la sinusoïde du courant alternatif de la prise de courant grâce à l'impulsion émise par le module depuis sa broche Z-C lors du passage à 0. Cette impultion va déclencher une interruption du processeur du microcontrolleur et exécutera la fonction zeroCross du code ci-dessous.

Le schéma ci-dessous montre le fonctionnement de ce montage avec une puissance à 25 % du maximum :

Le montage final est le suivant :

Le code du microcontrolleur doit donc générer un signal PWM synchronisé à partir d'une consigne reçue de la centrale domotique :

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

int pwmPin = 16; // Broche D0
int zcPin = 14;  // Broche D5
int dimming = 0;
int targetDimming = 0;
int offTime = 10000;
int loopCount = 0;

const char* ssid = "SSIDduWiFi";
const char* passwd = "MotDePasseDuWiFi";
const char* targetUrl = "http://10.250.0.1:8080/0/1/2/getInstruction";

void ICACHE_RAM_ATTR zeroCross()
{
	if (dimming < 15){
		digitalWrite(pwmPin, LOW);
	} else if (dimming == 100){
		digitalWrite(pwmPin, HIGH);
	} else {
		digitalWrite(pwmPin, LOW); 
		delayMicroseconds(offTime); 
		digitalWrite(pwmPin, HIGH);
	}
}

void setup()
{
	pinMode(pwmPin, OUTPUT);
	digitalWrite(pwmPin, LOW);
	WiFi.begin(ssid, passwd);
	while (WiFi.status() != WL_CONNECTED) {
		delay(500);
	}
	attachInterrupt(digitalPinToInterrupt(zcPin), zeroCross, RISING);
}

void loop()	{
	if ((WiFi.status() == WL_CONNECTED) && (loopCount == 10)) {
		loopCount = 0;
		WiFiClient client;
		HTTPClient http;
		http.begin(client, targetUrl);
		int httpCode = http.GET();
		if (httpCode > 0) {
			targetDimming = http.getString().toInt();
		}
		http.end();
	}
	if (targetDimming < dimming){
		dimming--;
		offTime = 10000-(100*dimming);
	}else if (targetDimming > dimming){
		dimming++;
		offTime = 10000-(100*dimming);
	}
	loopCount++;
	delay(100);
}