parent
3ad1adc596
commit
edbe46703f
@ -0,0 +1,362 @@ |
||||
//
|
||||
// Created by MightyPork on 2017/06/08.
|
||||
// originally written 2016/9/2 for STM32F103 bluepill, adapted
|
||||
//
|
||||
|
||||
#include "game.h" |
||||
|
||||
#include <string.h> |
||||
#include <stdint.h> |
||||
#include <stdlib.h> |
||||
#include <avr/io.h> |
||||
#include <iopins.h> |
||||
#include "lib/color.h" |
||||
#include "leds.h" |
||||
#include "lib/timebase.h" |
||||
#include "display.h" |
||||
#include "pinout.h" |
||||
|
||||
//region Colors
|
||||
|
||||
#define C_DARK rgb24(0,0,0) |
||||
#define C_DIMWHITE rgb24(30,30,30) |
||||
#define C_OKGREEN rgb24(30,200,0) |
||||
#define C_CRIMSON rgb24(255,0,0) |
||||
|
||||
#define C_DIMRED rgb24(100,0,0) |
||||
#define C_DIMGREEN rgb24(0,100,0) |
||||
#define C_DIMBLUE rgb24(0,0,80) |
||||
#define C_DIMYELLOW rgb24(50,45,0) |
||||
|
||||
#define C_BRTRED rgb24(255,0,0) |
||||
#define C_BRTGREEN rgb24(0,255,0) |
||||
#define C_BRTBLUE rgb24(0,0,255) |
||||
#define C_BRTYELLOW rgb24(127,110,0) |
||||
|
||||
// assign to positions
|
||||
|
||||
#define C_DIM1 C_DIMRED |
||||
#define C_DIM2 C_DIMGREEN |
||||
#define C_DIM3 C_DIMBLUE |
||||
#define C_DIM4 C_DIMYELLOW |
||||
|
||||
#define C_BRT1 C_BRTRED |
||||
#define C_BRT2 C_BRTGREEN |
||||
#define C_BRT3 C_BRTBLUE |
||||
#define C_BRT4 C_BRTYELLOW |
||||
|
||||
//endregion
|
||||
|
||||
enum GameState_enum { |
||||
STATE_NEW_GAME, // new game, waiting for key
|
||||
STATE_REPLAY, // showing sequence
|
||||
STATE_USER_INPUT, // waiting for user input of repeated sequence
|
||||
STATE_SUCCESS_EFFECT, // entered OK, show some fireworks
|
||||
STATE_FAIL_EFFECT, // entered wrong, show FAIL animation, then reset.
|
||||
}; |
||||
|
||||
/** Current game state */ |
||||
enum GameState_enum GameState = STATE_NEW_GAME; |
||||
|
||||
/** Screen colors */ |
||||
uint32_t screen[4] = {0, 0, 0, 0}; |
||||
const uint32_t brt[4] = {C_BRT1, C_BRT2, C_BRT3, C_BRT4}; |
||||
const uint32_t dim[4] = {C_DIM1, C_DIM2, C_DIM3, C_DIM4}; |
||||
const uint32_t dark[4] = {C_DARK, C_DARK, C_DARK, C_DARK}; |
||||
const uint32_t dimwhite[4] = {C_DIMWHITE, C_DIMWHITE, C_DIMWHITE, C_DIMWHITE}; |
||||
|
||||
#define REPLAY_INTERVAL 400 |
||||
#define REPLAY_INTERVAL_GAP 75 |
||||
#define SUC_EFF_TIME 500 |
||||
#define FAIL_EFF_TIME 1000 |
||||
|
||||
/** Sequence of colors to show. Seed is constant thorough a game.
|
||||
* rng_state is used by rand_r() for building the sequence. */ |
||||
uint32_t game_seed; |
||||
unsigned long game_rng_state; |
||||
uint8_t last_item; |
||||
uint8_t repeat_count; |
||||
|
||||
/** Nr of revealed colors in sequence */ |
||||
uint8_t game_revealed_n; |
||||
/** Nr of next color to replay/input */ |
||||
uint8_t game_replay_n; |
||||
/** Nr of succ repeated colors */ |
||||
uint8_t game_repeat_n; |
||||
|
||||
void enter_state(enum GameState_enum state); |
||||
|
||||
/** Show current screen colors */ |
||||
void show_screen() |
||||
{ |
||||
leds_set(screen); |
||||
} |
||||
|
||||
/** Prepare rng sequence for replay / test */ |
||||
void reset_sequence() |
||||
{ |
||||
game_rng_state = game_seed; |
||||
last_item = 99; |
||||
repeat_count = 0; |
||||
} |
||||
|
||||
/** Get next item in the sequence */ |
||||
uint8_t get_next_item() |
||||
{ |
||||
uint8_t item; |
||||
while (1) { |
||||
item = (uint8_t) rand_r(&game_rng_state) & 0x03; |
||||
if (item == last_item) { |
||||
repeat_count++; |
||||
if (repeat_count < 2) { |
||||
goto suc; |
||||
} |
||||
} else { |
||||
last_item = item; |
||||
repeat_count = 0; |
||||
goto suc; |
||||
} |
||||
} |
||||
|
||||
suc: |
||||
return item; |
||||
} |
||||
|
||||
/** Enter state - callback for delayed state change */ |
||||
void deferred_enter_state(void *state) |
||||
{ |
||||
enter_state((enum GameState_enum) state); |
||||
} |
||||
|
||||
/** Future task CB in replay seq */ |
||||
void replay_callback(void *onOff) |
||||
{ |
||||
bool on = (bool) onOff; |
||||
|
||||
screen[0] = C_DARK; |
||||
screen[1] = C_DARK; |
||||
screen[2] = C_DARK; |
||||
screen[3] = C_DARK; |
||||
|
||||
if (on) { |
||||
uint8_t color = get_next_item(); |
||||
game_replay_n++; |
||||
screen[color] = brt[color]; |
||||
show_screen(); |
||||
schedule_task(replay_callback, (void *) 0, REPLAY_INTERVAL, false); |
||||
} else { |
||||
// turning off
|
||||
show_screen(); |
||||
|
||||
// Schedule next turning ON
|
||||
if (game_replay_n < game_revealed_n) { |
||||
schedule_task(replay_callback, (void *) 1, REPLAY_INTERVAL_GAP, false); |
||||
} else { |
||||
enter_state(STATE_USER_INPUT); |
||||
//schedule_task(deferred_enter_state, (void *) STATE_USER_INPUT, 50, false);
|
||||
} |
||||
} |
||||
} |
||||
|
||||
/** SUCCESS effect */ |
||||
void suc_eff_callback(void *onOff) |
||||
{ |
||||
bool on = (bool) onOff; |
||||
|
||||
if (on) { |
||||
for (uint8_t i = 0; i < 4; i++) screen[i] = C_OKGREEN; |
||||
schedule_task(suc_eff_callback, 0, SUC_EFF_TIME, false); |
||||
} else { |
||||
for (uint8_t i = 0; i < 4; i++) screen[i] = C_DARK; |
||||
|
||||
schedule_task(deferred_enter_state, (void *) STATE_REPLAY, 250, false); |
||||
} |
||||
|
||||
show_screen(); |
||||
} |
||||
|
||||
/** ERROR effect */ |
||||
void fail_eff_callback(void *onOff) |
||||
{ |
||||
bool on = (bool) onOff; |
||||
|
||||
if (on) { |
||||
for (int i = 0; i < 4; i++) screen[i] = C_CRIMSON; |
||||
schedule_task(fail_eff_callback, 0, FAIL_EFF_TIME, false); |
||||
} else { |
||||
for (int i = 0; i < 4; i++) screen[i] = C_DARK; |
||||
|
||||
schedule_task(deferred_enter_state, (void *) STATE_NEW_GAME, 250, false); |
||||
} |
||||
|
||||
show_screen(); |
||||
} |
||||
|
||||
/**
|
||||
* @brief Enter a game state |
||||
* @param state |
||||
*/ |
||||
void enter_state(enum GameState_enum state) |
||||
{ |
||||
GameState = state; |
||||
|
||||
switch (state) { |
||||
case STATE_NEW_GAME: |
||||
// new game - idle state before new game is started
|
||||
|
||||
// all dimly lit
|
||||
for (int i = 0; i < 4; i++) screen[i] = 0; //C_DIMWHITE
|
||||
break; |
||||
|
||||
case STATE_REPLAY: |
||||
game_replay_n = 0; |
||||
reset_sequence(); |
||||
|
||||
// Start replay
|
||||
replay_callback((void *) 1); |
||||
break; |
||||
|
||||
case STATE_USER_INPUT: |
||||
memcpy(screen, dim, sizeof(screen)); |
||||
|
||||
// Start entering & checking
|
||||
game_repeat_n = 0; |
||||
reset_sequence(); |
||||
break; |
||||
|
||||
case STATE_SUCCESS_EFFECT: |
||||
memcpy(screen, dim, sizeof(screen)); |
||||
//suc_eff_callback((void *) 1);
|
||||
schedule_task(suc_eff_callback, (void *) 1, 250, false); |
||||
break; |
||||
|
||||
case STATE_FAIL_EFFECT: |
||||
memcpy(screen, dim, sizeof(screen)); |
||||
//fail_eff_callback((void *) 1);
|
||||
schedule_task(fail_eff_callback, (void *) 1, 250, false); |
||||
break; |
||||
} |
||||
|
||||
show_screen(); |
||||
} |
||||
|
||||
/** Prepare new sequence, using time for seed. */ |
||||
void prepare_sequence() |
||||
{ |
||||
game_seed = time_ms; |
||||
game_rng_state = game_seed; |
||||
last_item = 99; |
||||
repeat_count = 0; |
||||
} |
||||
|
||||
/** Main function, called from MX-generated main.c */ |
||||
void game_main(void) |
||||
{ |
||||
display_show(SEG_G, SEG_G); // two dashes...
|
||||
enter_state(STATE_NEW_GAME); |
||||
// we'll init the sequence when user first presses a button - the time is used as a seed
|
||||
|
||||
enum GameState_enum last_state = STATE_NEW_GAME; |
||||
uint16_t cnt = 0; |
||||
while (1) { |
||||
if (GameState == last_state) { |
||||
if (GameState == STATE_NEW_GAME) { |
||||
if (cnt == 50) { |
||||
// clear after 5 secs
|
||||
display_show(SEG_G, SEG_G); |
||||
} |
||||
|
||||
if (cnt == 3000) { |
||||
// Shut down after 5 mins
|
||||
screen[0] = C_CRIMSON; |
||||
screen[1] = C_CRIMSON; |
||||
screen[2] = C_CRIMSON; |
||||
screen[3] = C_CRIMSON; |
||||
show_screen(); |
||||
delay_s(2000); |
||||
pin_down(PIN_PWR_HOLD); |
||||
} |
||||
} else { |
||||
if (cnt > 150) {// 15 secs = stop game.
|
||||
// reset state
|
||||
enter_state(STATE_NEW_GAME); |
||||
show_screen(); |
||||
display_show(SEG_G, SEG_G); |
||||
cnt = 0; |
||||
} |
||||
} |
||||
} else { |
||||
last_state = GameState; |
||||
cnt = 0; |
||||
} |
||||
|
||||
cnt++; |
||||
delay_ms(100); |
||||
} |
||||
} |
||||
|
||||
/**
|
||||
* @brief Handle a button press. Callback for debouncer. |
||||
* @param button: button identifier |
||||
* @param press: press state (1 = just pressed, 0 = just released) |
||||
*/ |
||||
void game_button_handler(uint8_t button, bool press) |
||||
{ |
||||
// convert to 0-3
|
||||
button--; |
||||
|
||||
switch (GameState) { |
||||
case STATE_NEW_GAME: |
||||
if (press) { |
||||
// feedback
|
||||
display_show_number(0); // show 0
|
||||
} |
||||
|
||||
if (!press) { // released
|
||||
// user wants to start playing
|
||||
prepare_sequence(); |
||||
game_revealed_n = 1; // start with 1 revealed
|
||||
|
||||
// darken
|
||||
//memcpy(screen, dark, sizeof(screen));
|
||||
//show_screen();
|
||||
|
||||
// start playback with a delay
|
||||
// this makes it obvious the playback is not a feedback to the pressed button
|
||||
schedule_task(deferred_enter_state, (void *) STATE_REPLAY, 500, false); |
||||
//enter_state(STATE_REPLAY);
|
||||
} |
||||
break; |
||||
case STATE_USER_INPUT: |
||||
// user is entering a color
|
||||
memcpy(screen, dim, sizeof(screen)); |
||||
|
||||
if (press) { |
||||
// Button is down
|
||||
screen[button] = brt[button]; |
||||
} else { |
||||
// Button is released
|
||||
// Verify correctness
|
||||
uint8_t expected = get_next_item(); |
||||
if (expected == button) { |
||||
// good!
|
||||
game_repeat_n++; |
||||
if (game_repeat_n == game_revealed_n) { |
||||
// repeated all, good work!
|
||||
game_revealed_n++; |
||||
display_show_number(game_revealed_n-1); |
||||
enter_state(STATE_SUCCESS_EFFECT); |
||||
} |
||||
} else { |
||||
enter_state(STATE_FAIL_EFFECT); |
||||
} |
||||
} |
||||
|
||||
show_screen(); |
||||
break; |
||||
|
||||
default: |
||||
// discard button press, not expecting input now
|
||||
break; |
||||
} |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
//
|
||||
// Created by MightyPork on 2017/06/08.
|
||||
//
|
||||
|
||||
#ifndef FIRMWARE_GAME_H |
||||
#define FIRMWARE_GAME_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
|
||||
void game_main(void); |
||||
|
||||
void game_button_handler(uint8_t button, bool press); |
||||
|
||||
#endif //FIRMWARE_GAME_H
|
||||
@ -0,0 +1,296 @@ |
||||
//
|
||||
// Created by MightyPork on 2017/06/08.
|
||||
//
|
||||
|
||||
#include "timebase.h" |
||||
|
||||
// Time base
|
||||
volatile ms_time_t time_ms = 0; |
||||
|
||||
|
||||
typedef struct { |
||||
/** User callback with arg */ |
||||
void (*callback)(void *); |
||||
/** Arg for the arg callback */ |
||||
void *cb_arg; |
||||
/** Callback interval */ |
||||
ms_time_t interval_ms; |
||||
/** Counter, when reaches interval_ms, is cleared and callback is called. */ |
||||
ms_time_t countup; |
||||
/** Unique task ID (for cancelling / modification) */ |
||||
task_pid_t pid; |
||||
/** Enable flag - disabled tasks still count, but CB is not run */ |
||||
bool enabled; |
||||
/** Marks that the task is due to be run */ |
||||
bool enqueue; |
||||
} periodic_task_t; |
||||
|
||||
|
||||
typedef struct { |
||||
/** User callback with arg */ |
||||
void (*callback)(void *); |
||||
/** Arg for the arg callback */ |
||||
void *cb_arg; |
||||
/** Counter, when reaches 0ms, callback is called and the task is removed */ |
||||
ms_time_t countdown_ms; |
||||
/** Unique task ID (for cancelling / modification) */ |
||||
task_pid_t pid; |
||||
/** Whether this task is long and needs posting on the queue */ |
||||
bool enqueue; |
||||
} future_task_t; |
||||
|
||||
// Slots
|
||||
static periodic_task_t periodic_tasks[TIMEBASE_PERIODIC_COUNT]; |
||||
static future_task_t future_tasks[TIMEBASE_FUTURE_COUNT]; |
||||
|
||||
static task_pid_t next_task_pid = 1; // 0 (PID_NONE) is reserved
|
||||
|
||||
/** Get a valid free PID for a new task. */ |
||||
static task_pid_t make_pid(void) |
||||
{ |
||||
task_pid_t pid = next_task_pid++; |
||||
|
||||
// make sure no task is given PID 0
|
||||
if (next_task_pid == PID_NONE) { |
||||
next_task_pid++; |
||||
} |
||||
|
||||
return pid; |
||||
} |
||||
|
||||
|
||||
/** Take an empty periodic task slot and populate the basics. */ |
||||
static periodic_task_t* claim_periodic_task_slot(ms_time_t interval, bool enqueue) |
||||
{ |
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != PID_NONE) continue; // task is used
|
||||
|
||||
task->countup = 0; |
||||
task->interval_ms = interval - 1; |
||||
task->enqueue = enqueue; |
||||
task->pid = make_pid(); |
||||
task->enabled = true; |
||||
return task; |
||||
} |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
|
||||
/** Take an empty future task slot and populate the basics. */ |
||||
static future_task_t* claim_future_task_slot(ms_time_t delay, bool enqueue) |
||||
{ |
||||
for (size_t i = 0; i < TIMEBASE_FUTURE_COUNT; i++) { |
||||
future_task_t *task = &future_tasks[i]; |
||||
if (task->pid != PID_NONE) continue; // task is used
|
||||
|
||||
task->countdown_ms = delay; |
||||
task->enqueue = enqueue; |
||||
task->pid = make_pid(); |
||||
return task; |
||||
} |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
/** Add a periodic task with an arg. */ |
||||
task_pid_t add_periodic_task(void (*callback)(void*), void* arg, ms_time_t interval, bool enqueue) |
||||
{ |
||||
periodic_task_t *task = claim_periodic_task_slot(interval, enqueue); |
||||
|
||||
if (task == NULL) return PID_NONE; |
||||
|
||||
task->callback = callback; |
||||
task->cb_arg = arg; |
||||
|
||||
return task->pid; |
||||
} |
||||
|
||||
|
||||
/** Schedule a future task, with uint32_t argument. */ |
||||
task_pid_t schedule_task(void (*callback)(void*), void *arg, ms_time_t delay, bool enqueue) |
||||
{ |
||||
future_task_t *task = claim_future_task_slot(delay, enqueue); |
||||
|
||||
if (task == NULL) return PID_NONE; |
||||
|
||||
task->callback = callback; |
||||
task->cb_arg = arg; |
||||
|
||||
return task->pid; |
||||
} |
||||
|
||||
|
||||
/** Enable or disable a periodic task. */ |
||||
bool enable_periodic_task(task_pid_t pid, bool enable) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
|
||||
task->enabled = enable; |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
|
||||
/** Check if a periodic task is enabled */ |
||||
bool is_periodic_task_enabled(task_pid_t pid) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
|
||||
return task->enabled; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
bool reset_periodic_task(task_pid_t pid) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
|
||||
task->countup = 0; |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
|
||||
bool set_periodic_task_interval(task_pid_t pid, ms_time_t interval) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
task->interval_ms = interval; |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
|
||||
/** Remove a periodic task. */ |
||||
bool remove_periodic_task(task_pid_t pid) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
|
||||
task->pid = PID_NONE; // mark unused
|
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
|
||||
/** Abort a scheduled task. */ |
||||
bool abort_scheduled_task(task_pid_t pid) |
||||
{ |
||||
if (pid == PID_NONE) return false; |
||||
|
||||
for (size_t i = 0; i < TIMEBASE_FUTURE_COUNT; i++) { |
||||
future_task_t *task = &future_tasks[i]; |
||||
if (task->pid != pid) continue; |
||||
|
||||
task->pid = PID_NONE; // mark unused
|
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
|
||||
|
||||
/** Run a periodic task */ |
||||
static void run_periodic_task(periodic_task_t *task) |
||||
{ |
||||
if (!task->enabled) return; |
||||
|
||||
if (task->enqueue) { |
||||
// queued task
|
||||
// FIXME re-implement queue
|
||||
//tq_post(task->callback, task->cb_arg);
|
||||
} else { |
||||
// immediate task
|
||||
task->callback(task->cb_arg); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** Run a future task */ |
||||
static void run_future_task(future_task_t *task) |
||||
{ |
||||
if (task->enqueue) { |
||||
// queued task
|
||||
// FIXME re-implement queue
|
||||
//tq_post(task->callback, task->cb_arg);
|
||||
} else { |
||||
// immediate task
|
||||
task->callback(task->cb_arg); |
||||
} |
||||
} |
||||
|
||||
|
||||
/**
|
||||
* @brief Millisecond callback, should be run in the SysTick handler. |
||||
*/ |
||||
void timebase_ms_cb(void) |
||||
{ |
||||
// increment global time
|
||||
time_ms++; |
||||
|
||||
// run periodic tasks
|
||||
for (size_t i = 0; i < TIMEBASE_PERIODIC_COUNT; i++) { |
||||
periodic_task_t *task = &periodic_tasks[i]; |
||||
if (task->pid == PID_NONE) continue; // unused
|
||||
|
||||
if (task->countup++ >= task->interval_ms) { |
||||
// run if enabled
|
||||
run_periodic_task(task); |
||||
// restart counter
|
||||
task->countup = 0; |
||||
} |
||||
} |
||||
|
||||
// run planned future tasks
|
||||
for (size_t i = 0; i < TIMEBASE_FUTURE_COUNT; i++) { |
||||
future_task_t *task = &future_tasks[i]; |
||||
if (task->pid == PID_NONE) continue; // unused
|
||||
|
||||
if (task->countdown_ms-- == 0) { |
||||
// run
|
||||
run_future_task(task); |
||||
// release the slot
|
||||
task->pid = PID_NONE; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/** Helper for looping with periodic branches */ |
||||
bool ms_loop_elapsed(ms_time_t *start, ms_time_t duration) |
||||
{ |
||||
if (time_ms - *start >= duration) { |
||||
*start = time_ms; |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
@ -0,0 +1,151 @@ |
||||
//
|
||||
// Created by MightyPork on 2017/06/08.
|
||||
//
|
||||
|
||||
#ifndef TIMEBASE_H |
||||
#define TIMEBASE_H |
||||
|
||||
/**
|
||||
* To use the Timebase functionality, |
||||
* set up SysTick to 1 kHz and call |
||||
* timebase_ms_cb() in the IRQ. |
||||
* |
||||
* If you plan to use pendable future tasks, |
||||
* also make sure you call run_pending_tasks() |
||||
* in your main loop. |
||||
* |
||||
* This is not needed for non-pendable tasks. |
||||
*/ |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <stddef.h> |
||||
|
||||
/** Task PID. */ |
||||
typedef uint8_t task_pid_t; |
||||
|
||||
/** Time value in ms */ |
||||
typedef uint16_t ms_time_t; |
||||
|
||||
extern volatile ms_time_t time_ms; |
||||
|
||||
#define TIMEBASE_PERIODIC_COUNT 5 |
||||
#define TIMEBASE_FUTURE_COUNT 5 |
||||
|
||||
|
||||
// PID value that can be used to indicate no task
|
||||
#define PID_NONE 0 |
||||
|
||||
/** Loop until timeout - use in place of while() or for(). break and continue work too! */ |
||||
#define until_timeout(to_ms) for(uint32_t _utmeo = ms_now(); ms_elapsed(_utmeo) < (to_ms);) |
||||
|
||||
/** Retry a call until a timeout. Variable 'suc' is set to the return value. Must be defined. */ |
||||
#define retry_TO(to_ms, call) \ |
||||
until_timeout(to_ms) { \
|
||||
suc = call; \
|
||||
if (suc) break; \
|
||||
} |
||||
|
||||
/** Must be called every 1 ms */ |
||||
void timebase_ms_cb(void); |
||||
|
||||
|
||||
// --- Periodic -----------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Add a periodic task with an arg. |
||||
* @param callback : task callback |
||||
* @param arg : callback argument |
||||
* @param interval : task interval (ms) |
||||
* @param enqueue : put on the task queue when due |
||||
* @return task PID |
||||
*/ |
||||
task_pid_t add_periodic_task(void (*callback)(void *), void *arg, ms_time_t interval, bool enqueue); |
||||
|
||||
|
||||
/** Destroy a periodic task. */ |
||||
bool remove_periodic_task(task_pid_t pid); |
||||
|
||||
/** Enable or disable a periodic task. Returns true on success. */ |
||||
bool enable_periodic_task(task_pid_t pid, bool cmd); |
||||
|
||||
/** Check if a periodic task exists and is enabled. */ |
||||
bool is_periodic_task_enabled(task_pid_t pid); |
||||
|
||||
/** Reset timer for a task */ |
||||
bool reset_periodic_task(task_pid_t pid); |
||||
|
||||
/** Set inteval */ |
||||
bool set_periodic_task_interval(task_pid_t pid, ms_time_t interval); |
||||
|
||||
|
||||
// --- Future -------------------------------------------------
|
||||
|
||||
|
||||
/**
|
||||
* @brief Schedule a future task, with uint32_t argument. |
||||
* @param callback : task callback |
||||
* @param arg : callback argument |
||||
* @param delay : task delay (ms) |
||||
* @param enqueue : put on the task queue when due |
||||
* @return task PID |
||||
*/ |
||||
task_pid_t schedule_task(void (*callback_arg)(void *), void *arg, ms_time_t delay, bool enqueue); |
||||
|
||||
|
||||
/** Abort a scheduled task. */ |
||||
bool abort_scheduled_task(task_pid_t pid); |
||||
|
||||
|
||||
// --- Waiting functions --------------------------------------
|
||||
|
||||
/** Get milliseconds elapsed since start timestamp */ |
||||
static inline ms_time_t ms_elapsed(ms_time_t start) |
||||
{ |
||||
return time_ms - start; |
||||
} |
||||
|
||||
/** Delay N ms */ |
||||
static inline void delay_ms(ms_time_t ms) |
||||
{ |
||||
ms_time_t start = time_ms; |
||||
while ((time_ms - start) < ms); // overrun solved by unsigned arithmetic
|
||||
} |
||||
|
||||
/** Get current timestamp. */ |
||||
static inline ms_time_t ms_now(void) |
||||
{ |
||||
return time_ms; |
||||
} |
||||
|
||||
/** Seconds delay */ |
||||
static inline void delay_s(uint16_t s) |
||||
{ |
||||
while (s-- != 0) { |
||||
delay_ms(1000); |
||||
} |
||||
} |
||||
|
||||
/**
|
||||
* @brief Check if time since `start` elapsed. |
||||
* |
||||
* If so, sets the *start variable to the current time. |
||||
* |
||||
* Example: |
||||
* |
||||
* ms_time_t s = ms_now(); |
||||
* |
||||
* while(1) { |
||||
* if (ms_loop_elapsed(&s, 100)) { |
||||
* // this is called every 100 ms
|
||||
* } |
||||
* // ... rest of the loop ...
|
||||
* } |
||||
* |
||||
* @param start start time variable |
||||
* @param duration delay length |
||||
* @return delay elapsed; start was updated. |
||||
*/ |
||||
bool ms_loop_elapsed(ms_time_t *start, ms_time_t duration); |
||||
|
||||
#endif //TIMEBASE_H
|
||||
Loading…
Reference in new issue