blinky-esp/main/main.cpp

static const char *TAG = "blinky";
#include <esp_log.h>

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

#include <esp_spiffs.h>
#include <nvs_flash.h>

#include "wifi.hpp"
#include "http_serv.hpp"
#include "ota.hpp"
#include "device.hpp"
#include "utils.hpp"
#include "leds.hpp"
#include "presets.hpp"
#include "utils.hpp"
#include "spi_leds.hpp"


// mDNS / NetBIOS

#include <mdns.h>
#include <lwip/apps/netbiosns.h>

static void start_mdns_service(const char *hostname) {
    // Initialize mDNS service
    ESP_ERROR_CHECK(mdns_init());

    // Set hostname
    mdns_hostname_set(hostname);

    // Set default instance
    mdns_instance_name_set("Blinky Lights");

    // NetBIOS too
    netbiosns_init();
    netbiosns_set_name(hostname);
}


// Dummy FS

static void start_filesystem() {
    ESP_LOGI(TAG, "Initializing filesystem");

    esp_vfs_spiffs_conf_t conf = {
        .base_path = "/spiffs",
        .partition_label = NULL,
        .max_files = 5,
        .format_if_mount_failed = true
    };

    // Use settings defined above to initialize and mount SPIFFS filesystem.
    // Note: esp_vfs_spiffs_register is an all-in-one convenience function.
    ESP_ERROR_CHECK(esp_vfs_spiffs_register(&conf));
}

#include <string>
#include <dirent.h>
#include <sys/stat.h>
#include <errno.h>

static void log_dir(const std::string &path) {
    struct stat st;
    int err = stat(path.c_str(), &st);
    if (err < 0) {
        ESP_LOGE(TAG, "%s %d", path.c_str(), errno);
    } else {
        ESP_LOGI(TAG, "%s %d", path.c_str(), st.st_size);
    }

    DIR *dir;
    if ((dir = opendir(path.c_str())) == NULL) {
        //ESP_LOGE(TAG, "Failed to open %s", path.c_str());
        return;
    }

    struct dirent *de;
    while ((de = readdir(dir)) != NULL) {
        log_dir(path + "/" + de->d_name);
    }

    closedir(dir);
}


static std::string read_file(const char *path) {
    std::string data;
    FILE *f = fopen(path, "r");
    if (!f) {
        ESP_LOGE(TAG, "Failed to read %s", path);
        return data;
    }
    constexpr size_t szbuf = 4096;
    char *buf = (char*)malloc(szbuf);
    size_t nread;
    while ((nread = fread(buf, 1, szbuf - 1, f)) > 0) {
        buf[nread] = '\0';
        data += buf;
    }
    fclose(f);
    free(buf);
    return data;
}

static void write_file(const char *path, const std::string &data) {
    FILE *f = fopen(path, "w");
    if (!f) {
        ESP_LOGE(TAG, "Failed to open %s", path);
        return;
    }
    const char *ptr = data.c_str();
    size_t remain = data.length();
    size_t nwritten = fwrite(ptr, 1, remain, f);
    if (nwritten != remain) {
        ESP_LOGE(TAG, "Failed to write to %s: %d/%d", path, nwritten, remain);
    }
    fclose(f);
}


std::string gen_config(bool is_on, const std::string &effect) {
    return std::string() + "{ "
            "\"state\": \"" + (is_on ? "ON" : "OFF") + "\", "
            "\"effect\": \"" + effect + "\""
        " }";
}


constexpr char config_path[] = "/spiffs/blinky.json";


// Entry Point

extern "C" void app_main(void) {
    // Initialize NVS for WiFi Data
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    // WiFi
    config_wifi();

    // mDNS
    start_mdns_service("blinky-jr");

    // HTTP Server
    httpd_handle_t server = start_webserver();

    // OTA Server
    start_ota_serv(server);

    // Dummy Filesystem
    start_filesystem();
    // TODO: Scrape this out
    log_dir("/spiffs");

    Device device("blinky-jr");

    cJSON *json = cJSON_Parse(read_file(config_path).c_str());
    if (json) {
        ESP_LOGI(TAG, "Setting config");
        device.set_json_config(json);
        cJSON_Delete(json);
    }

    LEDStrip *LEDs = new SPI_LEDs(39); //new TerminalLEDs();

    while (true) {
        ESP_LOGI(TAG, "Configuring LEDs");

        device.lock();
            const std::string &effect = device.get_effect();
            bool is_on = device.is_on();
            int length = device.get_strip_length();
            cJSON *json = device.make_json_config_locked();
        device.unlock();

        if (length != LEDs->getLength()) {
            LEDs->setLength(length);
        }

        const Pattern *pattern = Presets::find(effect);
        if (pattern) {
            LEDs->setPattern(pattern);
        } else {
            ESP_LOGW(TAG, "Could not find pattern '%s'", effect.c_str());
            pattern = LEDs->getPattern();
        }

        char *config = cJSON_PrintUnformatted(json);
        write_file(config_path, config);
        ESP_LOGI(TAG, "Saved config");

        cJSON_free(config);
        cJSON_Delete(json);

        if (length <= 0 || !pattern || !is_on) {
            if (!is_on) ESP_LOGI(TAG, "Device off");
            if (length <= 0) ESP_LOGW(TAG, "No LEDs configured");
            if (!pattern) ESP_LOGW(TAG, "No LED pattern set");
            ESP_LOGI(TAG, "Waiting for new config");

            device.wait();

        } else {
            ESP_LOGI(TAG, "Starting animation");

            int period_us = 1000000 / 60;
            int64_t start = time_us();
            int64_t target_us = start;
            int64_t total_delay_us = 0;
            int n_delays = 0;
            int64_t after_sleep_us = 0;
            int n_processes = 0;
            int64_t total_process_us = 0;
            while (true) {
                int64_t now = time_us();

                if (after_sleep_us > 0) {
                    total_process_us += now - after_sleep_us;
                    ++n_processes;
                }

                if (now - start >= 5000000) {
                    ESP_LOGI(TAG, "Average delay: %f ms", (double)total_delay_us / (n_delays * 1000));
                    total_delay_us = 0;
                    n_delays = 0;

                    ESP_LOGI(TAG, "Average processing: %f us", (double)total_process_us / n_processes);
                    total_process_us = 0;
                    n_processes = 0;

                    start = now;
                }

                int64_t delay_us = target_us - now;
                if (delay_us < 0) delay_us = 0;
                if (device.wait(delay_us / 1000)) {
                    // If the semaphore is set, go back to top of outer loop
                    break;
                }

                after_sleep_us = time_us();

                total_delay_us += (after_sleep_us - now);
                ++n_delays;

                LEDs->step();
                LEDs->show();

                target_us += period_us;
            }
        }
    }

    // Spin
}