# ESP32 Dashboard rev_02

/********* Pleasedontcode.com **********

    Pleasedontcode thanks you for automatic code generation! Enjoy your code!

    - Terms and Conditions:
    You have a non-exclusive, revocable, worldwide, royalty-free license
    for personal and commercial use. Attribution is optional; modifications
    are allowed, but you're responsible for code maintenance. We're not
    liable for any loss or damage. For full terms,
    please visit pleasedontcode.com/termsandconditions.

    - Project: # ESP32 Dashboard
    - Version: 002
    - Source Code NOT compiled for: ESP32 DevKit V1
    - Source Code created on: 2026-03-14 23:03:27

********* Pleasedontcode.com **********/

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
    /* Initialize SSD1306 OLED display and display "Hello */
    /* World" text on screen with clear and refresh */
    /* updates */
/****** SYSTEM REQUIREMENT 2 *****/
    /* [POTA] Include POTA.h and secrets.h. Init POTA in */
    /* setup() with WiFi creds from secrets.h. Call */
    /* pota.loop() in loop(). */
/****** SYSTEM REQUIREMENT 3 *****/
    /* [POTA] MANDATORY OTA: call */
    /* pota.checkAndPerformOTA() in setup() after */
    /* begin(). Register pota.onOTAAvailable(cb) where cb */
    /* sets a bool flag. In loop() when flag is true call */
    /* pota.restart(). Without OTA the device cannot */
    /* update remotely. */
/****** END SYSTEM REQUIREMENTS *****/


/* START CODE */

/****** DEFINITION OF LIBRARIES *****/
#include <Wire.h>
#include <Adafruit_SSD1306.h>   //https://github.com/adafruit/Adafruit_SSD1306
#include <Adafruit_GFX.h>   //https://github.com/adafruit/Adafruit-GFX-Library
#include "secrets.h"
#include "POTA.h"

/****** FUNCTION PROTOTYPES *****/
void setup(void);
void loop(void);
void setupDashboard(void);
void setupDashboardCallbacks(void);
void onOTAAvailable(const char* version);

/***** DEFINITION OF I2C PINS *****/
const uint8_t myOLED_SSD1306OledDisplay_I2C_PIN_SDA_D21 = 21;
const uint8_t myOLED_SSD1306OledDisplay_I2C_PIN_SCL_D22 = 22;
const uint8_t myOLED_SSD1306OledDisplay_I2C_SLAVE_ADDRESS = 0x3C; // Standard I2C address for SSD1306

/***** OLED DISPLAY PARAMETERS *****/
const uint8_t OLED_SCREEN_WIDTH = 128; // SSD1306 OLED width in pixels
const uint8_t OLED_SCREEN_HEIGHT = 64; // SSD1306 OLED height in pixels
const int8_t OLED_RESET_PIN = -1; // Reset pin (-1 = no reset pin)

/****** DEFINITION OF LIBRARIES CLASS INSTANCES *****/
// Create SSD1306 display object with I2C address 0x3C
Adafruit_SSD1306 display(OLED_SCREEN_WIDTH, OLED_SCREEN_HEIGHT, &Wire, OLED_RESET_PIN);

// Create POTA instance for OTA and Dashboard functionality
POTA pota;

// Dashboard widget IDs
uint8_t dashboardHeader;
uint8_t statusIndicator;
uint8_t systemTemperature;
uint8_t systemUptime;
uint8_t systemMemory;
uint8_t ledToggle;
uint8_t deviceInfo;

// Device state variables
bool otaAvailable = false;
unsigned long startTime = 0;
uint32_t lastUpdateTime = 0;

/**
 * @brief Initialize dashboard with widgets
 * Configures all POTA dashboard widgets for monitoring and control
 */
void setupDashboard(void) {
    Serial.println("🎨 Configuring POTA dashboard widgets...");

    // Header separator with title and description
    dashboardHeader = pota.dashboard.addWidget(SEPARATOR_CARD, "📊 ESP32 Device Dashboard", 0, "Real-time monitoring and control interface for ESP32 DevKit V1 with OLED display integration");

    // Status indicator - shows current device status
    statusIndicator = pota.dashboard.addWidget(FEEDBACK_CARD, "System Status");
    pota.dashboard.setValue(statusIndicator, STATUS_SUCCESS);

    // Temperature slider - displays system temperature (read-only simulation)
    // Step 0.1 provides float values with 1 decimal precision
    systemTemperature = pota.dashboard.addWidget(SLIDER_CARD, "System Temperature (°C)", 0, "CPU Temperature", 0.1, 20, 85);
    pota.dashboard.setValue(systemTemperature, 45.5);

    // Uptime display - shows device runtime in seconds (read-only)
    // Step 1 provides integer values
    systemUptime = pota.dashboard.addWidget(SLIDER_CARD, "Uptime (seconds)", 0, "Time since device started", 1, 0, 2147483647);
    pota.dashboard.setValue(systemUptime, 0);

    // Memory usage - displays free heap memory
    // Step 100 provides values in 100-byte increments
    systemMemory = pota.dashboard.addWidget(SLIDER_CARD, "Free Memory (bytes)", 0, "Available heap memory", 100, 0, 4000000);
    pota.dashboard.setValue(systemMemory, 0);

    // LED toggle control - bidirectional widget for controlling LED
    ledToggle = pota.dashboard.addWidget(TOGGLE_BUTTON_CARD, "Onboard LED Control");
    pota.dashboard.setValue(ledToggle, false);

    // Device info display - shows firmware and hardware details
    deviceInfo = pota.dashboard.addWidget(FEEDBACK_CARD, "Device Information");
    pota.dashboard.setValue(deviceInfo, STATUS_INFO);

    Serial.println("✅ Dashboard widgets configured successfully!");
}

/**
 * @brief Register callbacks for dashboard widget interactions
 * Sets up event handlers for user interactions with dashboard widgets
 */
void setupDashboardCallbacks(void) {
    Serial.println("📡 Registering dashboard callbacks...");

    // LED toggle callback - handle on/off control from dashboard
    pota.dashboard.onUpdate(ledToggle, [](WidgetData data) {
        bool ledState = data.getBool();

        Serial.print("💡 LED control from dashboard: ");
        Serial.println(ledState ? "ON" : "OFF");

        // Control the onboard LED
        digitalWrite(LED_BUILTIN, ledState ? HIGH : LOW);

        // Update status feedback
        pota.dashboard.setValue(statusIndicator, ledState ? STATUS_SUCCESS : STATUS_NONE);

        // Update OLED display
        displayLEDStatus(ledState);
    });

    Serial.println("✅ Callbacks registered successfully!");
}

/**
 * @brief Callback invoked when OTA update is available
 * Registers availability of new firmware version
 *
 * @param version Pointer to version string of available update
 */
void onOTAAvailable(const char* version) {
    Serial.print("🔄 OTA Update available: ");
    Serial.println(version);

    otaAvailable = true;

    // Update dashboard status
    pota.dashboard.setValue(statusIndicator, STATUS_WARNING);

    // Update OLED display
    displayOTAAvailable(version);
}

/**
 * @brief Display LED status on OLED screen
 * Updates OLED display with current LED state
 *
 * @param isOn Current LED state (true = ON, false = OFF)
 */
void displayLEDStatus(bool isOn) {
    display.clearDisplay();
    display.setTextSize(2);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    display.println(F("Hello"));
    display.println(F("World"));

    display.setTextSize(1);
    display.setCursor(0, 40);
    display.print(F("LED: "));
    display.println(isOn ? F("ON") : F("OFF"));

    display.display();
}

/**
 * @brief Display OTA availability notification on OLED
 * Shows version information of available update
 *
 * @param version Pointer to version string of available update
 */
void displayOTAAvailable(const char* version) {
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    display.println(F("OTA Available!"));
    display.print(F("Version: "));
    display.println(version);
    display.println(F("Restarting..."));

    display.display();
}

/**
 * @brief Update system metrics on dashboard
 * Periodically updates temperature, uptime, and memory values
 */
void updateSystemMetrics(void) {
    // Only update every 5 seconds to avoid excessive updates
    if (millis() - lastUpdateTime < 5000) {
        return;
    }
    lastUpdateTime = millis();

    // Calculate uptime in seconds
    unsigned long uptimeSeconds = (millis() - startTime) / 1000;
    pota.dashboard.setValue(systemUptime, (int)uptimeSeconds);

    // Get free heap memory
    uint32_t freeHeap = 0;
    #ifdef ESP32
        freeHeap = ESP.getFreeHeap();
    #elif defined(ESP8266)
        freeHeap = ESP.getFreeHeap();
    #endif
    pota.dashboard.setValue(systemMemory, (int)freeHeap);

    // Simulate temperature reading (in real application, use ADC)
    // Temperature varies slightly around 45°C
    float tempBase = 45.5;
    float tempVariation = 2.0 * sin(uptimeSeconds / 10.0);
    float temperature = tempBase + tempVariation;
    pota.dashboard.setValue(systemTemperature, temperature);
}

void setup(void)
{
    // Initialize serial communication
    Serial.begin(115200);
    delay(2000);

    Serial.println("\n╔════════════════════════════════════════╗");
    Serial.println("║     OLED + POTA Dashboard Example      ║");
    Serial.println("╚════════════════════════════════════════╝\n");

    // Initialize the I2C communication with custom pins for ESP32
    Wire.begin(myOLED_SSD1306OledDisplay_I2C_PIN_SDA_D21, myOLED_SSD1306OledDisplay_I2C_PIN_SCL_D22);

    // Initialize the SSD1306 display with I2C address 0x3C
    if (!display.begin(SSD1306_SWITCHCAPVCC, myOLED_SSD1306OledDisplay_I2C_SLAVE_ADDRESS))
    {
        Serial.println("❌ SSD1306 initialization failed!");
        // Failed to initialize display - loop indefinitely
        while (1)
        {
            delay(100);
        }
    }

    // Clear the display buffer
    display.clearDisplay();

    // Set text size and color for "Hello World" text
    display.setTextSize(2); // Set text size to 2 (double size)
    display.setTextColor(SSD1306_WHITE); // Set text color to white

    // Set cursor position (x=0, y=0 at top-left corner)
    display.setCursor(0, 0);

    // Print "Hello World" text to the display buffer
    display.println(F("Hello"));
    display.println(F("World"));

    // Refresh the display to show the text on the screen
    display.display();

    Serial.println("✅ OLED Display initialized");

    // Configure onboard LED
    pinMode(LED_BUILTIN, OUTPUT);
    digitalWrite(LED_BUILTIN, LOW);

    // Initialize POTA with credentials from secrets.h
    Serial.println("\n🔧 Initializing POTA...");
    POTAError err = pota.begin(
        DEVICE_TYPE,
        FIRMWARE_VERSION,
        AUTH_TOKEN,
        SERVER_SECRET,
        WIFI_SSID,
        WIFI_PASSWORD
    );

    if (err != POTAError::SUCCESS) {
        Serial.print("❌ POTA initialization failed: ");
        Serial.println(POTA::errorToString(err));
        return;
    }

    Serial.println("✅ POTA initialized successfully");

    // Check for OTA updates immediately after initialization
    Serial.println("\n🔍 Checking for OTA updates...");
    err = pota.checkAndPerformOTA();

    if (err == POTAError::NO_UPDATE_AVAILABLE) {
        Serial.println("✅ Device is up to date");
    } else if (err != POTAError::SUCCESS) {
        Serial.print("⚠️  OTA check result: ");
        Serial.println(POTA::errorToString(err));
    }

    // Register OTA availability callback
    // This will be called if an update becomes available during runtime
    pota.onOTAAvailable(onOTAAvailable);

    // Register dashboard configuration callback
    pota.dashboard.setWidgetConfigCallback(setupDashboard);

    // Register callback for widget interactions
    pota.dashboard.setWidgetConfigCallback([](void) {
        setupDashboard();
        setupDashboardCallbacks();
    });

    // Initialize startup time for uptime calculation
    startTime = millis();
    lastUpdateTime = millis();

    Serial.println("✅ Setup complete");
    Serial.println("📱 Dashboard is ready! Connect to the POTA service.\n");
}

void loop(void)
{
    // Call POTA loop to handle WebSocket connections, OTA checks, and dashboard updates
    pota.loop();

    // Update system metrics for dashboard display
    updateSystemMetrics();

    // If OTA is available and callback was triggered, restart the device
    if (otaAvailable) {
        Serial.println("🔄 Restarting device for OTA update...");
        pota.restart();
        // restart() will not return - device will restart
    }

    // Small delay to prevent overwhelming the CPU
    delay(100);
}

/* END CODE */