From dd27c3530432ea0b09f01e604bf577f31d8ef841 Mon Sep 17 00:00:00 2001 From: jacqueline Date: Thu, 1 Jun 2023 15:41:47 +1000 Subject: convert lvgl from submodule to a plain old directory --- lib/lvgl | 1 - lib/lvgl/src/misc/lv_anim.c | 470 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 470 insertions(+), 1 deletion(-) delete mode 160000 lib/lvgl create mode 100644 lib/lvgl/src/misc/lv_anim.c (limited to 'lib/lvgl/src/misc/lv_anim.c') diff --git a/lib/lvgl b/lib/lvgl deleted file mode 160000 index 0732400e..00000000 --- a/lib/lvgl +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 0732400e7b564dd0e7dc4a924619d8e19c5b23a0 diff --git a/lib/lvgl/src/misc/lv_anim.c b/lib/lvgl/src/misc/lv_anim.c new file mode 100644 index 00000000..4e4253a6 --- /dev/null +++ b/lib/lvgl/src/misc/lv_anim.c @@ -0,0 +1,470 @@ +/** + * @file lv_anim.c + * + */ + +/********************* + * INCLUDES + *********************/ +#include "lv_anim.h" + +#include "../hal/lv_hal_tick.h" +#include "lv_assert.h" +#include "lv_timer.h" +#include "lv_math.h" +#include "lv_mem.h" +#include "lv_gc.h" + +/********************* + * DEFINES + *********************/ +#define LV_ANIM_RESOLUTION 1024 +#define LV_ANIM_RES_SHIFT 10 + +/********************** + * TYPEDEFS + **********************/ + +/********************** + * STATIC PROTOTYPES + **********************/ +static void anim_timer(lv_timer_t * param); +static void anim_mark_list_change(void); +static void anim_ready_handler(lv_anim_t * a); + +/********************** + * STATIC VARIABLES + **********************/ +static uint32_t last_timer_run; +static bool anim_list_changed; +static bool anim_run_round; +static lv_timer_t * _lv_anim_tmr; + +/********************** + * MACROS + **********************/ +#if LV_LOG_TRACE_ANIM + #define TRACE_ANIM(...) LV_LOG_TRACE(__VA_ARGS__) +#else + #define TRACE_ANIM(...) +#endif + + +/********************** + * GLOBAL FUNCTIONS + **********************/ + +void _lv_anim_core_init(void) +{ + _lv_ll_init(&LV_GC_ROOT(_lv_anim_ll), sizeof(lv_anim_t)); + _lv_anim_tmr = lv_timer_create(anim_timer, LV_DISP_DEF_REFR_PERIOD, NULL); + anim_mark_list_change(); /*Turn off the animation timer*/ + anim_list_changed = false; +} + +void lv_anim_init(lv_anim_t * a) +{ + lv_memset_00(a, sizeof(lv_anim_t)); + a->time = 500; + a->start_value = 0; + a->end_value = 100; + a->repeat_cnt = 1; + a->path_cb = lv_anim_path_linear; + a->early_apply = 1; +} + +lv_anim_t * lv_anim_start(const lv_anim_t * a) +{ + TRACE_ANIM("begin"); + + /*Do not let two animations for the same 'var' with the same 'exec_cb'*/ + if(a->exec_cb != NULL) lv_anim_del(a->var, a->exec_cb); /*exec_cb == NULL would delete all animations of var*/ + + /*If the list is empty the anim timer was suspended and it's last run measure is invalid*/ + if(_lv_ll_is_empty(&LV_GC_ROOT(_lv_anim_ll))) { + last_timer_run = lv_tick_get(); + } + + /*Add the new animation to the animation linked list*/ + lv_anim_t * new_anim = _lv_ll_ins_head(&LV_GC_ROOT(_lv_anim_ll)); + LV_ASSERT_MALLOC(new_anim); + if(new_anim == NULL) return NULL; + + /*Initialize the animation descriptor*/ + lv_memcpy(new_anim, a, sizeof(lv_anim_t)); + if(a->var == a) new_anim->var = new_anim; + new_anim->run_round = anim_run_round; + + /*Set the start value*/ + if(new_anim->early_apply) { + if(new_anim->get_value_cb) { + int32_t v_ofs = new_anim->get_value_cb(new_anim); + new_anim->start_value += v_ofs; + new_anim->end_value += v_ofs; + } + + if(new_anim->exec_cb && new_anim->var) new_anim->exec_cb(new_anim->var, new_anim->start_value); + } + + /*Creating an animation changed the linked list. + *It's important if it happens in a ready callback. (see `anim_timer`)*/ + anim_mark_list_change(); + + TRACE_ANIM("finished"); + return new_anim; +} + +uint32_t lv_anim_get_playtime(lv_anim_t * a) +{ + uint32_t playtime = LV_ANIM_PLAYTIME_INFINITE; + + if(a->repeat_cnt == LV_ANIM_REPEAT_INFINITE) + return playtime; + + playtime = a->time - a->act_time; + if(a->playback_now == 0) + playtime += a->playback_delay + a->playback_time; + + if(a->repeat_cnt <= 1) + return playtime; + + playtime += (a->repeat_delay + a->time + + a->playback_delay + a->playback_time) * + (a->repeat_cnt - 1); + + return playtime; +} + +bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb) +{ + lv_anim_t * a; + lv_anim_t * a_next; + bool del = false; + a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)); + while(a != NULL) { + /*'a' might be deleted, so get the next object while 'a' is valid*/ + a_next = _lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a); + + if((a->var == var || var == NULL) && (a->exec_cb == exec_cb || exec_cb == NULL)) { + _lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a); + if(a->deleted_cb != NULL) a->deleted_cb(a); + lv_mem_free(a); + anim_mark_list_change(); /*Read by `anim_timer`. It need to know if a delete occurred in + the linked list*/ + del = true; + } + + a = a_next; + } + + return del; +} + +void lv_anim_del_all(void) +{ + _lv_ll_clear(&LV_GC_ROOT(_lv_anim_ll)); + anim_mark_list_change(); +} + +lv_anim_t * lv_anim_get(void * var, lv_anim_exec_xcb_t exec_cb) +{ + lv_anim_t * a; + _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) { + if(a->var == var && (a->exec_cb == exec_cb || exec_cb == NULL)) { + return a; + } + } + + return NULL; +} + +struct _lv_timer_t * lv_anim_get_timer(void) +{ + return _lv_anim_tmr; +} + +uint16_t lv_anim_count_running(void) +{ + uint16_t cnt = 0; + lv_anim_t * a; + _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) cnt++; + + return cnt; +} + +uint32_t lv_anim_speed_to_time(uint32_t speed, int32_t start, int32_t end) +{ + uint32_t d = LV_ABS(start - end); + uint32_t time = (d * 1000) / speed; + + if(time == 0) { + time++; + } + + return time; +} + +void lv_anim_refr_now(void) +{ + anim_timer(NULL); +} + +int32_t lv_anim_path_linear(const lv_anim_t * a) +{ + /*Calculate the current step*/ + int32_t step = lv_map(a->act_time, 0, a->time, 0, LV_ANIM_RESOLUTION); + + /*Get the new value which will be proportional to `step` + *and the `start` and `end` values*/ + int32_t new_value; + new_value = step * (a->end_value - a->start_value); + new_value = new_value >> LV_ANIM_RES_SHIFT; + new_value += a->start_value; + + return new_value; +} + +int32_t lv_anim_path_ease_in(const lv_anim_t * a) +{ + /*Calculate the current step*/ + uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX); + int32_t step = lv_bezier3(t, 0, 50, 100, LV_BEZIER_VAL_MAX); + + int32_t new_value; + new_value = step * (a->end_value - a->start_value); + new_value = new_value >> LV_BEZIER_VAL_SHIFT; + new_value += a->start_value; + + return new_value; +} + +int32_t lv_anim_path_ease_out(const lv_anim_t * a) +{ + /*Calculate the current step*/ + uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX); + int32_t step = lv_bezier3(t, 0, 900, 950, LV_BEZIER_VAL_MAX); + + int32_t new_value; + new_value = step * (a->end_value - a->start_value); + new_value = new_value >> LV_BEZIER_VAL_SHIFT; + new_value += a->start_value; + + return new_value; +} + +int32_t lv_anim_path_ease_in_out(const lv_anim_t * a) +{ + /*Calculate the current step*/ + uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX); + int32_t step = lv_bezier3(t, 0, 50, 952, LV_BEZIER_VAL_MAX); + + int32_t new_value; + new_value = step * (a->end_value - a->start_value); + new_value = new_value >> LV_BEZIER_VAL_SHIFT; + new_value += a->start_value; + + return new_value; +} + +int32_t lv_anim_path_overshoot(const lv_anim_t * a) +{ + /*Calculate the current step*/ + uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX); + int32_t step = lv_bezier3(t, 0, 1000, 1300, LV_BEZIER_VAL_MAX); + + int32_t new_value; + new_value = step * (a->end_value - a->start_value); + new_value = new_value >> LV_BEZIER_VAL_SHIFT; + new_value += a->start_value; + + return new_value; +} + +int32_t lv_anim_path_bounce(const lv_anim_t * a) +{ + /*Calculate the current step*/ + int32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX); + int32_t diff = (a->end_value - a->start_value); + + /*3 bounces has 5 parts: 3 down and 2 up. One part is t / 5 long*/ + + if(t < 408) { + /*Go down*/ + t = (t * 2500) >> LV_BEZIER_VAL_SHIFT; /*[0..1024] range*/ + } + else if(t >= 408 && t < 614) { + /*First bounce back*/ + t -= 408; + t = t * 5; /*to [0..1024] range*/ + t = LV_BEZIER_VAL_MAX - t; + diff = diff / 20; + } + else if(t >= 614 && t < 819) { + /*Fall back*/ + t -= 614; + t = t * 5; /*to [0..1024] range*/ + diff = diff / 20; + } + else if(t >= 819 && t < 921) { + /*Second bounce back*/ + t -= 819; + t = t * 10; /*to [0..1024] range*/ + t = LV_BEZIER_VAL_MAX - t; + diff = diff / 40; + } + else if(t >= 921 && t <= LV_BEZIER_VAL_MAX) { + /*Fall back*/ + t -= 921; + t = t * 10; /*to [0..1024] range*/ + diff = diff / 40; + } + + if(t > LV_BEZIER_VAL_MAX) t = LV_BEZIER_VAL_MAX; + if(t < 0) t = 0; + int32_t step = lv_bezier3(t, LV_BEZIER_VAL_MAX, 800, 500, 0); + + int32_t new_value; + new_value = step * diff; + new_value = new_value >> LV_BEZIER_VAL_SHIFT; + new_value = a->end_value - new_value; + + return new_value; +} + +int32_t lv_anim_path_step(const lv_anim_t * a) +{ + if(a->act_time >= a->time) + return a->end_value; + else + return a->start_value; +} + +/********************** + * STATIC FUNCTIONS + **********************/ + +/** + * Periodically handle the animations. + * @param param unused + */ +static void anim_timer(lv_timer_t * param) +{ + LV_UNUSED(param); + + uint32_t elaps = lv_tick_elaps(last_timer_run); + + /*Flip the run round*/ + anim_run_round = anim_run_round ? false : true; + + lv_anim_t * a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)); + + while(a != NULL) { + /*It can be set by `lv_anim_del()` typically in `end_cb`. If set then an animation delete + * happened in `anim_ready_handler` which could make this linked list reading corrupt + * because the list is changed meanwhile + */ + anim_list_changed = false; + + if(a->run_round != anim_run_round) { + a->run_round = anim_run_round; /*The list readying might be reset so need to know which anim has run already*/ + + /*The animation will run now for the first time. Call `start_cb`*/ + int32_t new_act_time = a->act_time + elaps; + if(!a->start_cb_called && a->act_time <= 0 && new_act_time >= 0) { + if(a->early_apply == 0 && a->get_value_cb) { + int32_t v_ofs = a->get_value_cb(a); + a->start_value += v_ofs; + a->end_value += v_ofs; + } + if(a->start_cb) a->start_cb(a); + a->start_cb_called = 1; + } + a->act_time += elaps; + if(a->act_time >= 0) { + if(a->act_time > a->time) a->act_time = a->time; + + int32_t new_value; + new_value = a->path_cb(a); + + if(new_value != a->current_value) { + a->current_value = new_value; + /*Apply the calculated value*/ + if(a->exec_cb) a->exec_cb(a->var, new_value); + } + + /*If the time is elapsed the animation is ready*/ + if(a->act_time >= a->time) { + anim_ready_handler(a); + } + } + } + + /*If the linked list changed due to anim. delete then it's not safe to continue + *the reading of the list from here -> start from the head*/ + if(anim_list_changed) + a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)); + else + a = _lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a); + } + + last_timer_run = lv_tick_get(); +} + +/** + * Called when an animation is ready to do the necessary thinks + * e.g. repeat, play back, delete etc. + * @param a pointer to an animation descriptor + */ +static void anim_ready_handler(lv_anim_t * a) +{ + /*In the end of a forward anim decrement repeat cnt.*/ + if(a->playback_now == 0 && a->repeat_cnt > 0 && a->repeat_cnt != LV_ANIM_REPEAT_INFINITE) { + a->repeat_cnt--; + } + + /*Delete the animation if + * - no repeat left and no play back (simple one shot animation) + * - no repeat, play back is enabled and play back is ready*/ + if(a->repeat_cnt == 0 && (a->playback_time == 0 || a->playback_now == 1)) { + + /*Delete the animation from the list. + * This way the `ready_cb` will see the animations like it's animation is ready deleted*/ + _lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a); + /*Flag that the list has changed*/ + anim_mark_list_change(); + + /*Call the callback function at the end*/ + if(a->ready_cb != NULL) a->ready_cb(a); + if(a->deleted_cb != NULL) a->deleted_cb(a); + lv_mem_free(a); + } + /*If the animation is not deleted then restart it*/ + else { + a->act_time = -(int32_t)(a->repeat_delay); /*Restart the animation*/ + /*Swap the start and end values in play back mode*/ + if(a->playback_time != 0) { + /*If now turning back use the 'playback_pause*/ + if(a->playback_now == 0) a->act_time = -(int32_t)(a->playback_delay); + + /*Toggle the play back state*/ + a->playback_now = a->playback_now == 0 ? 1 : 0; + /*Swap the start and end values*/ + int32_t tmp = a->start_value; + a->start_value = a->end_value; + a->end_value = tmp; + /*Swap the time and playback_time*/ + tmp = a->time; + a->time = a->playback_time; + a->playback_time = tmp; + } + } +} + +static void anim_mark_list_change(void) +{ + anim_list_changed = true; + if(_lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)) == NULL) + lv_timer_pause(_lv_anim_tmr); + else + lv_timer_resume(_lv_anim_tmr); +} -- cgit v1.2.3