qtasks.h

 
#ifndef QTASKS_H
    #define QTASKS_H
 
    #include "qtypes.h"
    #include "qstimers.h"
    #include "qlists.h"
 
    #if ( Q_QUEUES == 1 )
        #include "qqueues.h"
    #endif
 
    #if ( Q_FSM == 1 )
        #include "qfsm.h"
    #endif
 
    #if ( Q_ATCLI == 1 )
        #include "qatcli.h"
    #endif
 
    #ifdef __cplusplus
    extern "C" {
    #endif
 
    typedef enum {
        qTriggerNULL,
        byTimeElapsed,
        byNotificationQueued,
        byNotificationSimple,
        byQueueReceiver,
        byQueueFull,
        byQueueCount,
        byQueueEmpty,
        byEventFlags,
        bySchedulingRelease,
        byNoReadyTasks,
    }
    qTrigger_t;
 
    typedef qUINT32_t qNotifier_t;
 
    typedef qUINT32_t qTask_Flag_t;
 
    #define QMAX_NOTIFICATION_VALUE         ( UINT32_MAX - 1UL )
 
    typedef enum {
        qUndefinedGlobalState,  
        qReady,                 
        qWaiting,               
        qSuspended,             
        qRunning                
    }
    qTask_GlobalState_t;
 
    #if ( Q_TASK_EVENT_FLAGS == 1 )
        /*The task Bit-Flag definitions*/
        #define QEVENTFLAG_01               ( 0x00001000UL )
        #define QEVENTFLAG_02               ( 0x00002000UL )
        #define QEVENTFLAG_03               ( 0x00004000UL )
        #define QEVENTFLAG_04               ( 0x00008000UL )
        #define QEVENTFLAG_05               ( 0x00010000UL )
        #define QEVENTFLAG_06               ( 0x00020000UL )
        #define QEVENTFLAG_07               ( 0x00040000UL )
        #define QEVENTFLAG_08               ( 0x00080000UL )
        #define QEVENTFLAG_09               ( 0x00100000UL )
        #define QEVENTFLAG_10               ( 0x00200000UL )
        #define QEVENTFLAG_11               ( 0x00400000UL )
        #define QEVENTFLAG_12               ( 0x00800000UL )
        #define QEVENTFLAG_13               ( 0x01000000UL )
        #define QEVENTFLAG_14               ( 0x02000000UL )
        #define QEVENTFLAG_15               ( 0x04000000UL )
        #define QEVENTFLAG_16               ( 0x08000000UL )
        #define QEVENTFLAG_17               ( 0x10000000UL )
        #define QEVENTFLAG_18               ( 0x20000000UL )
        #define QEVENTFLAG_19               ( 0x40000000UL )
        #define QEVENTFLAG_20               ( 0x80000000UL )
        #define QEVENTFLAG_CLEAR            ( qFalse )
 
        #define QEVENTFLAG_SET              ( qTrue )
    #endif
 
    typedef struct _qEvent_s { // skipcq: CXX-E2000
        void *TaskData;
        void *EventData;
        qTrigger_t Trigger;
        qBool_t FirstCall;
        qBool_t FirstIteration;
        qBool_t LastIteration;
        qClock_t StartDelay;
    }
    #ifdef DOXYGEN
    qEvent_t;
    #else
    _qEvent_t_/*, *const qEvent_t*/; // skipcq: CXX-E2000
    typedef const _qEvent_t_ *qEvent_t;
    #endif
 
    typedef void (*qTaskFcn_t)( qEvent_t arg );
 
    typedef struct _qTask_s { /*Task node definition*/ // skipcq: CXX-E2000
        struct _qTask_Private_s {    /*Task control block - TCB*/ // skipcq: CXX-E2000
            qNode_MinimalFields;                    
            void *taskData, *asyncData;             
            qTaskFcn_t callback;                    
            #if ( ( Q_FSM == 1 ) || ( Q_ATCLI == 1 ) )
                void *aObj;                        
            #endif
            #if ( Q_QUEUES == 1 )
                qQueue_t *aQueue;                    
                qUINT32_t aQueueCount;               
            #endif
            #if ( Q_ALLOW_TASK_NAMING == 1 )
                const char *name;                         
            #endif
            qSTimer_t timer;                        
            #if ( Q_TASK_COUNT_CYCLES == 1 )
                qCycles_t cycles;                   
            #endif
            #if ( Q_PRESERVE_TASK_ENTRY_ORDER == 1 )
                size_t entry;                       /*< To allow the OS maintain the task entry order. */
            #endif
            qIteration_t iterations;                
            volatile qNotifier_t notification;      
            volatile qTask_Flag_t flags;            
            qTrigger_t trigger;                     
            qPriority_t priority;                   
        }
        qPrivate;
    }
    qTask_t;
 
    #if ( Q_QUEUES == 1 )
        typedef enum {
            qQueueMode_Receiver = 4,    
            qQueueMode_Full = 8,        
            qQueueMode_Count = 16,      
            qQueueMode_Empty = 32,      
        }
        qQueueLinkMode_t;
    #endif
 
    typedef enum {
        qTask_NotifyNULL,               
        qTask_NotifySimple,             
        qTask_NotifyQueued,             
    }
    qTask_NotifyMode_t;
 
    typedef enum {
        qTask_ClearIterations,          
        qTask_ClearTimeElapsed,         
        qTask_ClearCycles,              
        qTask_ClearSimpleNotifications, 
        qTask_ClearQueuedNotifications, 
        qTask_ClearNotifications,       
    }
    qTask_ClrParam_t;
 
    qBool_t qTask_Notification_Send( qTask_t * const Task,
                                     void* eventData );
 
    qBool_t qTask_Notification_Queue( qTask_t * const Task,
                                      void* eventData );
 
    qBool_t qTask_HasPendingNotifications( const qTask_t * const Task );
 
    qState_t qTask_Get_State( const qTask_t * const Task);
    #if ( Q_TASK_COUNT_CYCLES == 1 )
        qCycles_t qTask_Get_Cycles( const qTask_t * const Task );
    #endif
 
    qTask_GlobalState_t qTask_Get_GlobalState( const qTask_t * const Task );
 
    qBool_t qTask_Set_Time( qTask_t * const Task,
                            const qTime_t tValue );
 
    qBool_t qTask_Set_Iterations( qTask_t * const Task,
                                  const qIteration_t iValue );
 
    qBool_t qTask_Set_Priority( qTask_t * const Task,
                                const qPriority_t pValue );
 
    qBool_t qTask_Set_Callback( qTask_t * const Task,
                                const qTaskFcn_t cFcn );
 
    qBool_t qTask_Set_State( qTask_t * const Task,
                             const qState_t s );
 
    qBool_t qTask_Set_Data( qTask_t * const Task,
                            void* arg );
 
    qBool_t qTask_Clear( qTask_t * const Task,
                         const qTask_ClrParam_t param );
 
    qTask_t* qTask_Self( void );
 
    #define qTask_Suspend( Task )     qTask_Set_State( (Task), qDisabled )
 
    #define qTask_Disable( Task )     qTask_Set_State( (Task), qDisabled )
 
    #define qTask_Resume( Task )      qTask_Set_State( (Task), qEnabled )
 
    #define qTask_Enable( Task )      qTask_Set_State( (Task), qEnabled )
 
    #define qTask_ASleep( Task )      qTask_Set_State( (Task), qAsleep )
 
    #define qTask_Awake( Task )       qTask_Set_State( (Task), qAwake )
 
    #define qTask_IsEnabled( Task )   ( qEnabled == qTask_Get_State( (Task) ) )
 
    #if ( Q_QUEUES == 1 )
        qBool_t qTask_Attach_Queue( qTask_t * const Task,
                                    qQueue_t * const q,
                                    const qQueueLinkMode_t mode,
                                    const qUINT16_t arg );
 
    #endif  /*Q_QUEUES*/
 
 
    #if ( Q_TASK_EVENT_FLAGS == 1 )
        qBool_t qTask_EventFlags_Modify( qTask_t * const Task,
                                         const qTask_Flag_t flags,
                                         const qBool_t action );
 
        qTask_Flag_t qTask_EventFlags_Read( const qTask_t * const Task );
 
        qBool_t qTask_EventFlags_Check( qTask_t * const Task,
                                        qTask_Flag_t flagsToCheck,
                                        const qBool_t clearOnExit,
                                        const qBool_t checkForAll );
 
    #endif /*Q_TASK_EVENT_FLAGS*/
 
    #if ( Q_ALLOW_TASK_NAMING == 1 )
        qBool_t qTask_Set_Name( qTask_t * const Task,
                                const char *name );
 
        const char *qTask_Get_Name( const qTask_t * const Task );
 
        qTask_t* qTask_Find_ByName( const char *name );
 
    #endif /*Q_ALLOW_TASK_NAMING*/
 
    #ifdef __cplusplus
    }
    #endif
 
#endif /* QTASKS_H */