mn_task.hpp

Go to the documentation of this file.

 
#ifndef MINLIB_ESP32_THREAD_
#define MINLIB_ESP32_THREAD_
 
#include "mn_config.hpp"
 
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
#include <freertos/task.h>
 
#include <string>
 
#include "mn_autolock.hpp"
#include "mn_error.hpp"
#include "mn_timespan.hpp"
#include "mn_sleep.hpp"
#include "mn_micros.hpp"
#include "mn_eventgroup.hpp"
 
namespace mn {
 
  class  basic_task : MN_ONSIGLETN_CLASS {
  public:
    enum  class priority {
      Idle = MN_THREAD_CONFIG_CORE_PRIORITY_IDLE,           
      Low = MN_THREAD_CONFIG_CORE_PRIORITY_LOW,             
      Normal = MN_THREAD_CONFIG_CORE_PRIORITY_NORM,         
      HalfCritical = MN_THREAD_CONFIG_CORE_PRIORITY_HALFCRT,
      Urgent = MN_THREAD_CONFIG_CORE_PRIORITY_URGENT,       
      Critical = MN_THREAD_CONFIG_CORE_PRIORITY_CRITICAL    
    };
 
    enum class state {
      Running = 0,    
      Ready,                
      Blocked,          
      Suspended,          
      Deleted           
    };
  public:
    using native_handle_type = xTaskHandle;
 
    basic_task() noexcept : basic_task(" ", priority::Normal, MN_THREAD_CONFIG_MINIMAL_STACK_SIZE) { }
    explicit basic_task(std::string strName, basic_task::priority uiPriority = basic_task::priority::Normal,
        unsigned short  usStackDepth = MN_THREAD_CONFIG_MINIMAL_STACK_SIZE) noexcept;
 
 
    virtual ~basic_task();
 
    virtual int           start(int uiCore = MN_THREAD_CONFIG_DEFAULT_CORE);
 
    int                   kill();
 
 
    bool                  is_running();
 
    std::string          get_name();
    basic_task::priority get_priority();
    unsigned short        get_stackdepth();
    xTaskHandle           get_handle();
 
    int                  get_return_value();
    timespan_t           get_time_since_start() const;
    int32_t              get_id();
    int32_t              get_on_core();
 
    void                  set_priority(basic_task::priority uiPriority);
 
    void                  suspend();
    void                  resume();
 
    bool                  joinable() const noexcept;
    int                   join(unsigned int xTickTimeout = portMAX_DELAY);
 
    int                 join(timespan_t time);
 
    int                 wait(unsigned int xTimeOut);
 
    int                 wait(timespan_t time);
 
    virtual void          on_start() {  }
    virtual void          on_kill()   {  }
 
    virtual int         on_task() { return ERR_TASK_OK; }
 
    virtual void          on_cleanup() { }
 
    state               get_state();
 
    operator xTaskHandle () { return (xTaskHandle)get_handle(); }
 
    operator int () { return get_id(); }
  public:
    bool operator == (const basic_task &r) const {
      return m_pHandle == r.m_pHandle;
    }
 
    bool operator != (const basic_task &r) const {
      return !operator==(r);
    }
 
    bool operator < (const basic_task &r) const {
      return m_pHandle < r.m_pHandle;
    }
 
    bool operator > (const basic_task &r) const {
      return m_pHandle > r.m_pHandle;
    }
  public:
    static void suspend(basic_task *t)  { t->suspend(); }
 
    static void resume(basic_task *t)   {   t->resume(); }
 
    static void yield()                   { taskYIELD(); }
    static void sleep(unsigned int secs)     { mn::delay(timespan_t(0, 0, 0, secs)); }
    static void usleep(unsigned int usec)     { mn::delay(timespan_t(0, 0, 0, 0, usec)); }
    static void nsleep(const timespan_t& req, timespan_t* rem)     {
        mn::ndelay(req, rem);
    }
 
    static uint32_t get_tasks();
 
    static bool is_current(basic_task* task) {
      return basic_task::get_self()->m_pHandle == task->m_pHandle;
    }
 
    static basic_task* get_self();
  protected:
    static void runtaskstub(void* parm);
  protected:
    mutable LockType_t m_runningMutex, m_contextMutext, m_continuemutex;
  protected:
    std::string m_strName;
    basic_task::priority m_uiPriority;
    unsigned short m_usStackDepth;
    int m_retval;
    bool m_bRunning;
    int32_t m_iID;
    int32_t m_iCore;
    native_handle_type m_pHandle;
 
    event_group_t m_eventGroup;
 
    #if( configSUPPORT_STATIC_ALLOCATION == 1 )
      StaticTask_t m_TaskBuffer;
      StackType_t  m_stackBuffer[MN_THREAD_CONFIG_STACK_DEPTH];
    #endif
  };
  using task_t = basic_task;
}
 
 
 
#endif