/*
* Centralina Meteo ESP32 + OLED SSD1306 I2C 128x64
* SDA: GPIO 21, SCL: GPIO 22, indirizzo OLED: 0x3C.
* Librerie: Adafruit GFX Library, Adafruit SSD1306, Adafruit BusIO,
* ArduinoJson 7.x. Il task meteo usa FreeRTOS come nello sketch originale.
*/
#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ArduinoJson.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <cstring>
// ---------- Configurazione ----------
const char* WIFI_SSID = "Wokwi-GUEST";
const char* WIFI_PASSWORD = "";
constexpr uint8_t PIN_SDA = 21;
constexpr uint8_t PIN_SCL = 22;
constexpr uint32_t INTERVALLO_METEO_MS = 5UL * 60UL * 1000UL;
constexpr uint32_t RITENTA_METEO_MS = 60UL * 1000UL;
constexpr uint32_t MAX_ETA_METEO_MS = 10UL * 60UL * 1000UL;
const char* METEO_HOST = "api.open-meteo.com";
const char* METEO_URL =
"https://api.open-meteo.com/v1/forecast"
"?latitude=45.4642&longitude=9.1900"
"¤t=temperature_2m,rain,showers,weather_code"
"&timezone=Europe%2FRome&forecast_days=1";
Adafruit_SSD1306 display(128, 64, &Wire, -1);
// ---------- Dati condivisi ----------
struct Meteo {
bool valido = false;
bool piove = false;
float temperatura = 0;
float pioggiaMm = 0;
int codice = -1;
uint32_t aggiornatoMs = 0;
char ora[6] = "--:--";
};
Meteo meteoCondiviso;
portMUX_TYPE meteoMux = portMUX_INITIALIZER_UNLOCKED;
Meteo leggiMeteo();
void pubblicaMeteo(const Meteo& dati);
bool codiceIndicaPioggia(int codice);
bool scaricaMeteo(Meteo& nuovo);
void taskMeteo(void* parametri);
void aggiornaDisplay(const Meteo& dati, uint32_t adesso);
Meteo leggiMeteo() {
portENTER_CRITICAL(&meteoMux);
Meteo copia = meteoCondiviso;
portEXIT_CRITICAL(&meteoMux);
return copia;
}
void pubblicaMeteo(const Meteo& dati) {
portENTER_CRITICAL(&meteoMux);
meteoCondiviso = dati;
portEXIT_CRITICAL(&meteoMux);
}
// ---------- Interpretazione codici WMO ----------
bool codiceIndicaPioggia(int codice) {
switch (codice) {
case 51: case 53: case 55: case 56: case 57:
case 61: case 63: case 65: case 66: case 67:
case 80: case 81: case 82:
return true;
default:
return false;
}
}
// ---------- Download e diagnostica ----------
bool scaricaMeteo(Meteo& nuovo) {
if (WiFi.status() != WL_CONNECTED) {
Serial.println("Download annullato: WiFi non connesso.");
return false;
}
// Se fallisce qui, il problema e' nella risoluzione del nome DNS.
IPAddress indirizzo;
if (WiFi.hostByName(METEO_HOST, indirizzo) != 1) {
Serial.printf("Errore DNS: impossibile risolvere %s\n", METEO_HOST);
return false;
}
Serial.printf("DNS: %s -> %s\n", METEO_HOST, indirizzo.toString().c_str());
WiFiClientSecure client;
client.setInsecure(); // Prototipo: verifica del certificato TLS disabilitata.
client.setHandshakeTimeout(15); // Secondi.
HTTPClient http;
http.setConnectTimeout(15000); // Millisecondi.
http.setTimeout(15000);
http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
Serial.printf("GET %s\n", METEO_URL);
if (!http.begin(client, METEO_URL)) {
Serial.println("Impossibile inizializzare la richiesta HTTPS.");
return false;
}
http.addHeader("Accept", "application/json");
int stato = http.GET();
// I valori negativi sono errori locali della libreria, non stati HTTP.
if (stato <= 0) {
Serial.printf("Errore connessione (%d): %s\n", stato,
HTTPClient::errorToString(stato).c_str());
char messaggioTLS[160] = {};
int erroreTLS = client.lastError(messaggioTLS, sizeof(messaggioTLS));
if (erroreTLS != 0) {
Serial.printf("Dettaglio TLS (%d): %s\n", erroreTLS, messaggioTLS);
}
http.end();
return false;
}
// Un valore positivo e' uno stato HTTP restituito dal server.
if (stato != HTTP_CODE_OK) {
Serial.printf("Risposta del server: HTTP %d\n", stato);
Serial.println(http.getString().substring(0, 300));
http.end();
return false;
}
String risposta = http.getString();
http.end();
if (risposta.length() == 0) {
Serial.println("Risposta HTTP 200, ma corpo vuoto.");
return false;
}
JsonDocument doc; // ArduinoJson 7.x.
DeserializationError errore = deserializeJson(doc, risposta);
if (errore) {
Serial.printf("JSON non valido: %s\n", errore.c_str());
return false;
}
JsonObjectConst corrente = doc["current"].as<JsonObjectConst>();
if (corrente.isNull() ||
!corrente["rain"].is<float>() ||
!corrente["showers"].is<float>() ||
!corrente["weather_code"].is<int>() ||
!corrente["temperature_2m"].is<float>() ||
!corrente["time"].is<const char*>()) {
Serial.println("Risposta meteo incompleta.");
return false;
}
float pioggia = corrente["rain"].as<float>();
float rovesci = corrente["showers"].as<float>();
const char* ora = corrente["time"].as<const char*>();
if (pioggia < 0 || rovesci < 0 || strlen(ora) < 16) {
Serial.println("Valori meteo non validi.");
return false;
}
nuovo.pioggiaMm = pioggia + rovesci;
nuovo.codice = corrente["weather_code"].as<int>();
nuovo.temperatura = corrente["temperature_2m"].as<float>();
nuovo.piove = nuovo.pioggiaMm > 0 || codiceIndicaPioggia(nuovo.codice);
memcpy(nuovo.ora, ora + 11, 5);
nuovo.ora[5] = '\0';
nuovo.aggiornatoMs = millis();
nuovo.valido = true;
Serial.printf("Aggiornato %s: Temp=%.1f C, Pioggia=%.2f mm, Piove=%s\n",
nuovo.ora, nuovo.temperatura, nuovo.pioggiaMm,
nuovo.piove ? "SI" : "NO");
return true;
}
// ---------- Task meteo ----------
void taskMeteo(void*) {
WiFi.mode(WIFI_STA);
WiFi.setAutoReconnect(true);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
bool richiestaEseguita = false;
uint32_t ultimaRichiestaMs = 0;
uint32_t ultimaRiconnessioneMs = millis();
uint32_t intervalloMs = INTERVALLO_METEO_MS;
for (;;) {
uint32_t adesso = millis();
if (WiFi.status() != WL_CONNECTED) {
pubblicaMeteo(Meteo{});
richiestaEseguita = false;
if ((uint32_t)(adesso - ultimaRiconnessioneMs) >= 15000UL) {
Serial.println("Riconnessione WiFi...");
WiFi.disconnect();
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
ultimaRiconnessioneMs = millis();
}
}
else if (!richiestaEseguita ||
(uint32_t)(adesso - ultimaRichiestaMs) >= intervalloMs) {
Meteo nuovo;
bool ok = scaricaMeteo(nuovo);
pubblicaMeteo(nuovo);
intervalloMs = ok ? INTERVALLO_METEO_MS : RITENTA_METEO_MS;
ultimaRichiestaMs = millis();
richiestaEseguita = true;
}
vTaskDelay(pdMS_TO_TICKS(500));
}
}
// ---------- Display OLED ----------
void aggiornaDisplay(const Meteo& dati, uint32_t adesso) {
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0, 0);
display.print("METEO MILANO");
display.drawFastHLine(0, 10, 128, SSD1306_WHITE);
if (!dati.valido) {
display.setCursor(0, 25);
if (WiFi.status() != WL_CONNECTED) {
display.print("Connessione WiFi...");
display.setCursor(0, 40);
display.print("Attendere...");
} else {
display.print("Dati non disponibili");
display.setCursor(0, 40);
display.print("Attesa aggiornamento");
}
}
else if ((uint32_t)(adesso - dati.aggiornatoMs) > MAX_ETA_METEO_MS) {
display.setCursor(0, 25);
display.print("Dati meteo scaduti");
}
else {
display.setTextSize(2);
display.setCursor(0, 18);
display.print(dati.temperatura, 1);
display.setTextSize(1);
display.print(" C");
display.setCursor(0, 38);
display.print("Pioggia: ");
display.print(dati.pioggiaMm, 1);
display.print(" mm");
display.setCursor(0, 48);
display.print("Stato: ");
display.print(dati.piove ? "PIOVE" : "NON PIOVE");
display.setCursor(95, 56);
display.print(dati.ora);
}
display.display();
}
void setup() {
Serial.begin(115200);
Wire.begin(PIN_SDA, PIN_SCL);
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println("Errore inizializzazione OLED");
for (;;) delay(1000);
}
display.setTextWrap(false);
display.setTextColor(SSD1306_WHITE);
display.setRotation(2);
aggiornaDisplay(Meteo{}, millis());
BaseType_t risultato = xTaskCreatePinnedToCore(
taskMeteo, "TaskMeteo", 8192, nullptr, 1, nullptr, 0
);
if (risultato != pdPASS) {
Serial.println("Errore: impossibile creare TaskMeteo.");
for (;;) delay(1000);
}
}
void loop() {
// Leggi prima i dati: il timestamp non deve risultare futuro rispetto ad adesso.
Meteo datiCorrenti = leggiMeteo();
uint32_t adesso = millis();
aggiornaDisplay(datiCorrenti, adesso);
delay(1000);
}Loading
ssd1306
ssd1306