Dans cet article, vous apprendrez comment contrôler un climatiseur via IR avec un microcontrôleur ESP32 ou ESP8266.
La plupart des climatiseurs modernes sont livrés avec une télécommande qui envoie des signaux infrarouges (IR) pour contrôler l’appareil. Cependant, souvent, les fonctionnalités de la télécommande et du climatiseur sont limitées. Que faire si vous voulez allumer le climatiseur à une heure précise ? Que faire si vous souhaitez réguler le climatiseur en fonction des prévisions météo ? Ou encore, contrôler le climatiseur depuis une autre pièce ? Peut-être avez-vous simplement perdu votre télécommande et souhaitez construire un remplacement plus puissant ?
Notez qu’en date de janvier 2024, le IRRemoteESP8266 library utilisé pour générer les signaux IR pour contrôler un climatiseur does not compile for the ESP32 and Arduino 3.0.0. J’ai essayé, mais je n’ai pas réussi à le faire fonctionner. Cependant, une fois la bibliothèque corrigée, le code de cet article devrait à nouveau fonctionner avec l’ESP32.
Tout cela et bien plus peut être réalisé si nous utilisons un microcontrôleur pour contrôler nous-mêmes le climatiseur. Commençons.
Pièces requises
Cette section liste les pièces nécessaires. En plus d’un ESP32 ou ESP8266 et de quelques petits composants, vous aurez besoin d’un climatiseur pouvant être contrôlé par signaux infrarouges. Vous pouvez trouver la liste des Aircons supportés ici.
Pour le microcontrôleur, j’utiliserai spécifiquement l’ESP8266 ESP-12F Mini (WEMOS LOLIN D1 mini) listé ci-dessous, mais la plupart des cartes ESP8266 et ESP32 devraient également fonctionner. J’ai aussi listé l’ESP32 lite en raison de son faible prix et de son connecteur batterie avec capacité de recharge. Cela peut être utile si vous souhaitez construire votre propre télécommande fonctionnant sur batterie.
Selon la version du projet que vous réalisez, vous n’aurez besoin que d’un sous-ensemble des pièces listées ici.
ESP8266 ESP-12F Mini
ESP32 lite
Câble USB de données
Jeu de fils Dupont
Plaque d’essai (breadboard)
Kit de résistances & LED
Kit de transistors
Récepteur et émetteur IR
Diode émettrice IR
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Technologie infrarouge et climatiseurs
La technologie infrarouge (IR) est largement utilisée dans diverses applications, notamment les télécommandes pour appareils électroniques comme les téléviseurs, lecteurs DVD et climatiseurs. Elle permet une communication sans fil entre appareils en transmettant des signaux sous forme de lumière infrarouge.
Les climatiseurs, étant l’un des appareils ménagers les plus courants, sont souvent équipés d’une télécommande utilisant la technologie IR. Ces télécommandes envoient des signaux IR spécifiques à l’unité de climatisation pour contrôler ses fonctions, comme régler la température, la vitesse du ventilateur et le mode.
Les climatiseurs sont équipés d’un récepteur IR capable de détecter et d’interpréter ces signaux. Lorsqu’une commande est reçue, le climatiseur réagit en conséquence, soit en modifiant la température, en ajustant la vitesse du ventilateur, ou en effectuant toute autre action liée à la commande.
Si vous souhaitez en savoir plus sur les signaux infrarouges et comment les générer, consultez nos tutoriels sur How to build a universal, programmable IR remote, How to control an ESP32 with an IR Remote, et How to Control a Servo with an IR Remote.
Climatiseurs supportés
Il est important de noter que différents modèles et marques de climatiseurs peuvent utiliser des protocoles et codes IR différents. Avant de poursuivre le projet, vous devez identifier la marque de votre climatiseur. Nous utiliserons le IRRemoteESP8266 library et la liste des Aircons supportés est disponible ici.
Une fois que vous avez vérifié que votre climatiseur est supporté, vous pouvez connecter l’ESP32/ESP8266 à une diode IR et programmer l’envoi des signaux appropriés. Cela vous permettra de contrôler votre climatiseur à distance via une interface web.
Système global
L’image ci-dessous montre le système global que nous allons construire. Une page web s’exécutant dans un navigateur qui contrôle l’ESP32/ESP8266 via Wi-Fi, lequel contrôle à son tour le climatiseur avec des signaux IR.
Dans la section suivante, je vous montrerai comment connecter l’ESP32/ESP8266 à un émetteur IR
Connexion de l’ESP32/ESP8266 à un émetteur IR
Pour envoyer des signaux infrarouges (IR), nous devons connecter l’ESP32 ou ESP8266 à un émetteur IR. Je vais vous montrer trois façons différentes de faire cela. La première est la plus simple et utilise un module émetteur IR pratique. Pour le deuxième circuit, nous utiliserons une diode émettrice IR et une résistance, ce qui demande un peu plus de travail mais peut offrir une meilleure portée. Le dernier circuit utilise un MOSFET supplémentaire, ce qui permet d’augmenter encore la portée.
Module émetteur IR
La façon la plus simple est d’utiliser un module émetteur IR. Ces modules sont très simples et consistent généralement en une diode IR et une résistance sur une carte breakout. Ils ont généralement trois broches : masse (GND ou ‘-‘), alimentation (VCC ou ‘+’) et signal (S ou DAT). Voir le module ci-dessous.
Connexion du module émetteur IR
La connexion du module est simple. Connectez la masse (G) de votre ESP32/ESP8266 à la broche moins (-/GND) du module (fil noir). Puis connectez une broche GPIO (ici D2) à la broche signal (S/DAT) du module (fil jaune). Enfin, connectez le +5V (ou +3,3V) de votre microcontrôleur à la broche centrale (+/VCC) du module (fil rouge). Note : ne connectez pas le module aux broches TX ou RX, cela pourrait interférer avec la communication série.
Dans le circuit d’exemple ci-dessus, j’utilise un Wemos Lolin D1 mini qui offre une sortie 5V ou 3,3V. Le choix de l’alimentation du module importe généralement peu. L’entrée 5V ou 3,3V du module IR est parfois même pas utilisée ou sert seulement à indiquer la présence d’alimentation ou de signal. Cela n’affecte généralement pas la portée de l’émetteur IR.
Bien que cela fonctionne et soit pratique pour tester la fonction, la portée reste limitée. J’obtiens entre 1 et 2 mètres de portée, dépendant de la résistance sur le module. Certains modules offrent une portée bien plus grande, mais ils utilisent probablement un circuit incorrect. Voir la section suivante.
Modules sans résistance de limitation de courant
Attention !Certains modules bon marché n’ont pas de résistance de limitation de courant, ce qui fait que la diode IR tire environ 180mA. C’est beaucoup trop pour une sortie GPIO d’un ESP8266, qui devrait être autour de 10mA! Si vous connectez ces modules, vous obtiendrez une excellente portée, mais vous risquez d’endommager votre carte !
Voici une photo d’un tel module. Si vous regardez attentivement, vous verrez que la résistance R1 est absente et que la carte ne comporte qu’une diode IR. Vous pouvez utiliser ces modules, mais vous devez ajouter une résistance dans le circuit.
Dans la section suivante, je vous montre comment connecter vous-même la diode émettrice IR et une résistance. Cela nous donne un meilleur contrôle du courant et de la portée.
Diode émettrice IR et résistance
Comme vous pouvez le voir ci-dessous, le circuit utilisant une diode émettrice IR et une résistance reste très simple. Connectez la patte la plus courte de la diode IR à la masse et la patte la plus longue à la résistance. L’autre patte de la résistance est connectée à une sortie GPIO, ici D2.
Nous pouvons calculer la valeur de la résistance requise comme suit. Nous avons 3,3 volts en sortie GPIO, nous voulons tirer au maximum 10 mA, et la diode IR a une tension directe de 1,2V à 1,5V (prenons 1,3V). Pour une résistance de 220Ω, nous obtenons un courant de 9mA :
(3,3V – 1,3V)/220Ω = 9mA
Comme le signal IR est une impulsion courte, on pourrait descendre jusqu’à 100Ω, ce qui donnerait (3,3V – 1,3V)/100Ω = 20mA. Cela augmenterait un peu la portée, mais c’est risqué. Une meilleure solution serait de piloter la diode IR via un transistor ou MOSFET. C’est ce que nous allons faire dans la section suivante.
Diode émettrice IR et MOSFET
La portée de notre émetteur IR est limitée car nous ne pouvons fournir en toute sécurité que 10mA à la diode IR en utilisant directement une sortie GPIO d’un ESP8266. La diode IR elle-même pourrait être alimentée jusqu’à 100mA, ce qui augmenterait considérablement la portée de notre émetteur. Le schéma suivant montre comment faire cela.
Dans ce circuit, la diode IR est connectée à une pile 9V avec une résistance de limitation de courant R1 de 100Ω. Cela donne un courant de (9V-1,3V)/100Ω = 77mA à travers la diode IR, ce qui est bien dans sa limite de 100mA. Avec cette configuration, j’obtiens une portée d’environ 8 à 10 mètres.
Le MOSFET agit comme un interrupteur. Si la sortie GPIO (D2) de l’ESP8266 passe à l’état haut, la grille (G) du MOSFET ouvre la connexion entre le drain (D) et la source (S) et le courant peut circuler de la pile 9V, à travers la diode IR vers la masse (GND).
Le 2N7000 MOSFET que j’utilise ici peut commuter jusqu’à 60V et 200mA en continu. Cela suffit pour les 70mA que consomme notre diode IR.
La résistance de 100Ω (R2) dans le circuit est une autre résistance de limitation de courant pour protéger la GPIO. La deuxième résistance (R1) de 10KΩ est une résistance de tirage vers la masse qui assure que le MOSFET s’éteint lorsque la grille n’est pas connectée. Si vous voulez en savoir plus sur les MOSFET et comment les utiliser pour contrôler des charges électriques, consultez notre tutoriel How To a Control Fan using Arduino.
Circuit complet sur breadboard
La photo ci-dessous montre le circuit complet sur une breadboard.
Le circuit sur breadboard suit le schéma présenté ci-dessus. Commencez par insérer le MOSFET et la diode IR dans la breadboard. Faites attention à la bonne orientation du 2N7000 et de la diode IR. Connectez la pile 9V en dernier et faites attention à la polarité. N’oubliez pas non plus que la pile et l’ESP8266 doivent avoir une masse commune (fil de masse de l’ESP8266 connecté à la pile) !
Pour tester le circuit, vous pouvez d’abord utiliser le blink sketch et une LED normale avant d’exécuter le programme beaucoup plus complexe que nous aborderons dans les sections suivantes. Commençons par la page web dont nous avons besoin pour contrôler notre climatiseur.
Page web pour télécommande
Nous voulons contrôler notre ESP32/ESP8266 via une page web. Les pages web sont généralement construites en utilisant le langage HTML. Le code HTML suivant décrit la mise en page, les couleurs et le contenu de notre page web.
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
Si vous copiez ce code HTML dans un fichier nommé « test.html » puis que vous l’ouvrez dans votre navigateur par glisser-déposer, vous verrez la page web suivante.
Vous pouvez facilement identifier les éléments dans le code HTML et les éléments correspondants sur la page web. Le titre est dans la balise « h1« , « p » définit le paragraphe, qui contient le texte « Power » et deux éléments « button » avec des liens hypertexte « a« . La section « style » spécifie les couleurs et la mise en page de la page. Si vous voulez en savoir plus sur le HTML, voici un bon HTML Tutorial.
Pour afficher cette page web dans un navigateur, nous devons exécuter un serveur web qui sert cette page au navigateur. Ce serveur web s’exécutera sur notre ESP32/ESP8266 et nous discuterons de ce code dans la section suivante.
Programmation de l’ESP32/ESP8266 pour le contrôle du climatiseur
Voici le code complet qui vous permet de contrôler un climatiseur via infrarouge en utilisant une page web servie par un serveur web tournant sur votre ESP32 ou ESP8266. C’est un gros morceau de code, mais nous allons le décomposer en parties gérables et l’expliquer en détail. Jetez d’abord un œil pour avoir une vue d’ensemble.
Notez que ce code est pour un DAIKIN climatiseur. Mais vous pouvez facilement adapter le code à votre climatiseur en changeant le protocole de communication pertinent (cherchez la variable ac.next.protocol dans le code). Vous pouvez trouver la liste des Aircons supportés ici.
// Control Aircon via Infrared Signals using a Webpage
// served by a Webserver running on an ESP32/ESP8266
#if defined(ESP8266)
#include "ESP8266WiFi.h"
#elif defined(ESP32)
#include "WiFi.h"
#else
#error "This ain't a ESP8266 or ESP32"
#endif
#include "Arduino.h"
#include "IRremoteESP8266.h" // ESP32 and ESP8266
#include "IRac.h"
#include "IRutils.h"
const int irPin = D2;
const char* ssid = "*****";
const char* password = "*****";
const char* html = R""""(
HTTP/1.1 200 OK
Content-type:text/html
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
)"""";
WiFiServer server(80);
IRac ac(irPin);
void setup_wifi() {
delay(10);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void setup_ac() {
pinMode(irPin, OUTPUT);
ac.next.protocol = decode_type_t::DAIKIN; // Set a protocol to use. Here a DAIKIN Aircon
ac.next.model = 1; // Some A/Cs have different models. Try just the first.
ac.next.mode = stdAc::opmode_t::kCool; // Run in cool mode initially.
ac.next.celsius = true; // Use Celsius for temp units. False = Fahrenheit
ac.next.degrees = 25; // 25 degrees.
ac.next.fanspeed = stdAc::fanspeed_t::kMedium; // Start the fan at medium.
ac.next.swingv = stdAc::swingv_t::kOff; // Don't swing the fan up or down.
ac.next.swingh = stdAc::swingh_t::kOff; // Don't swing the fan left or right.
ac.next.light = false; // Turn off any LED/Lights/Display that we can.
ac.next.beep = false; // Turn off any beep from the A/C if we can.
ac.next.econo = false; // Turn off any economy modes if we can.
ac.next.filter = false; // Turn off any Ion/Mold/Health filters if we can.
ac.next.turbo = false; // Don't use any turbo/powerful/etc modes.
ac.next.quiet = false; // Don't use any quiet/silent/etc modes.
ac.next.sleep = -1; // Don't set any sleep time or modes.
ac.next.clean = false; // Turn off any Cleaning options if we can.
ac.next.clock = -1; // Don't set any current time if we can avoid it.
ac.next.power = false; // Initially start with the unit off.
}
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
void run_server() {
WiFiClient client = server.accept();
if (client) {
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
if (currentLine.length() == 0) {
client.println(html);
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
execute(currentLine);
}
}
client.stop();
}
}
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
void loop() {
run_server();
}
Pour comprendre le code en détail, décomposons-le en parties.
Bibliothèques
D’abord, nous install et incluons les bibliothèques nécessaires pour l’ESP32 et la fonctionnalité IR. Selon le microcontrôleur (ESP32 ou ESP8266), nous devons inclure une bibliothèque Wi-Fi différente. Nous y parvenons en utilisant un conditional include (#if, #elif, #endif).
#if defined(ESP8266) #include "ESP8266WiFi.h" #elif defined(ESP32) #include "WiFi.h" #else #error "This is not a ESP8266 or ESP32" #endif #include "Arduino.h" #include "IRremoteESP8266.h" // ESP32 and ESP8266 #include "IRac.h" #include "IRutils.h"
Malgré son nom, la bibliothèque IRremoteESP8266.h fonctionne pour ESP8266 et ESP32 – du moins en théorie. Comme mentionné dans l’introduction, actuellement (janvier 2024) la library does not compile for ESP32.
Constantes et variables
Ensuite, nous définissons la constante irPin qui spécifie la broche à laquelle l’émetteur IR est connecté. Nous définissons aussi les variables ssid et password pour les identifiants du réseau Wi-Fi. Vous devrez insérer ici le SSID et le mot de passe de votre réseau Wi-Fi local. Le SSID est le nom de votre Wi-Fi domestique, par exemple « my_home_wifi », et le mot de passe est celui que vous utilisez habituellement pour vous connecter à ce réseau (avec votre téléphone ou ordinateur).
const int irPin = D2; const char* ssid = "*****"; const char* password = "*****";
Code HTML pour la page web
Nous avons déjà présenté cette partie du code. C’est le code HTML qui sera servi par le serveur web. Il décrit les éléments, les couleurs et la mise en page de la page web.
const char* html = R""""(
HTTP/1.1 200 OK
Content-type:text/html
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
)"""";
Notez particulièrement la section qui définit les boutons. Si vous voulez ajouter plus de boutons et de fonctionnalités à votre page web, c’est ici qu’il faut le faire (vous devrez aussi ajouter du code plus bas). Par exemple, si vous voulez aussi allumer ou éteindre les lumières du climatiseur, voici ce que vous ajouteriez :
<p>Power: <a href="/power/on"><button>ON</button></a> <a href="/power/off"><button>OFF</button></a> </p> <p>Lights: <a href="/light/on"><button>ON</button></a> <a href="/light/off"><button>OFF</button></a> </p>
Configuration Wi-Fi
La fonction setup_wifi() est responsable de connecter l’ESP32 au réseau Wi-Fi. Nous appelons WiFi.begin(ssid, password) pour initier la connexion Wi-Fi avec nos identifiants fournis (SSID, mot de passe). Puis nous attendons dans une boucle jusqu’à ce que la connexion soit établie en vérifiant WiFi.status().
void setup_wifi() {
delay(10);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
Une fois connecté, nous affichons l’adresse IP du serveur web (tournant sur notre ESP8266). Elle sera affichée dans le moniteur série et vous devrez la copier, car vous en aurez besoin pour vous connecter à la page web depuis votre ordinateur.
Enfin, nous appelons server.begin(), qui lance le serveur web. Si vous ne pouvez pas vous connecter au Wi-Fi, vérifiez votre SSID et mot de passe !
Configuration du climatiseur
Dans la fonction setup_ac(), nous configurons d’abord la broche de l’émetteur IR en sortie (pinMode(irPin, OUTPUT)). Puis nous définissons l’état initial du climatiseur. Comme vous pouvez le voir, il y a de nombreuses fonctions du climatiseur que vous pouvez activer ou désactiver. Celles-ci concernent un climatiseur DAIKIN, un modèle très courant.
void setup_ac() {
pinMode(irPin, OUTPUT);
ac.next.protocol = decode_type_t::DAIKIN; // Set a protocol to use.
ac.next.model = 1; // Some A/Cs have different models. Try just the first.
ac.next.mode = stdAc::opmode_t::kCool; // Run in cool mode initially.
ac.next.celsius = true; // Use Celsius for temp units. False = Fahrenheit
ac.next.degrees = 25; // 25 degrees.
ac.next.fanspeed = stdAc::fanspeed_t::kMedium; // Start the fan at medium.
ac.next.swingv = stdAc::swingv_t::kOff; // Don't swing the fan up or down.
ac.next.swingh = stdAc::swingh_t::kOff; // Don't swing the fan left or right.
ac.next.light = false; // Turn off any LED/Lights/Display that we can.
ac.next.beep = false; // Turn off any beep from the A/C if we can.
ac.next.econo = false; // Turn off any economy modes if we can.
ac.next.filter = false; // Turn off any Ion/Mold/Health filters if we can.
ac.next.turbo = false; // Don't use any turbo/powerful/etc modes.
ac.next.quiet = false; // Don't use any quiet/silent/etc modes.
ac.next.sleep = -1; // Don't set any sleep time or modes.
ac.next.clean = false; // Turn off any Cleaning options if we can.
ac.next.clock = -1; // Don't set any current time if we can avoid it.
ac.next.power = false; // Initially start with the unit off.
}
Changez la variable ac.next.protocol = decode_type_t::DAIKIN pour le modèle de votre climatiseur. Les noms des différents modèles sont listés here et les constantes correspondantes se trouvent here. Cherchez ce morceau de code :
enum decode_type_t {
UNKNOWN = -1,
UNUSED = 0,
RC5,
RC6,
NEC,
SONY,
PANASONIC,
...
}
Selon votre modèle, certaines de ces fonctions peuvent ne pas être disponibles et vous n’aurez peut-être pas besoin de définir toutes ces variables. Le code ci-dessus est basé sur cette example de la bibliothèque IRremoteESP8266. Vous y trouverez beaucoup plus d’exemples et d’informations.
Regardez particulièrement les wrappers pour certains climatiseurs. Leur utilisation peut offrir moins d’options mais simplifier votre code. Par exemple, pour le climatiseur DAIKIN, il existe la classe wrapper ir_Daikin.h, qui fournit des fonctions pour contrôler le climatiseur. Voici un example :
ac.on(); ac.setFan(1); ac.setTemp(25);
Utiliser ces fonctions signifie que nous n’aurions pas à écrire les nôtres comme dans la section suivante.
Contrôle du climatiseur
Ensuite, nous définissons la fonction ac_power() qui est responsable d’allumer ou d’éteindre le climatiseur en réglant la propriété power de l’objet ac et en envoyant le signal IR.
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
Si vous voulez contrôler plus de fonctions de votre climatiseur, vous ajouterez des fonctions supplémentaires. Par exemple, une fonction pour allumer ou éteindre les lumières du climatiseur ressemblerait à ceci :
void ac_light(bool isOn) {
ac.next.light = isOn;
ac.sendAc();
}
Exécution des commandes
Ensuite, nous avons la fonction execute() qui traite la commande HTTP reçue et exécute l’action correspondante. Dans ce cas, elle allume ou éteint le climatiseur selon la commande. Notez que les chaînes dans « GET /power/on » doivent correspondre aux liens hypertexte href="/power/on" dans la page web. C’est ce qui relie le bouton à la fonction exécutée lors de l’appui.
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
Si vous voulez contrôler les lumières en plus de l’alimentation, vous ajouteriez la fonction ac_light() ainsi :
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
if (command.endsWith("GET /light/on")) {
ac_light(true);
}
if (command.endsWith("GET /light/off")) {
ac_light(false);
}
}
Serveur web
La fonction run_server() gère les requêtes clients entrantes et sert la page HTML. Elle appelle aussi la fonction execute() pour traiter les commandes.
Le code ci-dessous est largement basé sur l’exemple SimpleWiFiServer fourni par WiFi library. Si vous avez besoin d’informations ou d’applications plus détaillées, consultez cette source.
void run_server() {
WiFiClient client = server.accept();
if (client) {
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
if (currentLine.length() == 0) {
client.println(html);
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
execute(currentLine);
}
}
client.stop();
}
}
Setup et boucle
Enfin, dans la fonction setup(), nous initialisons la communication série, configurons le climatiseur et connectons au réseau Wi-Fi.
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
Et la fonction loop() exécute en continu le serveur web pour gérer les requêtes entrantes.
void loop() {
run_server();
}
Et voilà ! Vous avez maintenant un contrôleur web entièrement fonctionnel pour votre climatiseur. Dans la section suivante, je vous montre comment l’utiliser réellement.
Utilisation du serveur web
Si vous réinitialisez votre ESP32/ESP8266 et ouvrez le moniteur série, vous devriez voir un texte affichant l’adresse IP de votre ESP32/ESP8266. Dans mon cas, pour mon ESP32, c’est 192.168.1.168, par exemple.
Vous verrez une adresse IP différente, celle attribuée à votre carte ESP32/ESP8266. Copiez cette adresse dans la barre de recherche de votre navigateur. Vous devriez voir la page web que le serveur web sur votre ESP32/ESP8266 crée :
Maintenant, vous pouvez appuyer sur les boutons pour allumer ou éteindre votre climatiseur depuis une page web.
Pour résumer, voici comment fonctionne le système global. L’ESP8266/ESP32 exécute un serveur web qui est servi à un navigateur web. Le navigateur et le serveur communiquent via Wi-Fi à travers votre routeur Wi-Fi. L’ESP8266/ESP32 contrôle le climatiseur via des signaux infrarouges (IR) qui imitent les commandes que votre télécommande enverrait. Cela signifie aussi que vous pouvez toujours utiliser votre télécommande.
Notez que la page web est assez sécurisée, car elle n’est accessible que depuis votre réseau Wi-Fi local. Elle n’est pas accessible publiquement depuis Internet ! Si vous souhaitez cela, cela demandera plus de travail et de mesures de sécurité, car il est risqué d’ouvrir votre réseau Wi-Fi à Internet !
Sinon, c’est tout !
Conclusion
Dans ce billet, nous avons appris comment contrôler un climatiseur en utilisant des signaux infrarouges (IR) et un microcontrôleur ESP32/ESP8266. En suivant ce guide étape par étape, vous pouvez automatiser votre système de refroidissement et profiter de la commodité du contrôle à distance.
Le code de ce tutoriel n’est qu’un début. Il y a tellement plus à faire ! À commencer par contrôler plus de fonctions de votre climatiseur, vous pourriez ajouter des capteurs supplémentaires (mouvement, température, humidité) pour contrôler automatiquement votre climatiseur selon les conditions environnementales. Pratiquement toute fonction manquante sur votre climatiseur, vous pouvez la construire vous-même.
Amusez-vous bien !
Questions fréquentes
Voici quelques questions fréquemment posées sur le contrôle d’un climatiseur avec des signaux infrarouges et un microcontrôleur ESP32/ESP8266 :
Q : Puis-je utiliser n’importe quelle carte ESP32/ESP8266 pour ce projet ?
R : Oui, vous pouvez utiliser n’importe quelle carte ESP32/ESP8266 pour ce projet tant qu’elle dispose des broches GPIO nécessaires pour connecter la diode IR et d’un module Wi-Fi intégré.
Q : Comment l’ESP32/ESP8266 contrôle-t-il le climatiseur avec des signaux infrarouges ?
R : L’ESP32/ESP8266 est programmé pour générer les signaux infrarouges nécessaires qui imitent les signaux de la télécommande du climatiseur. En connectant la diode IR à l’ESP32/ESP8266 et en la programmant en conséquence, vous pouvez envoyer des commandes infrarouges spécifiques au climatiseur, comme changer la température, le mode ou la vitesse du ventilateur.
Q : Puis-je contrôler plusieurs climatiseurs avec un seul ESP32/ESP8266 ?
R : Oui, vous pouvez contrôler plusieurs climatiseurs avec un seul ESP32/ESP8266 en utilisant différents codes IR pour chaque climatiseur. En programmant l’ESP32/ESP8266 pour envoyer les codes IR appropriés à chaque climatiseur, vous pouvez les contrôler individuellement ou simultanément.
Q : Comment augmenter la portée de l’émetteur IR ?
R : Vous pouvez utiliser deux (ou plus) émetteurs IR contrôlés en parallèle mais connectés à deux ports GPIO différents de votre ESP8266 ou ESP32. La meilleure option est d’alimenter l’émetteur IR séparément et d’utiliser un MOSFET (ou transistor) pour le contrôler. Si cela ne suffit toujours pas, vous pouvez connecter une seconde diode IR et contrôler les deux via le MOSFET. Vous n’aurez toujours besoin que d’une seule sortie GPIO. Voici un schéma d’exemple :
Ce sont quelques-unes des questions fréquemment posées concernant le contrôle d’un climatiseur avec des signaux infrarouges et un microcontrôleur ESP32/ESP8266. Si vous avez d’autres questions, n’hésitez pas à les poser dans la section commentaires ci-dessous.
