ESP32 Alexa e Google Home: controllo vocale con Espalexa e Sinric
Controllare ESP32 ed ESP8266 con Alexa e Google Home: dispositivo locale con Espalexa, cloud con Sinric Pro, collegamento del relè, rilevamento e confronto.
Un progetto ESP32 Alexa è il modo più rapido per comandare una lampada, un ventilatore o una presa costruiti da te dicendo "Alexa, accendi la luce". Ci sono due strade pratiche per collegare un ESP32 o un ESP8266 ad Alexa e a Google Home: con la libreria Espalexa la scheda si presenta nella rete di casa come una lampadina Philips Hue, mentre con il servizio cloud Sinric Pro la colleghi ad Alexa e a Google Home contemporaneamente. Entrambe richiedono poche righe di codice, ma dietro le quinte funzionano in modo completamente diverso.
In questa guida vedrai prima la differenza tra i due metodi e quando scegliere l'uno o l'altro. Poi realizzerai un progetto Espalexa con un modulo relè e una striscia LED dimmerabile, scoprirai cosa controllare quando Alexa non trova il dispositivo e comanderai lo stesso relè anche da Google Home con Sinric Pro. Gli sketch si compilano senza modifiche sia sull'ESP32 sia sull'ESP8266 (NodeMCU, Wemos D1 Mini).

Come comunica l'ESP32 con Alexa e Google Home?
Espalexa fa apparire l'ESP32 nella rete locale come un bridge Philips Hue. Quando il tuo Echo riceve il comando "cerca dispositivi", invia in rete un messaggio multicast SSDP; l'ESP32 risponde "sono una lampadina Hue" e l'Echo lo aggiunge alla sua lista. Da quel momento i comandi non passano da Internet, ma arrivano direttamente all'ESP32 sulla porta 80 della rete di casa. È veloce e non serve un account, ma funziona solo con Alexa e solo se nella stessa rete c'è un Echo. Google Home non supporta questa emulazione Hue locale, quindi bisogna passare dal cloud: con Sinric Pro l'ESP32 mantiene una connessione WebSocket permanente verso Internet, colleghi il tuo account Sinric Pro nell'app Alexa o Google e il comando vocale arriva dal cloud alla scheda.
| Metodo | Alexa | Google Home | Internet | Difficoltà | Nota |
|---|---|---|---|---|---|
| Espalexa | Sì (locale) | No | Non serve | Facile | Serve un Echo nella stessa rete |
| FauxmoESP | Sì (locale) | No | Non serve | Facile | Simile a Espalexa, richiede librerie Async |
| Sinric Pro | Sì (skill) | Sì | Necessario | Facile | Servono account e ID del dispositivo; il numero di dispositivi dipende dal piano |
| Home Assistant + ESPHome | Sì | Sì | Di solito per gli assistenti vocali | Media | Gestisce tutta la casa da un unico punto |
| Matter (core ESP32 3.x) | Sì | Sì | Non serve | Avanzata | Serve un hub o uno speaker compatibile Matter |
Materiale necessario e collegamenti
Negli esempi usiamo una scheda ESP32 o ESP8266, un modulo relè a un canale e, se vuoi, una striscia LED a 12 V pilotata tramite un MOSFET. Per la striscia scegli un MOSFET logic level come l'IRLZ44N, metti una resistenza da 220 Ω in serie al gate e una da 10 kΩ tra gate e GND; i dettagli sono nella guida usare un MOSFET.
| Collegamento | ESP32 | ESP8266 (NodeMCU / Wemos D1 Mini) |
|---|---|---|
| VCC del modulo relè | VIN (5 V) | VIN o 5V |
| GND del modulo relè | GND | GND |
| IN del modulo relè | GPIO 26 | D1 (GPIO 5) |
| Gate del MOSFET (striscia LED) | GPIO 25 | D2 (GPIO 4) |
| Pulsante (esempio Sinric Pro) | GPIO 0 (BOOT) | D3 (GPIO 0, FLASH) |

Metodo 1: un dispositivo Alexa locale con Espalexa
- Installa la libreria Espalexa (Christian Schwinne) dal Gestore librerie.
- Inserisci nome e password del Wi-Fi; ESP32 ed ESP8266 si collegano solo a reti a 2,4 GHz.
- Sostituisci i nomi in addDevice() con nomi in italiano, per esempio "Luce" e "Striscia LED"; Alexa riconosce meglio nomi brevi e ben distinti.
- Carica lo sketch, leggi l'indirizzo IP nel Monitor seriale e di' "Alexa, cerca dispositivi", oppure nell'app Alexa vai su Dispositivi > + > Aggiungi dispositivo > Altro > Rileva dispositivi.
- I dispositivi compaiono nell'app Alexa come luci di tipo Philips Hue; se vuoi, aggiungili a stanze e gruppi.
1#ifdef ESP8266
2 #include <ESP8266WiFi.h>
3#else
4 #include <WiFi.h>
5#endif
6#include <Espalexa.h>
7
8const char* WIFI_SSID = "WIFI_ADI"; // 2,4 GHz ağın adı / your 2.4 GHz network name
9const char* WIFI_PASS = "WIFI_SIFRESI";
10
11#ifdef ESP8266
12const int RELAY_PIN = 5; // D1
13const int LED_PIN = 4; // D2 (MOSFET üzerinden LED şerit / LED strip via MOSFET)
14#else
15const int RELAY_PIN = 26;
16const int LED_PIN = 25;
17#endif
18const int RELAY_ON = LOW; // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
19
20Espalexa espalexa;
21
22void setLed(uint8_t value) { // 0-255 parlaklık / brightness
23#if defined(ESP8266)
24 analogWrite(LED_PIN, value);
25#elif ESP_ARDUINO_VERSION_MAJOR >= 3
26 ledcWrite(LED_PIN, value);
27#else
28 ledcWrite(0, value);
29#endif
30}
31
32// Aç-kapa cihaz: röle / on-off device: relay
33void onLight(EspalexaDevice* d) {
34 bool on = d->getState();
35 digitalWrite(RELAY_PIN, on ? RELAY_ON : !RELAY_ON);
36 Serial.printf("Light: %s\n", on ? "ON" : "OFF");
37}
38
39// Kısılabilir cihaz: 0 = kapalı, 1-255 = parlaklık / dimmable device: 0 = off, 1-255 = brightness
40void onStrip(uint8_t brightness) {
41 setLed(brightness);
42 Serial.printf("Strip: %d%%\n", brightness * 100 / 255);
43}
44
45void setup() {
46 Serial.begin(115200);
47 pinMode(RELAY_PIN, OUTPUT);
48 digitalWrite(RELAY_PIN, !RELAY_ON); // başlangıçta kapalı / off at start
49#if defined(ESP8266)
50 pinMode(LED_PIN, OUTPUT);
51#elif ESP_ARDUINO_VERSION_MAJOR >= 3
52 ledcAttach(LED_PIN, 5000, 8); // 5 kHz, 8 bit
53#else
54 ledcSetup(0, 5000, 8);
55 ledcAttachPin(LED_PIN, 0);
56#endif
57 setLed(0);
58
59 WiFi.mode(WIFI_STA);
60 WiFi.begin(WIFI_SSID, WIFI_PASS);
61 while (WiFi.status() != WL_CONNECTED) {
62 delay(500);
63 Serial.print(".");
64 }
65 Serial.println(WiFi.localIP());
66
67 // Alexa'daki adlar: kendi dilinde yaz (Lampe, Lamba...) / names in Alexa: use your own language
68 espalexa.addDevice("Light", onLight, EspalexaDeviceType::onoff);
69 espalexa.addDevice("LED Strip", onStrip, 0);
70 espalexa.begin(); // 80. portta web sunucusu açar / starts a web server on port 80
71}
72
73void loop() {
74 espalexa.loop(); // Alexa isteklerini dinle / handle Alexa requests
75 delay(1);
76}Lo sketch definisce due dispositivi diversi. Light è di tipo EspalexaDeviceType::onoff, si accende e si spegne soltanto e pilota il relè; la sua funzione di callback riceve un puntatore a EspalexaDevice e legge lo stato con getState(). LED Strip è dimmerabile: il valore di luminosità 0–255 inviato da Alexa va direttamente all'uscita PWM, e 0 significa spento. La parte PWM distingue tra i core ESP32 2.x e 3.x: con il 3.x si usano ledcAttach(pin, frequenza, risoluzione) e ledcWrite(pin, valore), con il 2.x ledcSetup e ledcAttachPin. La regola più importante sta in loop(): espalexa.loop() va chiamato molto spesso; dei delay() lunghi fanno dire ad Alexa che il dispositivo non risponde.
| Comando | Esempio | Espalexa | Sinric Pro (Switch) |
|---|---|---|---|
| Accendere | Alexa, accendi la luce / Ok Google, accendi la luce | Sì | Sì |
| Spegnere | Alexa, spegni la striscia LED / Ok Google, spegni la luce | Sì | Sì |
| Luminosità | Alexa, imposta la striscia LED al 40 percento | Sì (tipo dimmable) | Con il tipo Dimmable Switch |
| Colore | Alexa, imposta la luce su blu | Sì (tipo color) | Con il tipo Light |
| Routine e gruppo | Alexa, buonanotte | Sì, con le routine dell'app | Sì |
Alexa non trova il dispositivo: risoluzione dei problemi di Espalexa
- Nessun Echo: l'app Alexa sul telefono da sola non può rilevare i dispositivi locali; la ricerca la fa un Echo nella rete.
- Reti diverse: ESP32 ed Echo devono essere sullo stesso router e nella stessa sottorete. Rete ospiti, isolamento dei client (AP isolation) o una rete IoT separata bloccano i messaggi multicast.
- Impostazioni del router: alcuni router dei provider e sistemi mesh filtrano il traffico SSDP e UPnP. Durante la ricerca tieni l'ESP32 vicino al router e lascia attivo il multicast (IGMP).
- Porta 80 occupata: se un altro web server nello stesso sketch usa la porta 80, Espalexa non funziona. Passa il tuo server a Espalexa con espalexa.begin(&server) oppure unisci i due.
- Nome cambiato: se hai cambiato un nome nel codice, elimina i vecchi dispositivi nell'app Alexa e ripeti la ricerca.
- Troppi dispositivi: il limite predefinito è di 10 dispositivi. Per averne di più scrivi #define ESPALEXA_MAXDEVICES 20 prima di includere Espalexa.h.
Metodo 2: Alexa e Google Home con Sinric Pro
- Crea un account sul sito di Sinric Pro e aggiungi un dispositivo di tipo Switch in Devices > Add Device; dagli il nome che pronuncerai.
- Copia nello sketch APP KEY e APP SECRET dalla pagina Credentials e il Device ID dall'elenco dei dispositivi.
- Installa la libreria SinricPro dal Gestore librerie; le librerie WebSockets e ArduinoJson necessarie vengono installate insieme.
- Nell'app Alexa attiva la skill Sinric Pro in Skill e giochi, collega il tuo account e avvia la ricerca dei dispositivi.
- Nell'app Google Home vai su + > Configura dispositivo > Compatibile con Google, cerca Sinric Pro e accedi con lo stesso account.
1#ifdef ESP8266
2 #include <ESP8266WiFi.h>
3#else
4 #include <WiFi.h>
5#endif
6#include <SinricPro.h>
7#include <SinricProSwitch.h>
8
9#define WIFI_SSID "WIFI_ADI"
10#define WIFI_PASS "WIFI_SIFRESI"
11#define APP_KEY "APP_KEY_BURAYA" // Sinric Pro > Credentials
12#define APP_SECRET "APP_SECRET_BURAYA"
13#define SWITCH_ID "CIHAZ_ID_BURAYA" // Sinric Pro > Devices
14
15#ifdef ESP8266
16const int RELAY_PIN = 5; // D1
17const int BUTTON_PIN = 0; // D3 (FLASH düğmesi / FLASH button)
18#else
19const int RELAY_PIN = 26;
20const int BUTTON_PIN = 0; // BOOT düğmesi / BOOT button
21#endif
22const int RELAY_ON = LOW;
23
24bool relayState = false;
25unsigned long lastPress = 0;
26
27void setRelay(bool on) {
28 relayState = on;
29 digitalWrite(RELAY_PIN, on ? RELAY_ON : !RELAY_ON);
30}
31
32// Alexa ya da Google Home'dan gelen komut / command from Alexa or Google Home
33bool onPowerState(const String& deviceId, bool& state) {
34 setRelay(state);
35 Serial.printf("Cloud: %s\n", state ? "ON" : "OFF");
36 return true; // komut uygulandı / command executed
37}
38
39void setup() {
40 Serial.begin(115200);
41 pinMode(RELAY_PIN, OUTPUT);
42 setRelay(false);
43 pinMode(BUTTON_PIN, INPUT_PULLUP);
44
45 WiFi.mode(WIFI_STA);
46 WiFi.begin(WIFI_SSID, WIFI_PASS);
47 while (WiFi.status() != WL_CONNECTED) {
48 delay(500);
49 Serial.print(".");
50 }
51
52 SinricProSwitch& mySwitch = SinricPro[SWITCH_ID];
53 mySwitch.onPowerState(onPowerState);
54 SinricPro.onConnected([]() { Serial.println("Sinric Pro: connected"); });
55 SinricPro.begin(APP_KEY, APP_SECRET);
56}
57
58void loop() {
59 SinricPro.handle(); // bulut bağlantısını canlı tut / keep the cloud link alive
60
61 // Fiziksel düğme: röleyi değiştir, durumu uygulamalara bildir / physical button: toggle and report
62 if (digitalRead(BUTTON_PIN) == LOW && millis() - lastPress > 500) {
63 lastPress = millis();
64 setRelay(!relayState);
65 SinricProSwitch& mySwitch = SinricPro[SWITCH_ID];
66 mySwitch.sendPowerStateEvent(relayState);
67 }
68}onPowerState viene chiamata ogni volta che Alexa o Google Home inviano un comando di accensione o spegnimento; restituire true comunica al cloud che il comando è stato eseguito, mentre con false l'assistente dice che il dispositivo non risponde. Il pulsante BOOT della scheda qui fa da interruttore fisico: commuta il relè e invia il nuovo stato al cloud con sendPowerStateEvent, così le app sul telefono mostrano sempre lo stato reale. L'attesa di mezzo secondo elimina i rimbalzi del pulsante ed evita di inviare al cloud più di un evento al secondo. Poiché i comandi passano da Internet, il ritardo è di solito tra mezzo secondo e un secondo.
Uso con ESP8266 (NodeMCU, Wemos D1 Mini)
Grazie alle righe #ifdef ESP8266 all'inizio, entrambi gli sketch si compilano anche per l'ESP8266; cambiano solo la libreria Wi-Fi e i numeri dei pin. Sull'ESP8266, D1 (GPIO 5) e D2 (GPIO 4) sono i pin più sicuri per un relè. D3 (GPIO 0), D4 (GPIO 2) e D8 (GPIO 15) devono avere livelli precisi all'avvio, quindi un relè collegato lì può impedire l'avvio della scheda o scattare per un attimo all'accensione. Il PWM dell'ESP8266 è generato via software; dal core 3.x analogWrite() usa di default l'intervallo 0–255, perciò puoi usare direttamente la luminosità inviata da Espalexa. Per i dettagli della scheda consulta la guida ESP8266 NodeMCU.
Idee di progetto: lampada, presa, ventilatore e striscia LED
- Presa smart: metti il relè in una scatola chiusa e aggiungi il controllo vocale al progetto presa smart con ESP32.
- Commutazione silenziosa: se il clic ti dà fastidio, usa un relè a stato solido (SSR) al posto di quello meccanico.
- Luce colorata: combina il tipo color di Espalexa con una striscia WS2812B e cambia colore con "Alexa, imposta la luce su rosso".
- Firmware pronto: per le strisce LED senza scrivere codice installa WLED, che include già Espalexa.
- Alimentazione compatta: con un HLK-PM01 ottieni 5 V direttamente dalla rete e il progetto entra in una scatola a muro.
- Ventilatore e stufetta: abbina il relè a un sensore di temperatura e gestisci il ventilatore sia in automatico sia a voce.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Alexa non trova il dispositivo | ESP sulla rete ospiti o nessun Echo nella rete | Stessa rete a 2,4 GHz e stessa sottorete; avvia la ricerca da un Echo |
| "Il dispositivo non risponde" | delay lungo in loop() o caduta del Wi-Fi | Elimina i delay, usa millis(), ricollega il Wi-Fi |
| Il relè non si spegne mai | Il modulo a 5 V non riconosce il segnale a 3,3 V o la logica LOW/HIGH è invertita | Cambia RELAY_ON; usa un modulo a 3,3 V o un transistor |
| Il relè scatta per un attimo all'avvio | Relè su un pin di boot | Scegli un pin sicuro, come GPIO 26 sull'ESP32 o D1 sull'ESP8266 |
| Sinric Pro non si collega | APP KEY, APP SECRET o Device ID errati | Ricopia i valori dal portale e controlla il Monitor seriale |
| Google Home non mostra il dispositivo | Account non collegato | Collega Sinric Pro in Compatibile con Google e sincronizza i dispositivi |
| Errore di compilazione "std::variant" | Sinric Pro 4.x o successivo con core ESP32 2.x | Aggiorna il core al 3.x o installa la versione 3.5.0 della libreria |
Far parlare un ESP32 con Alexa e Google Home è il primo passo verso la casa smart, e bastano un relè e poche righe di codice: Espalexa è locale e veloce, Sinric Pro offre una strada flessibile per entrambi gli assistenti. Nell'app BlueGrays trovi progetti ESP32 con connessione Wi-Fi, web server, mDNS e aggiornamento OTA, con schemi e codice passo passo, pronti per aggiungere il controllo vocale.
Domande frequenti
ESP32 con Alexa funziona senza un Echo?
Con Espalexa no, perché i dispositivi locali vengono rilevati da uno speaker Echo nella rete; l'app sul telefono da sola non basta. Senza Echo usa un servizio cloud come Sinric Pro: i comandi funzioneranno anche dall'app Alexa sul telefono.
Perché Alexa non rileva il mio ESP32?
Di solito ESP32 ed Echo sono su reti diverse, per esempio la rete ospiti del router o una banda a 5 GHz che l'ESP32 non può usare. Controlla anche che un altro web server non occupi la porta 80 e che dei delay lunghi non blocchino loop(). Dopo aver cambiato un nome, elimina i vecchi dispositivi nell'app e ripeti la ricerca.
Espalexa funziona con Google Home?
No. Espalexa imita il supporto locale Philips Hue di Alexa, e Google Home non usa questo metodo. Per Google Home servono Sinric Pro, Home Assistant o Matter.
Che differenza c'è tra Espalexa e FauxmoESP?
Entrambe registrano l'ESP come dispositivo locale in Alexa. Espalexa supporta luci dimmerabili e colorate e usa il web server standard, mentre FauxmoESP richiede librerie asincrone come AsyncTCP. Se sei all'inizio, Espalexa è più semplice da configurare.
Cosa serve per usare Sinric Pro con ESP32?
Un account Sinric Pro, l'ID del dispositivo creato e l'APP KEY e l'APP SECRET del tuo account. La scheda deve restare collegata a Internet, perché i comandi arrivano dal cloud. Piani e limiti di dispositivi possono cambiare nel tempo, quindi controlla le condizioni aggiornate quando ti registri.
È sicuro accendere una lampada a 230 V con ESP32 e Alexa?
Un modulo relè lo fa senza problemi tecnici, ma la tensione di rete è pericolosa per la vita. Monta tutto in una scatola chiusa, isolata e protetta da fusibile, e chiedi aiuto a un elettricista se non sei sicuro. Prova sempre prima con un carico a bassa tensione.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Lampeggio del LED interno dell'ESP32
Far lampeggiare il LED blu integrato nell'ESP32 DevKit V1. Non sono necessari componenti esterni! Il primo progetto da provare quando si acquista un ESP32. Il GPIO 2 è collegato al LED interno.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
Aggiungiamo all'ESP32 un servizio mDNS (Multicast DNS), così lo raggiungi con un nome host leggibile come bluegrays-esp.local invece che con un indirizzo IP. Anche se l'IP assegnato dal DHCP cambia, il dispositivo risponde sempre allo stesso nome. Un piccolo server web sulla scheda ti permette di controllare il LED dal browser all'indirizzo http://bluegrays-esp.local/.

Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)
Imparerai a caricare un nuovo firmware sull'ESP32 via Wi-Fi, senza cavo USB. Con la libreria ArduinoOTA l'ESP32 diventa visibile in rete e compare automaticamente come bluegrays-ota nella scheda "Network port" dell'Arduino IDE. Il primo caricamento avviene via USB, poi tutti gli aggiornamenti sono wireless: una funzione fondamentale per i dispositivi installati sul campo.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

