widget-display.cpp

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Preferences.h>
#include <time.h>
#include <math.h>

// config
#define WIFI_SSID   "NOME_REDE"     // "Wokwi-GUEST" if using wokwi simulator
#define WIFI_PASS   "SENHA_REDE"   // "" on wokwi

// weather API
#define OWM_API_KEY "CHAVE_OWM" 
#define OWM_CIDADE  "Sao Paulo"
#define OWM_PAIS    "BR"

// time zone
#define NTP_OFFSET  -10800

// buttons
#define BOTAO_PROX  12
#define BOTAO_ANT   14

// hardware
#define LARG_TELA   128
#define ALT_TELA     64
#define OLED_RESET   -1
#define OLED_ADDR   0x3C
#define DEBOUNCE_MS  200

Adafruit_SSD1306 display(LARG_TELA, ALT_TELA, &Wire, OLED_RESET);
Preferences       prefs;

// modes
enum AppMode {
    MODO_RELOGIO = 0,
    MODO_CLIMA,
    MODO_MUSICA,
    MODO_TOTAL
};

AppMode modoAtual = MODO_RELOGIO;

const char* TITULOS_MODOS[MODO_TOTAL] = {
    " Relogio",
    " Clima",
    " Musica"
};

// display region
struct Regiao { int x, y, w, h; };

const Regiao CIMA  = {0,  0,  128, 12};
const Regiao CORPO = {0,  13, 128, 43};
const Regiao BAIXO = {0,  57, 128,  7};

void limpaRegiao(Regiao r) {
    display.fillRect(r.x, r.y, r.w, r.h, SSD1306_BLACK);
}

// header and base
void renderCabecalho(const char* titulo) {
    limpaRegiao(CIMA);
    display.drawFastHLine(0, 11, 128, SSD1306_WHITE);

    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(2, 2);
    display.print(titulo);

    // mode indicator
    for (int i = 0; i < (int)MODO_TOTAL; i++) {
        int x = 128 - (MODO_TOTAL - i) * 7;
        if (i == (int)modoAtual)
            display.fillCircle(x, 5, 2, SSD1306_WHITE);
        else
            display.drawCircle(x, 5, 2, SSD1306_WHITE);
    }
}

// clock mode
struct EstadoRelogio {
    bool ntpSincronizado;
    int  hora, minuto, segundo;
    int  dia, mes, ano;
    char diaSemana[4];
};

EstadoRelogio relogio = {false, 0, 0, 0, 1, 1, 2026, "---"};

const char* DIAS_SEMANA[] = {"Dom","Seg","Ter","Qua","Qui","Sex","Sab"};

void sincronizaNTP() {
    if (WiFi.status() != WL_CONNECTED) return;
    configTime(NTP_OFFSET, 0, "pool.ntp.org");
}

void atualizaRelogio() {
    struct tm timeinfo;
    if (getLocalTime(&timeinfo)) {
        relogio.hora     = timeinfo.tm_hour;
        relogio.minuto   = timeinfo.tm_min;
        relogio.segundo  = timeinfo.tm_sec;
        relogio.dia      = timeinfo.tm_mday;
        relogio.mes      = timeinfo.tm_mon + 1;
        relogio.ano      = timeinfo.tm_year + 1900;
        strncpy(relogio.diaSemana, DIAS_SEMANA[timeinfo.tm_wday], 4);
        relogio.ntpSincronizado = true;
    } else {
        // fallback 
        static unsigned long ultimo = 0;
        if (millis() - ultimo >= 1000UL) {
            ultimo = millis();
            if (++relogio.segundo >= 60) { relogio.segundo = 0;
            if (++relogio.minuto  >= 60) { relogio.minuto  = 0;
            if (++relogio.hora    >= 24) { relogio.hora    = 0;
                                        relogio.dia++;       }}}
        }
    }
}

void renderRelogio() {
    limpaRegiao(CORPO);

    char bufHora[6], bufSeg[3], bufData[18];
    sprintf(bufHora, "%02d:%02d",    relogio.hora, relogio.minuto);
    sprintf(bufSeg,  "%02d",         relogio.segundo);
    sprintf(bufData, "%s %02d/%02d/%04d",
            relogio.diaSemana, relogio.dia, relogio.mes, relogio.ano);

    // hour
    display.setTextSize(3);
    int xHora = (LARG_TELA - 6 * 3 * 5) / 2;
    display.setCursor(xHora, CORPO.y + 4);
    display.print(bufHora);

    // sec
    display.setTextSize(1);
    display.setCursor(110, CORPO.y + 10);
    display.print(bufSeg);

    // date
    int xData = (LARG_TELA - (int)strlen(bufData) * 6) / 2;
    display.setCursor(xData, CORPO.y + 32);
    display.print(bufData);

    // ANTP sinc
    if (relogio.ntpSincronizado) {
        display.setCursor(120, CORPO.y + 32);
        display.print("*");
    }
}

// weather mode
struct EstadoClima {
    char  descricao[24];
    int   temperatura;
    int   sensacao;
    int   humidade;
    float vento;            // km/h
    bool  dadosValidos;
    unsigned long ultimaBusca;
};

EstadoClima clima = {"---", 0, 0, 0, 0.0f, false, 0};

#define INTERVALO_CLIMA 300000UL   

// icons
const uint8_t ICO_SOL[] PROGMEM = {
    0b00010000, 0b01010100, 0b00111000, 0b11111110,
    0b00111000, 0b01010100, 0b00010000, 0b00000000
};
const uint8_t ICO_NUVEM[] PROGMEM = {
    0b00000000, 0b00111000, 0b01111100, 0b11111110,
    0b11111110, 0b01111100, 0b00000000, 0b00000000
};
const uint8_t ICO_CHUVA[] PROGMEM = {
    0b00111000, 0b01111100, 0b11111110, 0b01111100,
    0b00101000, 0b01000100, 0b00101000, 0b01000100
};
const uint8_t ICO_NEVE[] PROGMEM = {
    0b00010000, 0b01010100, 0b00111000, 0b11010110,
    0b00111000, 0b01010100, 0b00010000, 0b00000000
};
const uint8_t ICO_TEMPESTADE[] PROGMEM = {
    0b00111100, 0b01111110, 0b11111110, 0b01111100,
    0b00011000, 0b00110000, 0b00011000, 0b00000000
};

void desenhaIconeClima(int x, int y) {
    const uint8_t* ico = ICO_NUVEM;
    String d = String(clima.descricao);
    d.toLowerCase();
    if      (d.indexOf("sol")    >= 0 || d.indexOf("clear") >= 0) ico = ICO_SOL;
    else if (d.indexOf("chuva")  >= 0 || d.indexOf("rain")  >= 0) ico = ICO_CHUVA;
    else if (d.indexOf("neve")   >= 0 || d.indexOf("snow")  >= 0) ico = ICO_NEVE;
    else if (d.indexOf("trovoada")>=0 || d.indexOf("thunder")>=0) ico = ICO_TEMPESTADE;
    display.drawBitmap(x, y, ico, 8, 8, SSD1306_WHITE);
}

void buscaClima() {
    if (WiFi.status() != WL_CONNECTED) return;
    if (clima.dadosValidos && millis() - clima.ultimaBusca < INTERVALO_CLIMA) return;

    HTTPClient http;
    char url[256];
    snprintf(url, sizeof(url),
        "http://api.openweathermap.org/data/2.5/weather"
        "?q=%s,%s&appid=%s&units=metric&lang=pt_br",
        OWM_CIDADE, OWM_PAIS, OWM_API_KEY);

    http.begin(url);
    int code = http.GET();

    if (code == 200) {
        String payload = http.getString();
        StaticJsonDocument<1024> doc;
        if (!deserializeJson(doc, payload)) {
            clima.temperatura = (int)roundf((float)doc["main"]["temp"]);
            clima.sensacao    = (int)roundf((float)doc["main"]["feels_like"]);
            clima.humidade    = doc["main"]["humidity"];
            clima.vento       = (float)doc["wind"]["speed"] * 3.6f;
            const char* d     = doc["weather"][0]["description"];
            if (d) strncpy(clima.descricao, d, sizeof(clima.descricao) - 1);
            clima.dadosValidos = true;
            clima.ultimaBusca  = millis();
        }
    }
    http.end();
}

void renderClima() {
    limpaRegiao(CORPO);

    if (!clima.dadosValidos) {
        display.setTextSize(1);
        display.setCursor(14, CORPO.y + 16);
        display.print("Buscando dados...");
        return;
    }

    desenhaIconeClima(2, CORPO.y + 2);

    char desc[24];
    strncpy(desc, clima.descricao, sizeof(desc) - 1);
    desc[0] = toupper(desc[0]);
    display.setTextSize(1);
    display.setCursor(14, CORPO.y + 2);
    display.print(desc);

    // temp
    display.setTextSize(2);
    display.setCursor(2, CORPO.y + 14);
    display.print(clima.temperatura);
    display.setTextSize(1);
    display.print((char)247);  
    display.print("C");

    // sensation, humidity, wind
    display.setCursor(60, CORPO.y + 14);
    display.print("Sens:"); display.print(clima.sensacao); display.print((char)247);

    display.setCursor(60, CORPO.y + 24);
    display.print("Hum: "); display.print(clima.humidade); display.print("%");

    display.setCursor(60, CORPO.y + 34);
    display.print("Vento:"); display.print((int)clima.vento); display.print("km/h");
}

// music mode
#define NUM_BARRAS        16
#define ALTURA_MAX        (CORPO.h - 4)
#define INTERVALO_ESPECTRO 80
#define PICO_HOLD_MS       800
#define PICO_QUEDA_MS      50

int           espectro[NUM_BARRAS];
int           espectroAnt[NUM_BARRAS];
int           pico[NUM_BARRAS];
unsigned long tempoPico[NUM_BARRAS];
float         envelope[NUM_BARRAS];
unsigned long ultimoEspectro = 0;

// simulated spectrum
void inicializaEspectro() {
    for (int i = 0; i < NUM_BARRAS; i++) {
        espectro[i]  = 0;
        espectroAnt[i] = 0;
        pico[i]      = 0;
        tempoPico[i] = 0;
        float norm   = (float)i / (NUM_BARRAS - 1);
        envelope[i]  = 0.3f + 0.7f * sinf(norm * 3.14159f);
    }
}

void atualizaEspectro() {
    if (millis() - ultimoEspectro < (unsigned long)INTERVALO_ESPECTRO) return;
    ultimoEspectro = millis();

    for (int i = 0; i < NUM_BARRAS; i++) {
        espectroAnt[i] = espectro[i];

        int alvo = (int)(random(4, ALTURA_MAX) * envelope[i]);

        espectro[i] = (espectroAnt[i] * 6 + alvo * 4) / 10;

        if (espectro[i] > pico[i]) {
            pico[i]      = espectro[i];
            tempoPico[i] = millis();
        } else if (millis() - tempoPico[i] > PICO_HOLD_MS) {
            unsigned long tempoApos = millis() - tempoPico[i] - PICO_HOLD_MS;
            if (tempoApos > (unsigned long)PICO_QUEDA_MS * (pico[i] - espectro[i])) {
                if (pico[i] > 0) pico[i]--;
            }
        }
    }
}

void renderEspectro() {
    limpaRegiao(CORPO);

    int largBarra = CORPO.w / NUM_BARRAS;   

    for (int i = 0; i < NUM_BARRAS; i++) {
        int h    = espectro[i];
        int x    = CORPO.x + i * largBarra;
        int y    = CORPO.y + CORPO.h - h;

        display.fillRect(x + 1, y, largBarra - 2, h, SSD1306_WHITE);

        if (pico[i] > 2) {
            int yPico = CORPO.y + CORPO.h - pico[i] - 2;
            display.drawFastHLine(x + 1, yPico, largBarra - 2, SSD1306_WHITE);
        }
    }
}

// config
void salvaConfiguracoes() {
    prefs.begin("widget", false);
    prefs.putInt("modo", (int)modoAtual);
    prefs.end();
}

void carregaConfiguracoes() {
    prefs.begin("widget", true);
    int m = prefs.getInt("modo", 0);
    if (m >= 0 && m < (int)MODO_TOTAL) modoAtual = (AppMode)m;
    prefs.end();
}

// buttons
unsigned long ultimoBotao = 0;

bool proximoApertado()   { return digitalRead(BOTAO_PROX) == LOW; }
bool anteriorApertado()  { return digitalRead(BOTAO_ANT)  == LOW; }

void verificaBotoes() {
    if (millis() - ultimoBotao < DEBOUNCE_MS) return;

    if (proximoApertado()) {
        modoAtual   = (AppMode)((modoAtual + 1) % MODO_TOTAL);
        salvaConfiguracoes();
        ultimoBotao = millis();
        return;
    }

    if (anteriorApertado()) {
        modoAtual   = (AppMode)((modoAtual + MODO_TOTAL - 1) % MODO_TOTAL);
        salvaConfiguracoes();
        ultimoBotao = millis();
    }
}

// render
unsigned long ultimaRenderizacao = 0;
#define INTERVALO_RENDER 100   

void renderModoAtual() {
    switch (modoAtual) {
        case MODO_RELOGIO: renderRelogio();  break;
        case MODO_CLIMA:   renderClima();    break;
        case MODO_MUSICA:  renderEspectro(); break;
        default: break;
    }
}

void renderFrame() {
    renderCabecalho(TITULOS_MODOS[modoAtual]);
    renderModoAtual();
    limpaRegiao(BAIXO);
    display.display();
}

// boot screen
void splash() {
    display.clearDisplay();
    display.drawRect(1, 1, 126, 62, SSD1306_WHITE);
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(20, 10); display.print("WIDGET DISPLAY");
    display.setCursor(18, 38); display.print("Inicializando...");
    display.display();
    delay(1500);
}

void telaConexaoWifi() {
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(4, 4);  display.print("Conectando WiFi:");
    display.setCursor(4, 16); display.print(WIFI_SSID);
    display.display();

    WiFi.begin(WIFI_SSID, WIFI_PASS);

    int tentativas = 0;
    while (WiFi.status() != WL_CONNECTED && tentativas < 20) {
        delay(500);
        display.print(".");
        display.display();
        tentativas++;
    }

    display.setCursor(4, 34);
    if (WiFi.status() == WL_CONNECTED) {
        display.print("OK! IP: ");
        display.println(WiFi.localIP());
    } else {
        display.print("offline");
    }
    display.display();
    delay(1200);
}

void setup() {
    Serial.begin(115200);
    Serial.println("\n=== Widget Display ===");

    pinMode(BOTAO_PROX, INPUT_PULLUP);
    pinMode(BOTAO_ANT,  INPUT_PULLUP);

    if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) {
        Serial.println("ERRO: SSD1306 nao encontrado. Verifique I2C.");
        while (true) delay(1000);
    }
    display.setTextWrap(false);
    display.clearDisplay();

    splash();
    telaConexaoWifi();
    carregaConfiguracoes();
    sincronizaNTP();
    inicializaEspectro();
    buscaClima();

    Serial.println("Sistema pronto.");
}


void loop() {
    verificaBotoes();

    atualizaRelogio();

    if (modoAtual == MODO_CLIMA)  buscaClima();
    if (modoAtual == MODO_MUSICA) atualizaEspectro();

    if (millis() - ultimaRenderizacao >= INTERVALO_RENDER) {
        ultimaRenderizacao = millis();
        renderFrame();
    }
}