TaskPlatformDeps.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry)..
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */
 
 
#ifndef TASKMANAGERIO_PLATFORMDETERMINATION_H
#define TASKMANAGERIO_PLATFORMDETERMINATION_H

 
class TimerTask;
 
// You can add your own local definitions header file here, this enables you to adjust build flags in environments
// where there is no easy way to do so with compiler options. Just create an include file "io_local_definitions.h"
// at the top level of your project source tree. This file will be honoured by all our libraries.
#if defined __has_include
#  if __has_include ("zio_local_definitions.h")
#    include "zio_local_definitions.h"
#  endif
#endif // has include "io_local_definitions"
 
// when not on mbed, we need to load Arduino.h to get the right defines for some boards.
#if defined(BUILD_FOR_PICO_CMAKE)
#include <pico/stdlib.h>
#include <valarray>
#elif !defined(__MBED__)
#include <Arduino.h>
#endif
 
#if defined(__MBED__) && !defined(ARDUINO_PICO_REVISION)
 
#if defined(TM_ENABLE_CAPTURED_LAMBDAS)
#define TM_ALLOW_CAPTURED_LAMBDA
#endif
 
// check if this is Arduino mbed or regular mbed.
// list of devices is pulled from https://github.com/arduino/ArduinoCore-mbed/blob/master/full.variables
// set TMIOA_FORCE_ARDUINO_MBED to force IoAbstraction to use Arduino-mbed mode.
#if defined(ARDUINO_NANO_RP2040_CONNECT) || \
    defined(ARDUINO_ARDUINO_NANO33BLE) || \
    defined(ARDUINO_RASPBERRY_PI_PICO) || \
    defined(ARDUINO_PORTENTA_H7_M7) || \
    defined(ARDUINO_PORTENTA_H7_M4) || \
    defined(ARDUINO_EDGE_CONTROL) || \
    defined(ARDUINO_NICLA) || \
    defined(ARDUINO_NICLA_VISION) || \
    defined(TMIOA_FORCE_ARDUINO_MBED) || \
    defined(ARDUINO_ARCH_MBED)
# define IOA_USE_ARDUINO
# define ARDUINO_MBED_MODE
# include "Arduino.h"
# define IOA_MULTITHREADED
#include "rtos/rtos.h"
inline void* getCurrentThreadId() { return rtos::ThisThread::get_id(); }
#else
# define IOA_USE_MBED
# include "mbed.h"
# define IOA_MULTITHREADED
inline void* getCurrentThreadId() { return ThisThread::get_id(); }
 
# if !defined(PIO_NEEDS_RTOS_WORKAROUND)
#  include "rtos.h"
# endif // PIO_NEED_RTOS_WORKAROUND
#endif // mbed and arduino-mbed checks
 
#include <mbed_atomic.h>
typedef uint32_t pintype_t;
 
namespace tm_internal {
    typedef TimerTask* volatile TimerTaskAtomicPtr;
    typedef volatile bool TmAtomicBool;

    inline bool atomicSwapBool(volatile bool *ptr, bool expected, bool newValue) {
        return core_util_atomic_cas_bool(ptr, &expected, newValue);
    }

    inline bool atomicReadBool(TmAtomicBool *pPtr) {
        return *pPtr;
    }
 
    inline void atomicWriteBool(TmAtomicBool *pPtr, bool newVal) {
        *pPtr = newVal;
    }

    inline TimerTask *atomicReadPtr(TimerTaskAtomicPtr *pPtr) {
        return *pPtr;
    }

    inline void atomicWritePtr(TimerTaskAtomicPtr *pPtr, TimerTask * volatile newValue) {
        //core_util_atomic_store_ptr((void* volatile*)pPtr,  newValue);
        *pPtr = newValue;
    }
}
#elif defined(ESP8266) || defined(ESP32) || defined(ARDUINO_PICO_REVISION)
typedef uint8_t pintype_t;
# define IOA_USE_ARDUINO
#if defined(TM_ENABLE_CAPTURED_LAMBDAS)
# define TM_ALLOW_CAPTURED_LAMBDA
#endif
 
#if defined(ESP8266) || defined(ARDUINO_PICO_REVISION)
#include <atomic>
namespace tm_internal {
 
    typedef std::atomic<TimerTask *> TimerTaskAtomicPtr;
 
    typedef std::atomic<uint32_t> TmAtomicBool;

    inline bool atomicSwapBool(TmAtomicBool *ptr, bool expected, bool newValue) {
        // compare and swap is not implemented on ESP8266
        auto ret = false;
        noInterrupts();
        if(ptr->load() == expected) {
            ptr->store(newValue);
            ret = true;
        }
        interrupts();
        return ret;
    }

    inline bool atomicReadBool(TmAtomicBool *pPtr) {
        return pPtr->load();
    }

    inline void atomicWriteBool(TmAtomicBool *pPtr, bool newVal) {
        pPtr->store(newVal);
    }

    inline TimerTask *atomicReadPtr(TimerTaskAtomicPtr *pPtr) {
        return pPtr->load();
    }

    inline void atomicWritePtr(TimerTaskAtomicPtr *pPtr, TimerTask *newValue) {
        pPtr->store(newValue);
    }
}
#else
# define IOA_MULTITHREADED
inline void* getCurrentThreadId() { return xTaskGetCurrentTaskHandle() ; }
 
namespace tm_internal {
 
    typedef TimerTask* volatile TimerTaskAtomicPtr;
    typedef volatile uint32_t TmAtomicBool; // to use CAS, the bool must be 32 bits wide
 
 
// `uxPortCompareSet` was removed in ESP-IDF v5.0
// See https://github.com/TcMenu/TaskManagerIO/issues/59
#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
    inline bool atomicSwapBool(TmAtomicBool *ptr, bool expected, bool newValue) {
        uint32_t exp32 = expected;
        uint32_t new32 = newValue;
        uxPortCompareSet(ptr, exp32, &new32);
        return new32 == expected;
    }
#else
    inline bool atomicSwapBool(TmAtomicBool *ptr, bool expected, bool newValue) {
        // function added in ESP-IDF v5.0
        return esp_cpu_compare_and_set(ptr, expected, newValue);
    }
#endif

    inline bool atomicReadBool(TmAtomicBool *pPtr) {
        return *pPtr != 0;
    }

    inline void atomicWriteBool(TmAtomicBool *pPtr, bool newVal) {
        *pPtr = newVal;
    }

    inline TimerTask *atomicReadPtr(TimerTaskAtomicPtr *pPtr) {
        return *pPtr;
    }

    inline void atomicWritePtr(TimerTaskAtomicPtr *pPtr, TimerTask *newValue) {
        *pPtr = newValue;
    }
}
#endif
#elif defined(BUILD_FOR_PICO_CMAKE)
#include <pico/critical_section.h>
#if defined(TM_ENABLE_CAPTURED_LAMBDAS)
#define TM_ALLOW_CAPTURED_LAMBDA
#endif
typedef uint8_t pintype_t;
namespace tm_internal {
    typedef TimerTask *volatile TimerTaskAtomicPtr;
    typedef volatile bool TmAtomicBool;
    extern critical_section_t* tmLock;
    void initPicoTmLock();
 
    static bool atomicSwapBool(volatile bool *ptr, bool expected, bool newValue) {
        bool ret = false;
        critical_section_enter_blocking(tmLock);
        if(*ptr == expected) {
            *ptr = newValue;
            ret = true;
        }
        critical_section_exit(tmLock);
        return ret;
    }
 
    static void atomicWriteBool(volatile bool *ptr, bool val) {
        critical_section_enter_blocking(tmLock);
        *ptr = val;
        critical_section_exit(tmLock);
    }
 
    inline bool atomicReadBool(volatile bool *ptr) {
        bool ret = false;
        critical_section_enter_blocking(tmLock);
        ret = *ptr;
        critical_section_exit(tmLock);
        return ret;
    }
 
    inline void atomicWritePtr(TimerTaskAtomicPtr *ptr, TimerTask *newVal) {
        *ptr = newVal;
    }
 
    inline TimerTask *atomicReadPtr(TimerTaskAtomicPtr *ptr) {
        return *ptr;
    }
}
#else
// fall back to using Arduino regular logic, works for all single core boards. If we end up here for a multicore
// board then there may be problems. Here we are in full arduino mode (AVR, MKR etc).
# define IOA_USE_ARDUINO
#include <Arduino.h>
typedef uint8_t pintype_t;
 
namespace tm_internal {
typedef TimerTask *volatile TimerTaskAtomicPtr;
typedef volatile bool TmAtomicBool;
 
    static bool atomicSwapBool(volatile bool* ptr, bool expected, bool newValue) {
        bool ret = false;
        noInterrupts();
        if(*ptr == expected) {
            *ptr = newValue;
            ret = true;
        }
        interrupts();
        return ret;
    }
 
    inline bool atomicReadBool(volatile bool *ptr) {
        return *ptr;
    }
 
    inline void atomicWriteBool(volatile bool *ptr, bool newVal) {
        *ptr = newVal;
    }
 
#if defined(__AVR__)
    inline void atomicWritePtr(TimerTaskAtomicPtr* pPtr, TimerTask* newValue) {
        noInterrupts();
        *pPtr = newValue;
        interrupts();
    }
 
    inline TimerTask* atomicReadPtr(TimerTaskAtomicPtr* pPtr) {
        noInterrupts();
        auto ptr = *pPtr;
        interrupts();
        return ptr;
    }
#else
// all other supported Arduino boards are atomic for pointer types
inline void atomicWritePtr(TimerTaskAtomicPtr* pPtr, TimerTask* newValue) {
        *pPtr = newValue;
    }
 
    inline TimerTask* atomicReadPtr(TimerTaskAtomicPtr* pPtr) {
        return *pPtr;
    }
#endif // AVR check for PTR atomicity
}
#endif // All platform checks
 
// for all mbed and ESP boards we already enable lambda captures, SAMD is a known extra case that works.
// we can only enable on larger boards with enough memory to take the extra size of the structures.
#if defined(TM_ENABLE_CAPTURED_LAMBDAS) && defined(ARDUINO_ARCH_SAMD)
# define TM_ALLOW_CAPTURED_LAMBDA
#endif
 
//
// Scheduling size. On all boards by default task manager uses 32 bit schedule data to make it more general purpose.
// Note that even on 8 bit boards, all the math still needs to be 32 bit to deal with times, so there is very little
// to no performance gain by doing this.
//
// If you need the few extra bytes back, and can live with 16 bit schedule values then define TM_FORCE_16BIT_SCHEDULER
//
#if defined(TM_FORCE_16BIT_SCHEDULER)
typedef uint16_t sched_t;
#else
typedef uint32_t sched_t;
#endif // TM_FORCE_16BIT_SCHEDULER
 
//
// DEFAULT_TASK_SIZE definition:
// TaskManagerIO will re-allocate the task array if needed. So there's little need to adjust this for most use cases.
// For AVR boards: MEGA 2560 has a default size of 10, others have a default size of 6.
// For all other boards the default size is 16. You can change it by defining DEFAULT_TASK_SIZE yourself.
//
#ifndef DEFAULT_TASK_SIZE
#ifdef __AVR_ATmega2560__
# define DEFAULT_TASK_SIZE 12
# define DEFAULT_TASK_BLOCKS 8
#elif defined(__AVR__)
# define DEFAULT_TASK_SIZE 6
# define DEFAULT_TASK_BLOCKS 4
#else
# define DEFAULT_TASK_SIZE 16
# define DEFAULT_TASK_BLOCKS 16
#endif // platform
#else
#ifndef DEFAULT_TASK_BLOCKS
#define DEFAULT_TASK_BLOCKS 8
#endif // DEFAULT_TASK_BLOCKS not defined when task size is
#endif // DEFAULT_TASK_SIZE defined already
 
//
// Here we define an attribute needed for interrupt support on ESP8266 and ESP32 boards, any interrupt code that is
// going to run on these boards should be marked with this attribute.
//
#undef ISR_ATTR
#if defined(ESP8266) || defined(ESP32)
# define ISR_ATTR IRAM_ATTR
#else
# define ISR_ATTR
#endif
 
//
// Here we have one last go at determining if we should enable capture lambdas by checking if the functional include
// is available, we only do so if we are on GCC > 5
//
# if !defined(TM_ALLOW_CAPTURED_LAMBDA) && defined(TM_ENABLE_CAPTURED_LAMBDAS) && __GNUC__ >= 5
#if __has_include(<functional>)
# define TM_ALLOW_CAPTURED_LAMBDA
#endif // _has_include
#endif // GCC>=5 and !TM_ALLOW_CAPTURED_LAMBDA
 
#ifndef internal_min
#define internal_min(a, b)  ((a) > (b) ? (b) : (a))
#endif // internal_min
 
#ifndef internal_max
#define internal_max(a, b)  ((a) < (b) ? (b) : (a));
#endif // internal_max
 
#endif //TASKMANGERIO_PLATFORMDETERMINATION_H