System.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * System.h
 *
 * @author: 14/8/2018 - mikee47 <mike@sillyhouse.net>
 *
 *  When SystemClass::onReady method called, the callback is only queued if the
 *  system is not actually ready; there is otherwise no point in queueing the
 *  callback as it would never get invoked. To avoid unpredictable behaviour and
 *  simplify application code, the callback is invoked immediately in this situation.
 *
 *  Global task queue added to class, initialised at system startup.
 *
 */

#pragma once

#include <esp_systemapi.h>
#include <Delegate.h>
#include <Interrupts.h>

using TaskCallback32 = void (*)(uint32_t param);

using TaskCallback = void (*)(void* param);

using TaskDelegate = Delegate<void()>;

using SystemReadyDelegate = TaskDelegate;

class ISystemReadyHandler
{
public:
    virtual ~ISystemReadyHandler()
    {
    }

    virtual void onSystemReady() = 0;
};

enum CpuFrequency {
    eCF_80MHz = 80,
    eCF_125MHz = 125,
    eCF_133MHz = 133,
    eCF_160MHz = 160,
    eCF_240MHz = 240,
};

enum DeepSleepOptions {
    eDSO_RF_CAL_BY_INIT_DATA = 0, 
    eDSO_RF_CAL_ALWAYS = 1,       
    eDSO_RF_CAL_NEVER = 2,        
    eDSO_DISABLE_RF =
        4, 
};

enum SystemState {
    eSS_None,        
    eSS_Intializing, 
    eSS_Ready        
};

class SystemClass
{
public:
    SystemClass()
    {
    }

    static bool initialize();

    bool isReady()
    {
        return state == eSS_Ready;
    }

    void restart(unsigned deferMillis = 0);

    bool setCpuFrequency(CpuFrequency freq)
    {
        return system_update_cpu_freq(freq);
    }

    CpuFrequency getCpuFrequency()
    {
        return static_cast<CpuFrequency>(system_get_cpu_freq());
    }

    bool deepSleep(uint32_t timeMilliseconds, DeepSleepOptions options = eDSO_RF_CAL_BY_INIT_DATA);

    void onReady(SystemReadyDelegate readyHandler)
    {
        queueCallback(readyHandler);
    }

    void onReady(ISystemReadyHandler* readyHandler)
    {
        if(readyHandler != nullptr) {
            queueCallback([](void* param) { static_cast<ISystemReadyHandler*>(param)->onSystemReady(); }, readyHandler);
        }
    }

    static bool IRAM_ATTR queueCallback(TaskCallback32 callback, uint32_t param = 0);

    __forceinline static bool IRAM_ATTR queueCallback(TaskCallback callback, void* param = nullptr)
    {
        return queueCallback(reinterpret_cast<TaskCallback32>(callback), reinterpret_cast<uint32_t>(param));
    }

    __forceinline static bool IRAM_ATTR queueCallback(InterruptCallback callback)
    {
        return queueCallback(reinterpret_cast<TaskCallback>(callback));
    }

    static bool queueCallback(TaskDelegate callback);

    static unsigned getTaskCount()
    {
#ifdef ENABLE_TASK_COUNT
        return taskCount;
#else
        return 255;
#endif
    }

    static unsigned getMaxTaskCount()
    {
#ifdef ENABLE_TASK_COUNT
        return maxTaskCount;
#else
        return 255;
#endif
    }

private:
    static void taskHandler(os_event_t* event);

private:
    static SystemState state;
    static os_event_t taskQueue[]; 
#ifdef ENABLE_TASK_COUNT
    static volatile uint8_t taskCount;  
    static volatile uint8_t maxTaskCount; 
#endif
};

extern SystemClass System;