# lv_timer.h (/api/misc/lv_timer_h) Functions [#functions] lv_timer_handler_set_resume_cb [#lv_timer_handler_set_resume_cb] Set the resume callback to the timer handler ```c title=" " lineNumbers=1 void lv_timer_handler_set_resume_cb(lv_timer_handler_resume_cb_t cb, void *data) ``` Parameters | Name | Type | Description | | ------ | ----------------------------------------------- | -------------------------------------------------- | | `cb` | | the function to call when timer handler is resumed | | `data` | `void *` | pointer to a resume data | lv_timer_set_cb [#lv_timer_set_cb] Set the callback to the timer (the function to call periodically) ```c title=" " lineNumbers=1 void lv_timer_set_cb(lv_timer_t *timer, lv_timer_cb_t timer_cb) ``` Parameters | Name | Type | Description | | ---------- | ---------------------------------------------------- | --------------------------------- | | `timer` | | pointer to a timer | | `timer_cb` | | the function to call periodically | lv_timer_set_period [#lv_timer_set_period] Set new period for a lv\_timer ```c title=" " lineNumbers=1 void lv_timer_set_period(lv_timer_t *timer, uint32_t period) ``` Parameters | Name | Type | Description | | -------- | ---------------------------------------------------- | ---------------------- | | `timer` | | pointer to a lv\_timer | | `period` | | the new period | lv_timer_set_repeat_count [#lv_timer_set_repeat_count] Set the number of times a timer will repeat. ```c title=" " lineNumbers=1 void lv_timer_set_repeat_count(lv_timer_t *timer, int32_t repeat_count) ``` Parameters | Name | Type | Description | | -------------- | ---------------------------------------------------- | --------------------------------------------- | | `timer` | | pointer to a lv\_timer. | | `repeat_count` | | -1 : infinity; 0 : stop ; n>0: residual times | lv_timer_set_auto_delete [#lv_timer_set_auto_delete] Set whether a lv\_timer will be deleted automatically when it is called `repeat_count` times. ```c title=" " lineNumbers=1 void lv_timer_set_auto_delete(lv_timer_t *timer, bool auto_delete) ``` Parameters | Name | Type | Description | | ------------- | ---------------------------------------------------- | -------------------------------------------------------------------------------------- | | `timer` | | pointer to a lv\_timer. | | `auto_delete` | | true: auto delete; false: timer will be paused when it is called `repeat_count` times. | lv_timer_set_user_data [#lv_timer_set_user_data] Set custom parameter to the lv\_timer. ```c title=" " lineNumbers=1 void lv_timer_set_user_data(lv_timer_t *timer, void *user_data) ``` Parameters | Name | Type | Description | | ----------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to a lv\_timer. | | `user_data` | `void *` | custom parameter | lv_timer_set_external_data [#lv_timer_set_external_data] Attaches external user data and destructor callback to a timer object. Associates custom user data with an LVGL timer and specifies a destructor function that will be automatically invoked when the timer is deleted to properly clean up the associated resources. ```c title=" " lineNumbers=1 void lv_timer_set_external_data(lv_timer_t *timer, void *data, void(*free_cb)(void *data)) ``` Parameters | Name | Type | Description | | --------- | ---------------------------------------------------- | ----------------------------------------------------- | | `timer` | | Pointer to the timer object | | `data` | `void *` | User-defined data pointer to associate with the timer | | `free_cb` | `void(*)(void *data)` | | lv_timer_get_idle [#lv_timer_get_idle] Get idle percentage ```c title=" " lineNumbers=1 uint32_t lv_timer_get_idle(void) ``` **Returns:** — the lv\_timer idle in percentage lv_timer_get_time_until_next [#lv_timer_get_time_until_next] Get the time remaining until the next timer will run ```c title=" " lineNumbers=1 uint32_t lv_timer_get_time_until_next(void) ``` **Returns:** — the time remaining in ms lv_timer_get_next [#lv_timer_get_next] Iterate through the timers ```c title=" " lineNumbers=1 lv_timer_t * lv_timer_get_next(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | -------------------------------------------------------------------------- | | `timer` | | NULL to start iteration or the previous return value to get the next timer | **Returns:** — the next timer or NULL if there is no more timer lv_timer_get_user_data [#lv_timer_get_user_data] Get the user\_data passed when the timer was created ```c title=" " lineNumbers=1 void * lv_timer_get_user_data(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ------------------------ | | `timer` | | pointer to the lv\_timer | **Returns:** `void *` — pointer to the user\_data lv_timer_get_paused [#lv_timer_get_paused] Get the pause state of a timer ```c title=" " lineNumbers=1 bool lv_timer_get_paused(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ---------------------- | | `timer` | | pointer to a lv\_timer | **Returns:** — true: timer is paused; false: timer is running lv_timer_handler [#lv_timer_handler] Call it periodically to handle lv\_timers. ```c title=" " lineNumbers=1 uint32_t lv_timer_handler(void) ``` **Returns:** — time till it needs to be run next (in ms) lv_timer_handler_run_in_period [#lv_timer_handler_run_in_period] Call it in the super-loop of main() or threads. It will run with a given period in ms. You can use it with sleep or delay in OS environment. This function is used to simplify the porting. ```c title=" " lineNumbers=1 uint32_t lv_timer_handler_run_in_period(uint32_t period) ``` Parameters | Name | Type | Description | | -------- | --------------------------- | --------------------------------------------------------------------------------------- | | `period` | | the period for running | **Returns:** — the time after which it must be called again lv_timer_periodic_handler [#lv_timer_periodic_handler] Call it in the super-loop of main() or threads. It will automatically call at the right time. This function is used to simplify the porting. ```c title=" " lineNumbers=1 void lv_timer_periodic_handler(void) ``` lv_timer_create_basic [#lv_timer_create_basic] Create an "empty" timer. It needs to be initialized with at least `lv_timer_set_cb` and `lv_timer_set_period` ```c title=" " lineNumbers=1 lv_timer_t * lv_timer_create_basic(void) ``` **Returns:** — pointer to the created timer lv_timer_create [#lv_timer_create] Create a new lv\_timer ```c title=" " lineNumbers=1 lv_timer_t * lv_timer_create(lv_timer_cb_t timer_xcb, uint32_t period, void *user_data) ``` Parameters | Name | Type | Description | | ----------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `timer_xcb` | | a callback to call periodically. (the 'x' in the argument name indicates that it's not a fully generic function because it not follows the `func_name(object, callback, ...)` convention) | | `period` | | call period in ms unit | | `user_data` | `void *` | custom parameter | **Returns:** — pointer to the new timer lv_timer_delete [#lv_timer_delete] Delete a lv\_timer ```c title=" " lineNumbers=1 void lv_timer_delete(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to an lv\_timer | lv_timer_pause [#lv_timer_pause] Pause a timer. It is typically safe to call from an interrupt handler or a different thread. ```c title=" " lineNumbers=1 void lv_timer_pause(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to an lv\_timer | lv_timer_resume [#lv_timer_resume] Resume a timer. ```c title=" " lineNumbers=1 void lv_timer_resume(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to an lv\_timer | lv_timer_ready [#lv_timer_ready] Make a lv\_timer ready. It will not wait its period. ```c title=" " lineNumbers=1 void lv_timer_ready(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to a lv\_timer. | lv_timer_reset [#lv_timer_reset] Reset a lv\_timer. It will be called the previously set period milliseconds later. ```c title=" " lineNumbers=1 void lv_timer_reset(lv_timer_t *timer) ``` Parameters | Name | Type | Description | | ------- | ---------------------------------------------------- | ----------------------- | | `timer` | | pointer to a lv\_timer. | lv_timer_enable [#lv_timer_enable] Enable or disable the whole lv\_timer handling ```c title=" " lineNumbers=1 void lv_timer_enable(bool en) ``` Parameters | Name | Type | Description | | ---- | ----------------------- | --------------------------------------------------------------------------- | | `en` | | true: lv\_timer handling is running, false: lv\_timer handling is suspended | Typedefs [#typedefs] lv_timer_cb_t [#lv_timer_cb_t] ```c title=" " lineNumbers=1 typedef void(* lv_timer_cb_t) (lv_timer_t *) ``` Timers execute this type of functions. * `lv_timer_create` — param `timer_xcb` * `lv_timer_set_cb` — param `timer_cb` lv_timer_handler_resume_cb_t [#lv_timer_handler_resume_cb_t] ```c title=" " lineNumbers=1 typedef void(* lv_timer_handler_resume_cb_t) (void *data) ``` Timer handler resume this type of function. * `lv_timer_handler_set_resume_cb` — param `cb` Macros [#macros] LV_NO_TIMER_READY [#lv_no_timer_ready] ```c title=" " lineNumbers=1 #define LV_NO_TIMER_READY 0xFFFFFFFF ``` Dependencies [#dependencies]