Core/Task.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.
 *
 * Task.h
 *
 * @author mikee47 mike@sillyhouse.net
 *
 *  Sming provides a task queue for applications to use. It can be used to defer processing
 *  from an interrupt service routine, but can also be used to provide a form of multi-tasking.
 *
 *  This class provides a simple way to create a task which runs continuously, or can be started
 *  and stopped as required.
 *
 *  You can see how this class is used in the `Basic_Tasks` sample.
 *
 *
 ****/
 
#pragma once
 
#include <SimpleTimer.h>
 
class Task
{
public:
    enum class State {
        Suspended,
        Sleeping,
        Running,
    };
 
    enum class Notify {
        None,
        Suspending,
        Resuming,
        Sleeping,
        Waking,
    };
 
    virtual ~Task()
    {
    }
 
    bool resume()
    {
        switch(state) {
        case State::Sleeping:
            sleepTimer.stop();
            notification = Notify::Waking;
            state = State::Running;
            return schedule();
        case State::Suspended:
            notification = Notify::Resuming;
            state = State::Running;
            return schedule();
        case State::Running:
            return true;
        default:
            assert(false);
            return false;
        }
    }
 
    void suspend()
    {
        switch(state) {
        case State::Sleeping:
            sleepTimer.stop();
            notify(Notify::Suspending);
            state = State::Suspended;
            break;
        case State::Running:
            notify(Notify::Suspending);
            state = State::Suspended;
            break;
        case State::Suspended:
            break;
        default:
            assert(false);
        }
    }
 
    void sleep(unsigned interval)
    {
        switch(state) {
        case State::Suspended:
        case State::Running:
            sleepTimer.initializeMs(
                interval,
                [](void* param) {
                    auto task = static_cast<Task*>(param);
                    task->notify(Notify::Waking);
                    task->state = State::Running;
                    task->service();
                },
                this);
            sleepTimer.startOnce();
            notify(Notify::Sleeping);
            state = State::Sleeping;
            break;
        case State::Sleeping:
            break;
        }
    }
 
protected:
    virtual void loop() = 0;
 
    virtual void onNotify(Notify code)
    {
    }
 
private:
    /*
     *
     */
    void notify(Notify code)
    {
        notification = Notify::None;
        onNotify(code);
    }
 
    bool schedule()
    {
        if(scheduled) {
            return true;
        }
 
        scheduled = System.queueCallback(
            [](uint32_t param) {
                auto task = reinterpret_cast<Task*>(param);
                task->scheduled = false;
                task->service();
            },
            uint32_t(this));
 
        return scheduled;
    }
 
    /*
     * Executed via task queue
     */
    void service()
    {
        if(state == State::Running) {
            if(notification != Notify::None) {
                notify(notification);
            }
            loop();
            schedule();
        }
    }
 
private:
    State state{State::Suspended};   
    Notify notification{Notify::None}; 
    bool scheduled{false};             
    SimpleTimer sleepTimer;
};