144 lines
3.9 KiB
C
144 lines
3.9 KiB
C
#include "timer.h"
|
|
#include "check.h"
|
|
#include "memmgr.h"
|
|
#include "kernel.h"
|
|
|
|
#include "core/common_defines.h"
|
|
#include <FreeRTOS.h>
|
|
#include <timers.h>
|
|
|
|
typedef struct {
|
|
FuriTimerCallback func;
|
|
void* context;
|
|
} TimerCallback_t;
|
|
|
|
static void TimerCallback(TimerHandle_t hTimer) {
|
|
TimerCallback_t* callb;
|
|
|
|
/* Retrieve pointer to callback function and context */
|
|
callb = (TimerCallback_t*)pvTimerGetTimerID(hTimer);
|
|
|
|
/* Remove dynamic allocation flag */
|
|
callb = (TimerCallback_t*)((uint32_t)callb & ~1U);
|
|
|
|
if(callb != NULL) {
|
|
callb->func(callb->context);
|
|
}
|
|
}
|
|
|
|
FuriTimer* furi_timer_alloc(FuriTimerCallback func, FuriTimerType type, void* context) {
|
|
furi_assert((furi_is_irq_context() == 0U) && (func != NULL));
|
|
|
|
TimerHandle_t hTimer;
|
|
TimerCallback_t* callb;
|
|
UBaseType_t reload;
|
|
uint32_t callb_dyn;
|
|
|
|
hTimer = NULL;
|
|
callb = NULL;
|
|
callb_dyn = 0U;
|
|
|
|
/* Dynamic memory allocation is available: if memory for callback and */
|
|
/* its context is not provided, allocate it from dynamic memory pool */
|
|
if(callb == NULL) {
|
|
callb = (TimerCallback_t*)malloc(sizeof(TimerCallback_t));
|
|
|
|
if(callb != NULL) {
|
|
/* Callback memory was allocated from dynamic pool, set flag */
|
|
callb_dyn = 1U;
|
|
}
|
|
}
|
|
|
|
if(callb != NULL) {
|
|
callb->func = func;
|
|
callb->context = context;
|
|
|
|
if(type == FuriTimerTypeOnce) {
|
|
reload = pdFALSE;
|
|
} else {
|
|
reload = pdTRUE;
|
|
}
|
|
|
|
/* Store callback memory dynamic allocation flag */
|
|
callb = (TimerCallback_t*)((uint32_t)callb | callb_dyn);
|
|
// TimerCallback function is always provided as a callback and is used to call application
|
|
// specified function with its context both stored in structure callb.
|
|
hTimer = xTimerCreate(NULL, 1, reload, callb, TimerCallback);
|
|
if((hTimer == NULL) && (callb != NULL) && (callb_dyn == 1U)) {
|
|
/* Failed to create a timer, release allocated resources */
|
|
callb = (TimerCallback_t*)((uint32_t)callb & ~1U);
|
|
free(callb);
|
|
}
|
|
}
|
|
|
|
/* Return timer ID */
|
|
return ((FuriTimer*)hTimer);
|
|
}
|
|
|
|
void furi_timer_free(FuriTimer* instance) {
|
|
furi_assert(!furi_is_irq_context());
|
|
furi_assert(instance);
|
|
|
|
TimerHandle_t hTimer = (TimerHandle_t)instance;
|
|
TimerCallback_t* callb;
|
|
|
|
callb = (TimerCallback_t*)pvTimerGetTimerID(hTimer);
|
|
|
|
furi_check(xTimerDelete(hTimer, portMAX_DELAY) == pdPASS);
|
|
|
|
while (furi_timer_is_running(instance)) furi_delay_tick(2);
|
|
|
|
if((uint32_t)callb & 1U) {
|
|
/* Callback memory was allocated from dynamic pool, clear flag */
|
|
callb = (TimerCallback_t*)((uint32_t)callb & ~1U);
|
|
|
|
/* Return allocated memory to dynamic pool */
|
|
free(callb);
|
|
}
|
|
}
|
|
|
|
FuriStatus furi_timer_start(FuriTimer* instance, uint32_t ticks) {
|
|
furi_assert(!furi_is_irq_context());
|
|
furi_assert(instance);
|
|
|
|
TimerHandle_t hTimer = (TimerHandle_t)instance;
|
|
FuriStatus stat;
|
|
|
|
if(xTimerChangePeriod(hTimer, ticks, portMAX_DELAY) == pdPASS) {
|
|
stat = FuriStatusOk;
|
|
} else {
|
|
stat = FuriStatusErrorResource;
|
|
}
|
|
|
|
/* Return execution status */
|
|
return (stat);
|
|
}
|
|
|
|
FuriStatus furi_timer_stop(FuriTimer* instance) {
|
|
furi_assert(!furi_is_irq_context());
|
|
furi_assert(instance);
|
|
|
|
TimerHandle_t hTimer = (TimerHandle_t)instance;
|
|
FuriStatus stat;
|
|
|
|
if(xTimerIsTimerActive(hTimer) == pdFALSE) {
|
|
stat = FuriStatusErrorResource;
|
|
} else {
|
|
furi_check(xTimerStop(hTimer, portMAX_DELAY) == pdPASS);
|
|
stat = FuriStatusOk;
|
|
}
|
|
|
|
/* Return execution status */
|
|
return (stat);
|
|
}
|
|
|
|
uint32_t furi_timer_is_running(FuriTimer* instance) {
|
|
furi_assert(!furi_is_irq_context());
|
|
furi_assert(instance);
|
|
|
|
TimerHandle_t hTimer = (TimerHandle_t)instance;
|
|
|
|
/* Return 0: not running, 1: running */
|
|
return (uint32_t)xTimerIsTimerActive(hTimer);
|
|
}
|