wellhub_reloaded/main/App.cpp

/// © MiroZ 2024

#include "App.h"

#include <Arduino.h>
#include "Settings.h"
#include "errors.h"

#include "Ota.h"
#include "ProvisionSoftAP.h"


#define LED_PIN	26

static const char * TAG = "app";

App::App()
{

}

Led * App::getLed()
{
	return m_led;
}

CircBuffer * App::getBuffer()
{
	return & m_circ_buffer;
}

CommandProcessor * App::getCommandProcessor()
{
	return m_commandProcessor;
}

void App::init()
{
    #pragma message(WH_VERSION)
    ESP_LOGW(TAG, "Starting the app...");
    uint8_t mac[8];
    esp_read_mac(mac, ESP_MAC_WIFI_STA);
    //Lets report all programmed parameters
    ESP_LOGI(TAG, "mqtt_id: %s, wifi mac: %02x:%02x:%02x:%02x:%02x:%02x well_id: %u, group_id: %u", SETTINGS.mqtt.device_id,
        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], SETTINGS.device.tata_id, SETTINGS.device.group_id);

    ESP_LOGW(TAG, "Ver:1.00");


    m_led = new Led(LED_PIN);
    m_wifi = new Wifi();
    m_commandProcessor = new CommandProcessor(*this);
    m_ble_service = new BleService(*this);
    m_ble_service->start();

    bool needs_provision = true;
    bool first_attempt = true;
    bool connected = false;

    #if 0
    ESP_LOGI(TAG, "Scanning wifi networks...");
    int num_networks = WiFi.scanNetworks(false, false, false, 0);
    for(int n = 0; n < num_networks; n++)
    {
        ESP_LOGI(TAG, "%s, %d", WiFi.SSID(n).c_str(), WiFi.RSSI(n));
    }
    #endif

    // Main connection/provisioning cycle
    while(!connected)
    {
        needs_provision = true;

        // Try WiFi connections (provisioned networks + fallback)
        if(SETTINGS.wifi.num > 0 || !first_attempt)
        {
            if(!first_attempt)
            {
                ESP_LOGI(TAG, "Retrying WiFi connections after provisioning timeout...");
                m_wifi->pause(false); // Resume WiFi task
            }
            else
            {
                ESP_LOGI(TAG, "Trying provisioned networks...");
                m_wifi->start();
            }

            m_led->setColor(0, 255, 0);
            Wifi::WIFI_STATUS wifi_status = m_wifi->waitForConnection();
            ESP_LOGI(TAG, "WiFi final status: %d", (int)wifi_status);

            if(wifi_status == Wifi::WIFI_STATUS::CONNECTED)
            {
                ESP_LOGI(TAG, "Connected to WiFi successfully");
                
                // Sync time
                ESP_LOGI(TAG, "Getting local time...");
                struct tm timeinfo;
                int tries = 5;
                while (tries--)
                {
                    configTime(0, 0, "pool.ntp.org");
                    if(getLocalTime(&timeinfo))
                    {
                        ESP_LOGI(TAG, "pool.ntp.org ok");
                        break;
                    }
                    else
                        ESP_LOGE(TAG, "pool.ntp.org Failed");
                }
                
                needs_provision = false;
                connected = true;
            }
            else
            {
                ESP_LOGI(TAG, "All WiFi connections failed, will enter provisioning mode");
                m_wifi->pause(true);
            }
        }
        else if(first_attempt)
        {
            // No provisioned networks - try fallback directly
            ESP_LOGI(TAG, "No provisioned networks, trying fallback...");
            m_led->setColor(0, 255, 0);
            m_wifi->start();
            Wifi::WIFI_STATUS wifi_status = m_wifi->waitForConnection();
            
            if(wifi_status == Wifi::WIFI_STATUS::CONNECTED)
            {
                ESP_LOGI(TAG, "Connected to fallback network");
                
                // Sync time
                ESP_LOGI(TAG, "Getting local time...");
                struct tm timeinfo;
                int tries = 5;
                while (tries--)
                {
                    configTime(0, 0, "pool.ntp.org");
                    if(getLocalTime(&timeinfo))
                    {
                        ESP_LOGI(TAG, "pool.ntp.org ok");
                        break;
                    }
                    else
                        ESP_LOGE(TAG, "pool.ntp.org Failed");
                }
                
                needs_provision = false;
                connected = true;
            }
            else
            {
                ESP_LOGI(TAG, "Fallback connection failed");
                m_wifi->pause(true);
            }
        }

        // Enter provisioning mode if needed
        if(needs_provision && !connected)
        {
            ESP_LOGI(TAG, "Entering provisioning mode for 10 minutes...");
            m_led->setPulse(0, 0, 255);
            
            // Start provisioning mode in WiFi
            m_wifi->startProvisioning();
            
            // Start the provision server
            ProvisionSoftAP provision(80);
            provision.start();
            
            // Wait for either successful provisioning or timeout
            ESP_LOGI(TAG, "Waiting for provisioning (10 minute timeout)...");
            while(m_wifi->status() == Wifi::WIFI_STATUS::PROVISIONING)
            {
                if(m_wifi->isProvisioningTimedOut())
                {
                    ESP_LOGW(TAG, "Provisioning timeout reached (10 minutes)");
                    break;
                }
                
                // You could add logic here to check if new credentials were received
                // and attempt immediate connection if so
                
                delay(1000);
            }
            
            // Stop provisioning
            ESP_LOGI(TAG, "Stopping provisioning mode...");
            // provision.stop(); // Add this method to ProvisionSoftAP if available
            m_wifi->stopProvisioning();
            
            ESP_LOGI(TAG, "Provisioning period ended, will retry connections in 5 seconds...");
            delay(5000);
        }
        
        first_attempt = false;
    }

    ESP_LOGI(TAG, "WiFi connection established, continuing with app initialization...");

    otaCheck();
    
    // m_led->setPulse(255, 0, 255);
    m_led->allOff();

    m_mqtt_service = new MqttService(*this);
    m_mqtt_service->start();

    m_sensor_service = new SensorService(*this);
    m_sensor_service->start();
}

void App::otaCheck()
{
	Ota ota(*this);
	ota.start();
}

void App::start()
{

}

void App::readSensors()
{

}

void App::reportSensors()
{

}