In questo articolo imparerai come controllare un condizionatore d’aria tramite IR con un microcontrollore ESP32 o ESP8266.
La maggior parte delle unità di condizionamento moderne è dotata di un telecomando che invia segnali a infrarossi (IR) per controllare l’unità. Tuttavia, spesso la funzionalità del telecomando e del condizionatore è limitata. E se volessi accendere il condizionatore a un orario specifico? E se volessi regolare il condizionatore in base alle previsioni meteo? O se volessi controllarlo da un’altra stanza? Forse hai semplicemente perso il telecomando e vuoi costruirne uno più potente?
Nota che a partire da gennaio 2024 il IRRemoteESP8266 library utilizzato per generare i segnali IR per il controllo del condizionatore does not compile for the ESP32 and Arduino 3.0.0. Ho provato, ma non sono riuscito a farlo funzionare. Tuttavia, una volta che la libreria sarà sistemata, il codice in questo articolo dovrebbe funzionare di nuovo con l’ESP32.
Tutto questo e molto altro può essere realizzato se usiamo un microcontrollore per controllare il condizionatore da soli. Iniziamo.
Componenti necessari
In questa sezione sono elencati i componenti necessari. Oltre a un ESP32 o ESP8266 e alcuni componenti minori, ti servirà un condizionatore che possa essere controllato tramite segnali a infrarossi. Puoi trovare la lista dei Aircons supportati qui.
Per quanto riguarda il microcontrollore, userò specificamente l’ESP8266 ESP-12F Mini (WEMOS LOLIN D1 mini) elencato qui sotto, ma la maggior parte delle schede ESP8266 e ESP32 dovrebbe funzionare altrettanto bene. Ho anche elencato l’ESP32 lite per il suo basso costo e il connettore per batteria con capacità di ricarica. Questo può essere utile se vuoi costruire un telecomando alimentato a batteria.
A seconda della versione del progetto che stai realizzando, ti servirà solo un sottoinsieme dei componenti elencati qui.
ESP8266 ESP-12F Mini
ESP32 lite
Cavo dati USB
Set di fili Dupont
Breadboard
Kit di resistori e LED
Kit di transistor
Ricevitore e trasmettitore IR
Diodo trasmettitore 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.
Tecnologia a infrarossi e condizionatori
La tecnologia a infrarossi (IR) è ampiamente utilizzata in varie applicazioni, inclusi i telecomandi per dispositivi elettronici come televisori, lettori DVD e condizionatori. Permette la comunicazione wireless tra dispositivi trasmettendo segnali sotto forma di luce infrarossa.
I condizionatori, essendo uno degli elettrodomestici più comuni, spesso sono dotati di un telecomando che utilizza la tecnologia IR. Questi telecomandi inviano segnali IR specifici all’unità per controllarne le funzioni, come la regolazione della temperatura, della velocità della ventola e della modalità.
I condizionatori sono dotati di un ricevitore IR che può rilevare e interpretare questi segnali. Quando viene ricevuto un comando, il condizionatore risponde di conseguenza, modificando la temperatura, regolando la velocità della ventola o eseguendo qualsiasi altra azione associata al comando.
Se vuoi saperne di più sui segnali infrarossi e su come generarli, dai un’occhiata ai nostri tutorial su How to build a universal, programmable IR remote, How to control an ESP32 with an IR Remote, e How to Control a Servo with an IR Remote.
Condizionatori supportati
È importante notare che diversi modelli e marche di condizionatori possono utilizzare protocolli e codici IR differenti. Pertanto, prima di procedere con il progetto, dovresti identificare la marca del tuo condizionatore. Useremo il IRRemoteESP8266 library e la lista dei Aircons supportati può essere trovata qui.
Una volta verificato che il tuo condizionatore è supportato, puoi procedere collegando l’ESP32/ESP8266 a un diodo IR e programmando l’invio dei segnali appropriati. Questo ti permetterà di controllare il condizionatore da remoto tramite un’interfaccia web.
Sistema generale
L’immagine qui sotto mostra il sistema generale che andremo a costruire. Una pagina web che gira in un browser e controlla l’ESP32/ESP8266 via Wi-Fi, che a sua volta controlla il condizionatore usando segnali IR.
Nella prossima sezione ti mostrerò come collegare l’ESP32/ESP8266 a un trasmettitore IR
Collegare l’ESP32/ESP8266 a un trasmettitore IR
Per inviare segnali a infrarossi (IR) dobbiamo collegare l’ESP32 o ESP8266 a un trasmettitore IR. Di seguito ti mostrerò tre modi diversi per farlo. Il primo è il più semplice e utilizza uno di quei pratici moduli trasmettitori IR. Per il secondo circuito useremo un diodo trasmettitore IR e un resistore, un po’ più laborioso ma che può offrire una portata migliore. L’ultimo circuito usa un MOSFET aggiuntivo, che ci permette di aumentare ulteriormente la portata.
Modulo trasmettitore IR
Il modo più semplice è usare un modulo trasmettitore IR. Questi moduli sono molto semplici e solitamente consistono in un diodo IR e un resistore su una scheda breakout. Di solito hanno tre pin: massa (GND o ‘-‘), alimentazione (VCC o ‘+’) e segnale (S o DAT). Vedi il modulo qui sotto.
Collegare il modulo trasmettitore IR
Collegare il modulo è semplice. Collega la massa (G) del tuo ESP32/ESP8266 al pin meno (-/GND) del modulo (filo nero). Poi collega un pin GPIO (qui usiamo D2) al pin segnale (S/DAT) del modulo (filo giallo). Infine collega +5V (o +3.3V) del microcontrollore al pin centrale (+/VCC) del modulo (filo rosso). Nota: non collegare il modulo ai pin TX o RX, potrebbe interferire con la comunicazione seriale.
Nel circuito di esempio sopra, uso un Wemos Lolin D1 mini che offre un’uscita a 5V o 3.3V. Quale usare per alimentare il modulo di solito non importa. L’ingresso a 5V o 3.3V al modulo IR a volte non viene usato affatto o serve solo per indicare alimentazione o trasferimento segnale. Generalmente non influisce sulla portata del trasmettitore IR.
Anche se funziona ed è comodo per testare la funzione, la portata è piuttosto limitata. Ottengo tra 1 e 2 metri di portata e dipende dal resistore sul modulo. Alcuni moduli offrono portate maggiori ma probabilmente usano un circuito non corretto. Vedi la sezione successiva.
Moduli senza resistore di limitazione corrente
Attenzione! Alcuni moduli economici non hanno resistore di limitazione corrente, il che fa sì che il diodo IR assorba circa 180mA di corrente. Questo è troppo alto per un’uscita GPIO di un ESP8266, che dovrebbe essere intorno a 10mA! Se colleghi queste schede ottieni un’ottima portata ma rischi di danneggiare la tua scheda!
Ecco una foto di un modulo del genere. Se guardi attentamente puoi vedere che il resistore R1 manca e la scheda ha solo un diodo IR. Puoi usare queste schede ma devi aggiungere un resistore al circuito.
Nella prossima sezione ti mostro come collegare tu stesso il diodo trasmettitore IR e un resistore. Questo ci dà un miglior controllo sulla corrente e sulla portata.
Diodo trasmettitore IR e resistore
Come vedi sotto, il circuito che usa un diodo trasmettitore IR e un resistore è ancora molto semplice. Collega il pin più corto del diodo IR a massa e il pin più lungo al resistore. L’altro pin del resistore va collegato a un’uscita GPIO, qui scelgo D2.
Possiamo calcolare il valore del resistore necessario così. Abbiamo 3.3 Volt in uscita dal GPIO, vogliamo assorbire non più di 10 mA, e il diodo IR ha una tensione diretta di 1.2V a 1.5V (facciamo 1.3V). Quindi per un resistore da 220Ω otteniamo una corrente di 9mA:
(3.3V – 1.3V)/220Ω = 9mA
Dato che il segnale IR è un impulso breve, potremmo scendere fino a 100Ω, per cui avremmo (3.3V – 1.3V)/100Ω = 20mA. Questo aumenterebbe un po’ la portata ma diventa rischioso. Una soluzione migliore è pilotare il diodo IR tramite un transistor o MOSFET. Ed è quello che faremo nella prossima sezione.
Diodo trasmettitore IR e MOSFET
La portata del nostro trasmettitore IR è limitata perché possiamo fornire in sicurezza solo 10mA al diodo IR usando direttamente un’uscita GPIO dell’ESP8266. Il diodo IR potrebbe essere alimentato fino a 100mA, aumentando drasticamente la portata del trasmettitore. Lo schema seguente mostra come fare.
In questo circuito il diodo IR è collegato a una batteria da 9V con un resistore di limitazione corrente R1 da 100Ω. Questo ci dà una corrente di (9V-1.3V)/100Ω = 77mA attraverso il diodo IR, che è ben entro il limite di 100mA. Con questa configurazione ottengo una portata di circa 8-10 metri.
Il MOSFET agisce come un interruttore. Se l’uscita GPIO (D2) dell’ESP8266 va alta, il Gate (G) del MOSFET apre la connessione tra Drain (D) e Source (S) e la corrente può fluire dalla batteria da 9V, attraverso il diodo IR verso massa (GND).
Il 2N7000 MOSFET che uso qui può commutare fino a 60V e 200mA in continuo. Questo è sufficiente per i 70mA di corrente assorbiti dal nostro diodo IR.
Il resistore da 100Ω (R2) nel circuito è un altro resistore di limitazione corrente per proteggere il GPIO. Il secondo resistore (R1) da 10KΩ è un resistore di pulldown che assicura che il MOSFET si spenga quando il gate non è connesso. Se vuoi saperne di più sui MOSFET e su come usarli per controllare carichi elettrici, dai un’occhiata al nostro tutorial How To a Control Fan using Arduino.
Circuito completo su breadboard
L’immagine qui sotto mostra il circuito completo su breadboard.
Il circuito sulla breadboard segue lo schema presentato sopra. Inizia inserendo il MOSFET e il diodo IR nella breadboard. Fai attenzione all’orientamento corretto del 2N7000 e del diodo IR. Collega la batteria da 9V per ultima e fai attenzione alla polarità corretta. Non dimenticare che batteria e ESP8266 devono avere massa comune (filo di massa dell’ESP8266 collegato alla batteria)!
Per testare il circuito potresti usare prima il blink sketch e un LED normale prima di eseguire il programma più complesso che discuteremo nelle prossime sezioni. Iniziamo dalla pagina web necessaria per controllare il condizionatore.
Pagina web per il telecomando
Vogliamo controllare il nostro ESP32/ESP8266 tramite una pagina web. Le pagine web sono tipicamente costruite usando il linguaggio HTML. Il codice HTML seguente descrive il layout, i colori e il contenuto della nostra pagina 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>
Se copiassi questo codice HTML in un file chiamato “test.html” e lo caricassi nel tuo browser tramite Drag&Drop, vedresti la seguente pagina web.
Puoi facilmente identificare gli elementi nel codice HTML e gli elementi corrispondenti nella pagina web. Il titolo è nel tag “h1“, “p” definisce il paragrafo, che contiene il testo “Power” e due elementi “button” con hyperlink “a“. La sezione “style” specifica i colori e il layout della pagina. Se vuoi saperne di più su HTML, ecco un buon HTML Tutorial.
Per mostrare questa pagina web in un browser dobbiamo eseguire un webserver che la serva al browser. Questo webserver girerà sul nostro ESP32/ESP8266 e discuteremo il codice nella prossima sezione.
Programmare l’ESP32/ESP8266 per il controllo del condizionatore
Di seguito c’è il codice completo che ti permette di controllare un condizionatore tramite infrarossi usando una pagina web servita da un webserver che gira sul tuo ESP32 o ESP8266. È un blocco di codice piuttosto grande, ma lo divideremo in parti gestibili e lo spiegheremo in dettaglio. Dai un’occhiata prima per avere una panoramica.
Nota che questo codice è per un DAIKIN condizionatore. Ma puoi adattare facilmente il codice al tuo condizionatore cambiando il protocollo di comunicazione rilevante (cerca la variabile ac.next.protocol nel codice). Puoi trovare una lista dei Aircons supportati qui.
// 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();
}
Per capire il codice in dettaglio, dividiamolo in parti.
Librerie
Per prima cosa install e includiamo le librerie necessarie per ESP32 e funzionalità IR. A seconda del microcontrollore (ESP32 o ESP8266) dobbiamo includere una libreria Wi-Fi diversa. Lo facciamo usando 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"
Nonostante il nome, la libreria IRremoteESP8266.h funziona sia per ESP8266 che per ESP32 – almeno in teoria. Come detto nell’introduzione, attualmente (gennaio 2024) la library does not compile for ESP32.
Costanti e variabili
Definiamo la costante irPin che specifica a quale pin è collegato il trasmettitore IR. Definiamo anche le variabili ssid e password per le credenziali della rete Wi-Fi. Dovrai inserire qui SSID e password della tua rete Wi-Fi locale. L’SSID è il nome della tua rete Wi-Fi domestica, ad esempio “my_home_wifi”, e la password è quella che usi normalmente per connetterti a questa rete (con telefono o computer).
const int irPin = D2; const char* ssid = "*****"; const char* password = "*****";
Codice HTML per la pagina web
Abbiamo già introdotto questa parte del codice. È il codice HTML che sarà servito dal webserver. Descrive gli elementi, i colori e il layout della pagina 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>
)"""";
Fai particolare attenzione alla sezione che definisce i pulsanti. Se vuoi aggiungere più pulsanti e funzionalità alla tua pagina web, questo è il posto giusto (dovrai anche aggiungere codice più avanti). Per esempio, se vuoi anche accendere o spegnere le luci del condizionatore, questo è ciò che aggiungeresti:
<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>
Configurazione Wi-Fi
La funzione setup_wifi() è responsabile della connessione dell’ESP32 alla rete Wi-Fi. Chiamiamo WiFi.begin(ssid, password) per iniziare la connessione Wi-Fi con le credenziali fornite (SSID, password). Poi aspettiamo in un ciclo finché non ci connettiamo controllando 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();
}
Una volta connessi, stampiamo l’indirizzo IP del webserver (che gira sul nostro ESP8266). Verrà mostrato nel monitor seriale e dovrai copiarlo, perché ti serve per connetterti alla pagina web dal tuo computer.
Infine chiamiamo server.begin(), che avvia il webserver. Se non riesci a connetterti al Wi-Fi, controlla SSID e password!
Configurazione del condizionatore
Nella funzione setup_ac(), impostiamo prima il pin del trasmettitore IR come uscita (pinMode(irPin, OUTPUT)). Poi impostiamo lo stato iniziale del condizionatore. Come vedi, ci sono molte funzioni del condizionatore che puoi attivare o disattivare. Queste sono per un condizionatore DAIKIN, un modello molto comune.
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.
}
Cambia la variabile ac.next.protocol = decode_type_t::DAIKIN con il modello del tuo condizionatore. I nomi dei diversi modelli sono elencati here e le costanti corrispondenti si trovano here. Cerca questo pezzo di codice:
enum decode_type_t {
UNKNOWN = -1,
UNUSED = 0,
RC5,
RC6,
NEC,
SONY,
PANASONIC,
...
}
A seconda del modello, alcune di queste funzioni potrebbero non essere disponibili e potresti non dover impostare tutte queste variabili. Il codice sopra si basa sulla libreria this example of the IRremoteESP8266. Troverai molti altri esempi e informazioni lì.
Dai un’occhiata in particolare ai wrapper per alcuni condizionatori. Usarli potrebbe darti meno opzioni ma semplifica il codice. Per esempio, per il condizionatore DAIKIN c’è la classe wrapper ir_Daikin.h, che fornisce funzioni per controllare il condizionatore. Ecco un example:
ac.on(); ac.setFan(1); ac.setTemp(25);
Usare queste funzioni significa che non dovremmo scrivere le nostre come facciamo nella prossima sezione.
Controllo del condizionatore
Definiamo la funzione ac_power() che si occupa di accendere o spegnere il condizionatore impostando la proprietà power dell’oggetto ac e inviando il segnale IR.
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
Se vuoi controllare più funzioni del tuo condizionatore, aggiungeresti funzioni aggiuntive. Per esempio, una funzione per accendere o spegnere le luci del condizionatore potrebbe essere così:
void ac_light(bool isOn) {
ac.next.light = isOn;
ac.sendAc();
}
Esecuzione comandi
Abbiamo poi la funzione execute() che elabora il comando HTTP ricevuto e esegue l’azione corrispondente. In questo caso, accende o spegne il condizionatore in base al comando. Nota che le stringhe in “GET /power/on” devono corrispondere agli hyperlink href="/power/on" nella pagina web. Questo collega il pulsante alla funzione eseguita quando il pulsante viene premuto.
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
Se vuoi controllare anche le luci oltre all’alimentazione, aggiungeresti la funzione ac_light() così:
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);
}
}
Web server
La funzione run_server() gestisce le richieste dei client in arrivo e serve la pagina HTML. Chiama anche la funzione execute() per elaborare i comandi.
Il codice qui sotto si basa in gran parte sull’esempio SimpleWiFiServer fornito da WiFi library. Se ti servono informazioni più dettagliate o applicazioni, dai un’occhiata lì.
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 e loop
Infine, nella funzione setup() inizializziamo la comunicazione seriale, configuriamo il condizionatore e connettiamo il Wi-Fi.
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
E la funzione loop() esegue continuamente il webserver per gestire le richieste in arrivo.
void loop() {
run_server();
}
E questo è tutto! Ora hai un controller web completamente funzionante per il tuo condizionatore. Nella prossima sezione ti mostro come usarlo realmente.
Usare il webserver
Se resetti il tuo ESP32/ESP8266 e apri il monitor seriale, dovresti vedere un testo che mostra l’indirizzo IP del tuo ESP32/ESP8266. Nel mio caso, per il mio ESP32 è 192.168.1.168, per esempio.
Vedrai un indirizzo IP diverso, quello assegnato alla tua scheda ESP32/ESP8266. Copia quell’indirizzo nella barra di ricerca del browser. Dovresti vedere la pagina web che il webserver sul tuo ESP32/ESP8266 crea:
Ora puoi premere i pulsanti per accendere o spegnere il condizionatore da una pagina web.
Per riassumere, ecco come funziona il sistema complessivo. L’ESP8266/ESP32 esegue un webserver che viene servito a un browser web. Browser e webserver comunicano via Wi-Fi attraverso il tuo router Wi-Fi. L’ESP8266/ESP32 controlla il condizionatore tramite segnali infrarossi (IR) che imitano i comandi che il telecomando invierebbe. Questo significa anche che puoi continuare a usare il tuo telecomando.
Nota che la pagina web è abbastanza sicura, poiché è accessibile solo all’interno della tua rete Wi-Fi locale. Non è accessibile pubblicamente da internet! Se vuoi questo, servirà più lavoro e misure di sicurezza, perché è rischioso aprire la tua rete Wi-Fi a internet!
Altrimenti, è tutto!
Conclusione
In questo post del blog abbiamo imparato come controllare un condizionatore usando segnali infrarossi (IR) e un microcontrollore ESP32/ESP8266. Seguendo la guida passo passo, puoi automatizzare il tuo sistema di raffreddamento e goderti la comodità del controllo remoto.
Il codice in questo tutorial è solo un inizio. C’è molto di più che puoi fare! A partire dal controllo di più funzioni del tuo condizionatore, potresti aggiungere sensori aggiuntivi (movimento, temperatura, umidità) per controllare automaticamente il condizionatore in base alle condizioni ambientali. Praticamente qualsiasi funzione mancante nel tuo condizionatore puoi costruirtela da solo.
Divertiti!
Domande frequenti
Ecco alcune domande frequenti sul controllo di un condizionatore usando segnali infrarossi e un microcontrollore ESP32/ESP8266:
D: Posso usare qualsiasi scheda ESP32/ESP8266 per questo progetto?
R: Sì, puoi usare qualsiasi scheda ESP32/ESP8266 per questo progetto purché abbia i pin GPIO necessari per collegare il diodo IR e un modulo Wi-Fi integrato.
D: Come controlla l’ESP32/ESP8266 il condizionatore usando segnali infrarossi?
R: L’ESP32/ESP8266 è programmato per generare i segnali infrarossi necessari che imitano i segnali del telecomando del condizionatore. Collegando il diodo IR all’ESP32/ESP8266 e programmando di conseguenza, puoi inviare comandi IR specifici al condizionatore, come cambiare temperatura, modalità o velocità della ventola.
D: Posso controllare più condizionatori con un singolo ESP32/ESP8266?
R: Sì, puoi controllare più condizionatori con un singolo ESP32/ESP8266 usando codici IR diversi per ciascun condizionatore. Programmando l’ESP32/ESP8266 per inviare i codici IR appropriati per ogni condizionatore, puoi controllarli individualmente o simultaneamente.
D: Come aumento la portata del trasmettitore IR?
R: Puoi usare due (o più) trasmettitori IR controllati in parallelo ma collegati a due pin GPIO diversi del tuo ESP8266 o ESP32. L’opzione migliore è alimentare il trasmettitore IR separatamente e usare un MOSFET (o transistor) per controllarlo. Se ancora non basta, puoi collegare un secondo diodo IR e controllarli entrambi tramite il MOSFET. Ti servirà comunque un solo pin GPIO. Ecco uno schema di esempio:
Queste sono alcune delle domande frequenti riguardo al controllo di un condizionatore usando segnali infrarossi e un microcontrollore ESP32/ESP8266. Se hai altre domande, sentiti libero di chiedere nella sezione commenti qui sotto.
