TaskManagerIO.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 TASKMANAGER_IO_H
#define TASKMANAGER_IO_H
 
#include "TaskPlatformDeps.h"
#include "TaskTypes.h"
#include "TaskBlock.h"
 
#ifdef PARTICLE
enum InterruptMode;
#endif // PARTICLE

 
#if defined(IOA_USE_MBED) || defined(BUILD_FOR_PICO_CMAKE)
#include <cstdint>
void yield();
uint32_t millis();
uint32_t micros();
#ifdef IOA_USE_MBED
#define delayMicroseconds(x) wait_us(x)
#else
#define delayMicroseconds(x) sleep_us(x)
#endif // DELAY Microseconds code
#endif // IOA_USE_MBED

typedef void (*RawIntHandler)();

typedef void (*InterruptFn)(pintype_t pin);

class InterruptAbstraction {
public:
    virtual void attachInterrupt(pintype_t pin, RawIntHandler fn, uint8_t mode) = 0;
};
 
class TaskExecutionRecorder;

class TimePeriod {
private:
    uint32_t amount: 24;
    uint32_t unit: 7;
    uint32_t repeating: 1;
public:
    TimePeriod();
    TimePeriod(uint32_t amount, TimerUnit unit, bool repeat);
 
    TimePeriod(const TimePeriod& other) =default;
    TimePeriod& operator= (const TimePeriod& other) =default;
 
    uint32_t getAmount() const {
        return amount;
    }
 
    TimerUnit getUnit() const {
        return (TimerUnit)unit;
    }
 
    bool getRepeating() const {
        return repeating != 0;
    }
};

inline TimePeriod repeatSeconds(uint32_t seconds) { return {seconds, TIME_SECONDS, true}; }

inline TimePeriod repeatMillis(uint32_t millis) { return {millis, TIME_MILLIS, true}; }

inline TimePeriod repeatMicros(uint32_t micros) { return {micros, TIME_MICROS, true}; }

inline TimePeriod onceSeconds(uint32_t seconds) { return {seconds, TIME_SECONDS, false}; }

inline TimePeriod onceMillis(uint32_t millis) { return {millis, TIME_MILLIS, false}; }

inline TimePeriod onceMicros(uint32_t micros) { return {micros, TIME_MICROS, false}; }

class TaskManager {
protected:
    // the memory that holds all the tasks is an array of task blocks, allocated on demand
    TaskBlock* volatile taskBlocks[DEFAULT_TASK_BLOCKS];  // task blocks never ever move in memory, they are not volatile but the pointer is
    volatile taskid_t numberOfBlocks; // this holds the current number of blocks available.
 
    // here we have a linked list of tasks, this linked list is in time order, nearest task first.
    tm_internal::TimerTaskAtomicPtr first;
 
    // interrupt handling variables, store the interrupt state and probable pin cause if applicable
    volatile pintype_t lastInterruptTrigger;
    volatile bool interrupted;
    volatile InterruptFn interruptCallback;
 
    tm_internal::TmAtomicBool memLockerFlag;      // memory and list operations are locked by this flag using the TmSpinLocker
    tm_internal::TimerTaskAtomicPtr runningTask;
public:
    TaskManager();
    ~TaskManager();

    inline taskid_t execute(TimerFn workToDo) {
        return scheduleOnce(2, workToDo, TIME_MICROS);
    }

    inline taskid_t execute(Executable* execToDo, bool deleteWhenDone = false) {
        return scheduleOnce(2, execToDo, TIME_MICROS, deleteWhenDone);
    }

    taskid_t schedule(const TimePeriod& when, TimerFn timerFunction);

    taskid_t schedule(const TimePeriod& when, Executable* execRef, bool deleteWhenDone = false);
 

    taskid_t scheduleOnce(uint32_t when, TimerFn timerFunction, TimerUnit timeUnit = TIME_MILLIS);

    taskid_t scheduleOnce(uint32_t when, Executable* execRef, TimerUnit timeUnit = TIME_MILLIS, bool deleteWhenDone = false);

    taskid_t scheduleFixedRate(uint32_t when, TimerFn timerFunction, TimerUnit timeUnit = TIME_MILLIS);

    taskid_t scheduleFixedRate(uint32_t when, Executable* execRef, TimerUnit timeUnit = TIME_MILLIS, bool deleteWhenDone = false);

    taskid_t registerEvent(BaseEvent* eventToAdd, bool deleteWhenDone = false);

    ISR_ATTR void triggerEvents() {
        lastInterruptTrigger = 0xff; // 0xff is the shorthand for event trigger basically.
        interrupted = true;
    }

    void addInterrupt(InterruptAbstraction* interruptAbstraction, pintype_t pin, uint8_t mode);

    void setInterruptCallback(InterruptFn handler);

    void cancelTask(taskid_t task);

    void setTaskEnabled(taskid_t task, bool ena);

    virtual void yieldForMicros(uint32_t micros);

    void runLoop();

    static void markInterrupted(pintype_t interruptNo);

    void reset() {
        // the queue must be completely cleared.
        tm_internal::atomicWritePtr(&first, nullptr);
 
        // all the slots should be cleared
        for(taskid_t i =0; i<numberOfBlocks; i++) {
            taskBlocks[i]->clearAll();
        }
    }

    char* checkAvailableSlots(char* slotData, size_t slotDataSize) const;

    TimerTask* getFirstTask() {
        return tm_internal::atomicReadPtr(&first);
    }

    TimerTask* getTask(taskid_t task) const;

    uint32_t microsToNextTask() {
        auto maybeTask = tm_internal::atomicReadPtr(&first);
        if(maybeTask == nullptr) return 600 * 1000000U; // wait for 10 minutes if there's nothing to do
        else return maybeTask->microsFromNow();
    }

    TimerTask* getRunningTask() { return runningTask; }
 
    friend class TaskExecutionRecorder;
private:
    taskid_t findFreeTask();

    void removeFromQueue(TimerTask* task);

    void putItemIntoQueue(TimerTask* tm);

    void dealWithInterrupt();
};

extern TaskManager taskManager;

#define millisToMicros(x) ((x)*1000UL)

#define secondsToMicros(x) ((x)*1000000UL)

#define secondsToMillis(x) ((x)*1000UL)
 
#endif //TASKMANAGER_IO_H