hal_tim.h

Go to the documentation of this file.

#ifndef HAL_TIM_H
#define HAL_TIM_H

#include <stdint.h>
#include <stdbool.h>
#include "hal_compiler_support.h"


#ifndef HAL_TIM_USE_INTERRUPT_EVENTS
#define HAL_TIM_USE_INTERRUPT_EVENTS    1
#endif

#ifndef HAL_TIM_USE_TASK_EVENTS
#define HAL_TIM_USE_TASK_EVENTS         1
#endif

#define TIM_NO_EVENT                    0xffffffff


// -----------------------------------------------------------------------------
//  PUBLIC TYPEDEFS
// -----------------------------------------------------------------------------

typedef union {
    uint32_t id;
    struct {
        uint32_t index : 31;
        uint32_t type : 1;
    } field;
} TIM_EventID;


typedef struct {
    uint32_t counter_periods : 31;
    uint32_t negative        : 1;
    uint32_t counter_ticks;
} TIM_Time;


typedef enum
{
    TIM_EVENT_TYPE_NO_TYPE = -1,
    TIM_EVENT_TYPE_INTERRUPT = 0,
    TIM_EVENT_TYPE_TASK = 1
} TIM_EventType;


typedef struct
{
    uint32_t MinTickBase;
    uint32_t MaxTickBase;
    uint32_t CounterRange;
} TIM_Capabilities;


typedef struct TIMDeviceDesc* TIMDevice;


// -----------------------------------------------------------------------------
//  PUBLIC API
// -----------------------------------------------------------------------------

void TIM_Init(TIMDevice tim, uint32_t TickTimeBase);

#define TIM_Deinit(TIM)                                     (TIM)->Deinit(TIM)

#define TIM_GetTime(TIM)                                    (TIM)->GetTime(TIM)

#define TIM_ResetCounter(TIM)                               (TIM)->ResetCounter(TIM)

#define TIM_GetCapabilities(TIM, Caps)                      (TIM)->GetCapabilities(TIM, Caps)

#define TIM_GetError(TIM, TickTimeBase)                     (TIM)->GetError(TIM, TickTimeBase)


int64_t TIM_GetTimeInNS(TIMDevice tim);

int64_t TIM_GetTimeElapsed(TIMDevice tim, TIM_Time since);

TIM_Time TIM_NSToTimTime(TIMDevice tim, int64_t ns);

int64_t TIM_TimTimeToNS(TIMDevice tim, TIM_Time t);

TIM_EventID TIM_InitEvent(TIMDevice tim, void (*handler)(TIMDevice tim, TIM_EventID event_id, TIM_Time expire_time, void* context), TIM_EventType type, void* context);

static HAL_INLINE bool TIM_IsEvent(TIM_EventID event_id) {  return event_id.id != TIM_NO_EVENT; }

void TIM_DeinitEvent(TIMDevice tim, TIM_EventID event_id);

HALRESULT TIM_ScheduleEvent(TIMDevice tim, TIM_EventID event_id, TIM_Time delta_time);

HALRESULT TIM_ScheduleEventAt(TIMDevice tim, TIM_EventID event_id, TIM_Time abs_time);

HALRESULT TIM_UnscheduleEvent(TIMDevice tim, TIM_EventID event_id);

bool TIM_IsEventScheduled(TIMDevice tim, TIM_EventID event_id);

TIM_EventID TIM_SetEventType(TIMDevice tim, TIM_EventID event_id, TIM_EventType type);

TIM_EventType TIM_GetEventType(TIM_EventID event_id);

TIM_Time TIM_GetTimeToEvent(TIMDevice tim, TIM_EventID event_id);

TIM_EventID TIM_GetNextEvent(TIMDevice tim);

TIM_Time TIM_GetEventTime(TIMDevice tim, TIM_EventID event_id);

void TIM_TaskEventProc(TIMDevice tim);

void TIM_InterruptProc(TIMDevice tim);

TIM_Time TIM_AddTime(TIMDevice tim, TIM_Time t1, TIM_Time t2);

TIM_Time TIM_SubtractTime(TIMDevice tim, TIM_Time t1, TIM_Time t2);

int TIM_CompareTime(TIM_Time t1, TIM_Time t2);

static HAL_INLINE int TIM_IsEventValid(TIM_EventID event_id)  { if (TIM_NO_EVENT == event_id.id) { return 0; } return 1; }

#endif /* HAL_TIM_H */