OS.hxx

Go to the documentation of this file.

 
#ifndef _OS_OS_HXX_
#define _OS_OS_HXX_
 
#include <endian.h>
 
#include "utils/macros.h"
#include "os/os.h"
 
class OSThread
{
public:
    OSThread(const char *name, int priority, size_t stack_size,
             void *(*start_routine)(void*), void *arg)
    {
        os_thread_create(&handle, name, priority, stack_size, start_routine, arg);
    }
 
    OSThread()
        : handle(0)
    {
    }
 
    void start(const char *name, int priority, size_t stack_size)
    {
        HASSERT(!is_created());
        os_thread_create(&handle, name, priority, stack_size, start, this);
    }
 
    virtual ~OSThread()
    {
    }
 
    bool is_created()
    {
        return handle != 0;
    }
 
    void inherit()
    {
        HASSERT(!is_created());
        ScopedSetThreadHandle h(this);
        entry();
    }
 
    static int getpriority(OSThread *thread)
    {
        return get_priority(thread);
    }
 
    static int get_priority(OSThread *thread)
    {
        return os_thread_get_priority(thread->handle);
    }
 
    static int get_priority_min()
    {
        return os_thread_get_priority_min();
    }
 
    static int get_priority_max()
    {
        return os_thread_get_priority_max();
    }
 
    os_thread_t get_handle()
    {
        return handle;
    }
 
    void lock_to_thread()
    {
        HASSERT(handle == 0);
        handle = os_thread_self();
    }
 
    void unlock_from_thread()
    {
        handle = 0;
    }
 
    struct ScopedSetThreadHandle
    {
        ScopedSetThreadHandle(OSThread *parent)
            : parent_(parent)
        {
            parent_->lock_to_thread();
        }
 
        ~ScopedSetThreadHandle()
        {
            parent_->unlock_from_thread();
        }
 
    private:
        OSThread *parent_;
    };
 
protected:
    virtual void *entry()
    {
        HASSERT(0 && "forgot to overload OSThread entry point. This thread "
                     "would do nothing.");
        return NULL;
    }
    
private:
    static void *start(void *arg)
    {
        OSThread *thread = (OSThread*)arg;
        return thread->entry();
    }
 
    DISALLOW_COPY_AND_ASSIGN(OSThread);
 
    os_thread_t handle;
};
 
class OSThreadOnce
{
public:
    OSThreadOnce(void (*routine)(void))
        : handle(OS_THREAD_ONCE_INIT),
          routine(routine)
    {
    }
    
    int once(void)
    {
        return os_thread_once(&handle, routine);
    }
 
    ~OSThreadOnce()
    {
    }
 
private:
    DISALLOW_COPY_AND_ASSIGN(OSThreadOnce);
 
    os_thread_once_t handle;
    
    void (*routine)(void);
};
 
class OSSem
{
public:
    OSSem(unsigned int value = 0)
    {
        os_sem_init(&handle, value);
    }
 
    ~OSSem()
    {
        os_sem_destroy(&handle);
    }
 
    void post()
    {
        os_sem_post(&handle);
    }
 
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
    void post_from_isr(int *woken)
    {
        os_sem_post_from_isr(&handle, woken);
    }
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
 
    void wait()
    {
        os_sem_wait(&handle);
    }
 
#if OPENMRN_FEATURE_SEM_TIMEDWAIT
    int timedwait(long long timeout)
    {
        return os_sem_timedwait(&handle, timeout);
    }
#endif
 
private:
    DISALLOW_COPY_AND_ASSIGN(OSSem);
 
    os_sem_t handle;
};
 
class OSMQ
{
public:
    
    OSMQ(size_t length, size_t item_size)
        : handle(os_mq_create(length, item_size))
    {
        HASSERT(handle != NULL);
    }
    
    ~OSMQ()
    {
    }
    
    void send(const void *data)
    {
        os_mq_send(handle, data);
    }
 
    int timedsend(const void *data, long long timeout)
    {
        return os_mq_timedsend(handle, data, timeout);
    }
    
    void receive(void *data)
    {
        os_mq_receive(handle, data);
    }
    
    int timedreceive(void *data, long long timeout)
    {
        return os_mq_timedreceive(handle, data, timeout);
    }
 
    int send_from_isr(const void *data, int *woken)
    {
        return os_mq_send_from_isr(handle, data, woken);
    }
 
    int receive_from_isr(void *data, int *woken)
    {
        return os_mq_receive_from_isr(handle, data, woken);
    }
 
    int num_pending()
    {
        return os_mq_num_pending(handle);
    }
 
    int num_spaces()
    {
        return os_mq_num_spaces(handle);
    }
 
    int pending_from_isr()
    {
        return os_mq_num_pending_from_isr(handle);
    }
 
    int is_full_from_isr()
    {
        return os_mq_is_full_from_isr(handle);
    }
    
private:
    OSMQ();
 
    os_mq_t handle;
    
    DISALLOW_COPY_AND_ASSIGN(OSMQ);
};
 
class OSMutex
{
public:
    OSMutex(bool recursive = false)
    {
        if (recursive)
        {
            os_recursive_mutex_init(&handle);
        }
        else
        {
            os_mutex_init(&handle);
        }
    }
 
    void lock()
    {
        os_mutex_lock(&handle);
    }
 
    void unlock()
    {
        os_mutex_unlock(&handle);
    }
 
    ~OSMutex()
    {
        os_mutex_destroy(&handle);
    }
 
private:
    DISALLOW_COPY_AND_ASSIGN(OSMutex);
 
    friend class OSMutexLock;
    os_mutex_t handle;
};
 
class OSMutexLock
{
public:
    OSMutexLock(OSMutex* mutex)
        : mutex_(&mutex->handle)
    {
        os_mutex_lock(mutex_);
    }
 
    OSMutexLock(os_mutex_t* mutex)
        : mutex_(mutex)
    {
        os_mutex_lock(mutex_);
    }
 
    ~OSMutexLock()
    {
        os_mutex_unlock(mutex_);
    }
private:
    DISALLOW_COPY_AND_ASSIGN(OSMutexLock);
 
    os_mutex_t* mutex_;
};
 
#define OSMutexLock(l) int error_omitted_mutex_lock_variable[-1]
 
extern "C"
{
extern long long rtcOffset;
}
 
class OSTime
{
public:
    static long long get_monotonic()
    {
        return os_get_time_monotonic();
    }
 
    static long long get_realtime()
    {
        return get_monotonic() + rtcOffset;
    }
 
    static void set_realtime(long long time)
    {
        rtcOffset = time - get_monotonic();
    }
 
private:
    DISALLOW_COPY_AND_ASSIGN(OSTime);
 
    /* Private default constructor prevents instantiating this class. */
    OSTime();
 
    ~OSTime();
};
 
#if defined (__FreeRTOS__)
typedef EventBits_t OSEventType;
class OSEvent
{
public:
    enum Test
    {
        WAIT_ANY = 0, 
        WAIT_ALL, 
    };
 
    OSEvent()
        : event(xEventGroupCreate())
    {
        HASSERT(event);
    }
 
    ~OSEvent()
    {
        vEventGroupDelete(event);
    }
 
    static int number_of_bits()
    {
#if configUSE_16_BIT_TICKS
        return 8;
#else
        return 24;
#endif
    }
 
    int wait(OSEventType mask, OSEventType *value, bool clear, Test test)
    {
        return timedwait(mask, value, clear, test, OPENMRN_OS_WAIT_FOREVER);
    }
 
    int timedwait(OSEventType mask, OSEventType *value, bool clear, Test test, long long timeout)
    {
        BaseType_t e_clear = clear ? pdTRUE : pdFALSE;
        BaseType_t e_test = test ? pdTRUE : pdFALSE;
        TickType_t e_timeout = timeout == OPENMRN_OS_WAIT_FOREVER ? portMAX_DELAY : timeout >> NSEC_TO_TICK_SHIFT;
 
        OSEventType bits = xEventGroupWaitBits(event, mask, e_clear, e_test, e_timeout);
 
        if (((bits & mask) == mask && test == WAIT_ALL) ||
            ((bits & mask) != 0    && test == WAIT_ANY))
        {
            // success
            if (value)
            {
                *value = bits;
            }
            return 0;
        }
        else
        {
            // timeout
            errno = ETIMEDOUT;
            return -1;
        }
    }
 
    void set(OSEventType mask)
    {
        xEventGroupSetBits(event, mask);
    }
 
    void set_from_isr(OSEventType mask, int *woken)
    {
        portBASE_TYPE local_woken;
        xEventGroupSetBitsFromISR(event, mask, &local_woken);
        *woken |= local_woken;
    }
 
    void clear(OSEventType mask)
    {
        xEventGroupClearBits(event, mask);
    }
 
    void clear_from_isr(OSEventType mask)
    {
        xEventGroupClearBitsFromISR(event, mask);
    }
 
    OSEventType peek()
    {
        return xEventGroupGetBits(event);
    }
 
private:
    DISALLOW_COPY_AND_ASSIGN(OSEvent);
 
    EventGroupHandle_t event;
};
#elif defined(ARDUINO) && !defined(ESP_PLATFORM)
 
typedef uint32_t OSEventType;
 
extern "C" {
extern unsigned critical_nesting;
extern uint32_t SystemCoreClock;
}
 
#define cm3_cpu_clock_hz SystemCoreClock
#define cpu_clock_hz SystemCoreClock
 
#define portENTER_CRITICAL()                                                   \
    do                                                                         \
    {                                                                          \
        noInterrupts();                                                        \
        ++critical_nesting;                                                    \
    } while (0)
#define portEXIT_CRITICAL()                                                    \
    do                                                                         \
    {                                                                          \
        if (critical_nesting <= 1)                                             \
        {                                                                      \
            critical_nesting = 0;                                              \
            interrupts();                                                      \
        }                                                                      \
        else                                                                   \
        {                                                                      \
            --critical_nesting;                                                \
        }                                                                      \
    } while (0)
 
#define configKERNEL_INTERRUPT_PRIORITY (0xa0)
 
#endif  // freertos or arduino/esp32
 
#endif /* _OS_OS_HXX_ */