Pin RTC

Nel diagramma dei pin che hai allegato, la sigla RTC accanto ad alcuni GPIO non indica la presenza di un modulo Real Time Clock (RTC) hardware come il DS3231, ma ha un altro significato:

👉 RTC = “Real-Time Clock domain” (dominio di alimentazione RTC).

In pratica:

L’ESP32-S3 ha due domini di alimentazione interni:

1. Dominio principale (Digital Domain) – si spegne completamente quando il chip va in deep sleep.

2. Dominio RTC – resta alimentato anche in deep sleep per mantenere attivi alcuni pin, sensori o il timer interno.

Quindi:

I GPIO contrassegnati come RTC possono funzionare anche durante il deep sleep, ad esempio per:

• leggere un sensore touch o un pulsante che deve “svegliare” l’ESP32-S3,

• monitorare un pin di allarme esterno,

• oppure mantenere attivi timer e sensori integrati.

💡 Nota bene:
L’ESP32-S3 ha sì un piccolo RTC interno software/hardware (timer a bassa potenza), ma non mantiene l’ora reale dopo lo spegnimento — serve solo per contare il tempo nel deep sleep.
Per avere l’ora vera (data e ora correnti), serve un chip esterno come DS3231 o una sincronizzazione via NTP (rete).

🧠 Cos’è il “deep sleep”

Il deep sleep è una modalità in cui l’ESP32-S3 spegne quasi tutto il chip, tranne il dominio RTC (quello che hai visto indicato nei pin).
Serve per risparmiare corrente quando il microcontrollore non deve fare nulla per un po’.

In questo stato:

⚙️ Come si mette in Deep Sleep

Puoi entrare nel deep sleep con una semplice riga di codice.
Ecco un esempio base per farlo dormire per 5 secondi:

#include "esp_sleep.h"

void setup() {
  Serial.begin(115200);
  Serial.println("Vado in deep sleep per 5 secondi...");

  // Imposta timer di risveglio (in microsecondi)
  esp_sleep_enable_timer_wakeup(5 * 1000000);

  // Entra in deep sleep
  esp_deep_sleep_start();
}

void loop() {
  // Non viene mai eseguito, il chip dorme
}

👉 Quando chiami esp_deep_sleep_start(), il microcontrollore si spegne immediatamente.
Dopo 5 secondi, il timer RTC lo riaccende — e ricomincia dal setup(), come se fosse un reset.

🔔 Altri modi per “svegliarlo”

Puoi anche impostare un “evento” che lo riattivi, ad esempio:

1. Timer interno (come sopra)

sveglia dopo N secondi

2. Tocco su un pin touch (solo quelli con “TOUCHX”)

esp_sleep_enable_touchpad_wakeup();  
      

3. Segnale su un pin RTC (per esempio un pulsante)

esp_sleep_enable_ext0_wakeup(GPIO_NUM_33, 0); // sveglia se GPIO33 va LOW  
      

🔄 Cosa succede al risveglio

Quando si risveglia dal deep sleep:

• fa un reset completo del programma,

• le variabili in RAM vengono perse (tranne quelle nella RTC RAM, se usata),

• puoi distinguere che si è “svegliato” con:

   

  esp_sleep_wakeup_cause_t motivo = esp_sleep_get_wakeup_cause();

nel primo esempio con il timer, l’ESP32-S3 entra in deep sleep, dorme 5 secondi, si risveglia, rifà il setup(), e poi — se nel codice non c’è una condizione diversa — si rimette subito a dormire.
Quindi sì, resta in un ciclo “dormi–svegliati–dormi”.

Quello serve solo come esempio dimostrativo, ma nella pratica — come hai intuito — è molto più utile decidere tu quando dormire e quando svegliarlo con eventi esterni.

🔘 Esempio pratico: dorme su pulsante, si sveglia su sensore

Vediamo un esempio semplice:

• Premendo un pulsante l’ESP32-S3 entra in deep sleep.

• Poi si risveglia quando un sensore (collegato a un GPIO RTC) dà un segnale.

🔧 Schema logico

🧩

Codice di esempio

#include "esp_sleep.h"

#define PIN_SLEEP_BUTTON 0
#define PIN_WAKEUP_SENSOR 33

void setup() {
  Serial.begin(115200);
  delay(1000);
  
  // Controlla il motivo del risveglio
  esp_sleep_wakeup_cause_t motivo = esp_sleep_get_wakeup_cause();

  if (motivo == ESP_SLEEP_WAKEUP_EXT0) {
    Serial.println("✅ Risvegliato dal sensore esterno!");
  } else {
    Serial.println("⚙️ Avvio normale o reset manuale.");
  }

  // Imposta il pulsante per il deep sleep
  pinMode(PIN_SLEEP_BUTTON, INPUT_PULLUP);

  Serial.println("Premi il pulsante per entrare in deep sleep...");
}

void loop() {
  // Se premi il pulsante (va LOW)
  if (digitalRead(PIN_SLEEP_BUTTON) == LOW) {
    Serial.println("😴 Vado in deep sleep, mi sveglierà il sensore...");

    // Configura risveglio sul pin 33 (LOW)
    esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_WAKEUP_SENSOR, 0);

    // Avvia deep sleep
    esp_deep_sleep_start();
  }
}

�� Cosa succede:

1. All’accensione normale → “Avvio normale”.

2. Premi il pulsante → va in deep sleep.

3. Tutto si spegne tranne il dominio RTC.

4. Quando il sensore porta GPIO 33 a LOW → l’ESP32-S3 si risveglia e rifà il setup().

5. Vedi sul monitor seriale: “✅ Risvegliato dal sensore esterno!”.

🧠 Suggerimento:

Puoi anche combinare:

• un timer (es. 1 ora)

• e un evento esterno (es. vento forte o luce solare)

così l’ESP32-S3 si risveglia automaticamente o manualmente, a seconda delle esigenze.

Questa riga:

esp_sleep_enable_ext0_wakeup((gpio_num_t)PIN_WAKEUP_SENSOR, 0);

Serve per abilitare il risveglio da un segnale esterno (EXT0) su uno specifico pin RTC.

🔧 Significato dei parametri

1. (gpio_num_t)PIN_WAKEUP_SENSOR
   → è il numero del pin GPIO che userai come sorgente di risveglio.
   Deve essere uno dei pin che hanno la sigla RTC (perché restano alimentati durante il deep sleep).
   Esempio: GPIO33, GPIO32, GPIO34, ecc.

   (gpio_num_t) è solo un cast di tipo, cioè dice al compilatore:

   “tratta questa costante come un numero di pin valido per la funzione di wake-up”.

   Non cambia nulla a livello pratico, serve solo per evitare avvisi di compilazione.

2. 0
   → è il livello logico che farà “scattare” il risveglio:

   • 0 = si risveglia quando il pin va LOW (livello basso, 0V)

   • 1 = si risveglia quando il pin va HIGH (livello alto, 3.3V)

   Esempio:

   • Se colleghi un pulsante verso massa (GND) → userai 0

   • Se colleghi un sensore che porta il pin a 3.3V quando attivo → userai 1

🧠 Quindi, in parole semplici:

“Permetti all’ESP32-S3 di uscire dal deep sleep quando il pin specificato cambia al livello indicato (0 o 1).”

⚠️ Attenzione:

• esp_sleep_enable_ext0_wakeup() usa solo un pin alla volta.
  Se vuoi più sorgenti di risveglio, devi usare la variante:

   

  esp_sleep_enable_ext1_wakeup(mask, mode);

   

  che permette di specificare più pin insieme (usando una maschera di bit).