V1.0.5

packages/artinchip/env/env.c

@@ -15,6 +15,12 @@
 #include <env.h>
 #include <aic_crc32.h>
 
+#ifdef KERNEL_BAREMETAL
+#include <aic_partition.h>
+#include <disk_part.h>
+#include <mmc.h>
+#endif
+
 #ifndef KERNEL_BAREMETAL
 
 #include <rtthread.h>
@@ -635,6 +641,161 @@ static int bar_spinand_save_env_simple(void *buf, size_t size)
 #endif
 #endif
 
+#ifndef KERNEL_BAREMETAL
+static int rtt_mmc_load_env_simple(void *buf, size_t size)
+{
+    rt_device_t env_current;
+    struct rt_device_blk_geometry get_data;
+    size_t blkcnt = 0;
+
+    if (dev_current == 0) {
+        env_current = rt_device_find("mmc0p1");
+    } else if (dev_current == 1) {
+        env_current = rt_device_find("mmc0p2");
+    } else {
+        pr_err("Invalid dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    if (env_current == RT_NULL) {
+        pr_err("Not found dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    rt_device_open(env_current, RT_DEVICE_FLAG_RDWR);
+
+    rt_device_control(env_current, RT_DEVICE_CTRL_BLK_GETGEOME, (void *)&get_data);
+
+    blkcnt = size / get_data.bytes_per_sector;
+
+    if (rt_device_read(env_current, 0, buf, blkcnt) != blkcnt) {
+        pr_err("mmc read env fail\n");
+        goto rtt_mmc_load_env_simple_exit;
+    }
+
+rtt_mmc_load_env_simple_exit:
+    rt_device_close(env_current);
+
+    return 0;
+}
+
+static int rtt_mmc_save_env_simple(void *buf, size_t size)
+{
+    rt_device_t env_current;
+    struct rt_device_blk_geometry get_data;
+    unsigned long long p[2] = {0};
+    size_t blkcnt = 0;
+
+    if (dev_current == 0) {
+        env_current = rt_device_find("mmc0p2");
+    } else if (dev_current == 1) {
+        env_current = rt_device_find("mmc0p1");
+    } else {
+        pr_err("Invalid dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    if (env_current == RT_NULL) {
+        pr_err("Not found dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    rt_device_open(env_current, RT_DEVICE_FLAG_RDWR);
+
+    rt_device_control(env_current, RT_DEVICE_CTRL_BLK_GETGEOME, (void *)&get_data);
+
+    p[0] = 0;//offset is 0
+    p[1] = get_data.sector_count;
+
+    if (rt_device_control(env_current, RT_DEVICE_CTRL_BLK_ERASE, (void *)p) < 0) {
+        pr_err("Erase mmc partition failed!");
+        goto rtt_mmc_save_env_simple_exit;
+    }
+
+    blkcnt = size / get_data.bytes_per_sector;
+
+    if (rt_device_write(env_current, 0, (void *)buf, blkcnt) != blkcnt) {
+        pr_err("mmc write env fail\n");
+        goto rtt_mmc_save_env_simple_exit;
+    }
+
+rtt_mmc_save_env_simple_exit:
+    rt_device_close(env_current);
+
+    return 0;
+}
+#else
+static int bar_mmc_load_env_simple(void *buf, size_t size)
+{
+    struct aic_sdmc *host = NULL;
+    struct aic_partition *parts = NULL, *part = NULL;
+    struct blk_desc dev_desc = {0};
+
+    host = find_mmc_dev_by_index(0);
+    if (host== NULL) {
+        pr_err("can't find mmc device!");
+        return -1;
+    }
+
+    dev_desc.blksz = 512;
+    dev_desc.lba_count = host->dev->card_capacity * 2;
+    dev_desc.priv = host;
+    parts = aic_disk_get_parts(&dev_desc);
+
+    if (dev_current == 0) {
+        part = aic_part_get_byname(parts, AIC_ENV_PART_NAME);
+    } else if (dev_current == 1) {
+        part = aic_part_get_byname(parts, AIC_ENV_REDUNDAND_PART_NAME);
+    } else {
+        pr_err("Invalid dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    if (parts)
+        aic_part_free(parts);
+
+    mmc_bread(host, part->start / dev_desc.blksz, size / dev_desc.blksz, buf);
+
+    return 0;
+}
+
+static int bar_mmc_save_env_simple(void *buf, size_t size)
+{
+    struct aic_sdmc *host = NULL;
+    struct aic_partition *parts = NULL, *part = NULL;
+    struct blk_desc dev_desc = {0};
+
+    host = find_mmc_dev_by_index(0);
+    if (host== NULL) {
+        pr_err("can't find mmc device!");
+        return -1;
+    }
+
+    dev_desc.blksz = 512;
+    dev_desc.lba_count = host->dev->card_capacity * 2;
+    dev_desc.priv = host;
+    parts = aic_disk_get_parts(&dev_desc);
+
+    if (dev_current == 0) {
+        part = aic_part_get_byname(parts, AIC_ENV_REDUNDAND_PART_NAME);
+    } else if (dev_current == 1) {
+        part = aic_part_get_byname(parts, AIC_ENV_PART_NAME);
+    } else {
+        pr_err("Invalid dev_current:%d\n", dev_current);
+        return -1;
+    }
+
+    if (parts)
+        aic_part_free(parts);
+
+    mmc_berase(host, part->start / dev_desc.blksz, part->size / dev_desc.blksz);
+
+    mmc_bwrite(host, part->start / dev_desc.blksz, size / dev_desc.blksz, buf);
+
+    return 0;
+}
+#endif
+
 static int flash_env_read(void *buf, size_t size)
 {
     int ret = 0;
@@ -658,6 +819,14 @@ static int flash_env_read(void *buf, size_t size)
 #endif
             break;
 #endif
+        case BD_SDMC0:
+#ifndef KERNEL_BAREMETAL
+            ret = rtt_mmc_load_env_simple(buf, size);
+#else
+            ret = bar_mmc_load_env_simple(buf, size);
+#endif
+            break;
+
         default:
             break;
     }
@@ -721,6 +890,14 @@ static int flash_env_write(void *buf, size_t size)
 #endif
             break;
 #endif
+        case BD_SDMC0:
+#ifndef KERNEL_BAREMETAL
+            ret = rtt_mmc_save_env_simple(buf, size);
+#else
+            ret = bar_mmc_save_env_simple(buf, size);
+#endif
+            break;
+
         default:
             break;
     }

packages/artinchip/lvgl-ui/aic_demo/elevator_demo/SConscript

@@ -0,0 +1,22 @@
+from building import *
+import os
+
+cwd = GetCurrentDir()
+group = []
+CPPPATH = [cwd]
+src = []
+
+src += Glob('./elevator_ui.c')
+
+if GetDepend(['LV_ELEVATOR_UART_COMMAND']):
+    src += Glob('./elevator_uart.c')
+
+list = os.listdir(cwd)
+for d in list:
+    path = os.path.join(cwd, d)
+    if os.path.isfile(os.path.join(path, 'SConscript')):
+        group = group + SConscript(os.path.join(d, 'SConscript'))
+
+group = group + DefineGroup('LVGL-port', src, depend = ['AIC_LVGL_ELEVATOR_DEMO'], CPPPATH = CPPPATH)
+
+Return('group')

packages/artinchip/lvgl-ui/aic_demo/elevator_demo/elevator_uart.c

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2023-2024 ArtinChip Technology Co., Ltd.
+ * Authors:  Huahui Mai <huahui.mai@artinchip.com>
+ *
+ */
+
+#include <rtconfig.h>
+#ifdef RT_USING_FINSH
+#include <rthw.h>
+#include <rtthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <finsh.h>
+#include "lvgl.h"
+
+#include "elevator_ui.h"
+#include "elevator_uart.h"
+#include "aic_core.h"
+
+#define UART_DEVICE     "uart1"
+#define UART_MAX_COUNT  64
+#define DATA_MAX_COUNT  12
+
+rt_device_t elevator_uart;
+static struct rt_semaphore rx_sem;
+static rt_mutex_t dynamic_mutex = RT_NULL;
+
+static LIST_HEAD(task);
+
+#define UART_IOCTL_DEF(ioctl, _ui_func)	            \
+	[UART_IOCTL_NR(ioctl)] = {		                \
+		.cmd = ioctl,			                    \
+		.ui_func = _ui_func,			            \
+		.name = #ioctl			                    \
+	}
+
+/* Ioctl table */
+static const struct uart_ioctl_desc uart_ioctls[] = {
+    UART_IOCTL_DEF(UART_IOCTL_UP_DOWN, inside_up_down_ioctl),
+    UART_IOCTL_DEF(UART_IOCTL_LEVEL, inside_level_ioctl),
+    UART_IOCTL_DEF(UART_IOCTL_REPLAY, replayer_ioctl),
+};
+
+#define UART_IOCTL_COUNT	ARRAY_SIZE(uart_ioctls)
+
+/**
+ * DOC: uart specific ioctls
+ *
+ * When UART_DEVICE receives a command, elevator ui will executes a specific
+ * ioctls.
+ *
+ * Command format: AA ioctl_id data...
+ *
+ * Command table:
+ * AA 00 00/01 : elevator up/down
+ * AA 01 level : elevator level
+ * AA 02 00 : elevator player video
+ */
+
+rt_err_t elevator_uart_input(rt_device_t dev, rt_size_t size)
+{
+    if (size > 0)
+        rt_sem_release(&rx_sem);
+
+    return RT_EOK;
+}
+
+static inline bool check_uart_receive_over(int *count, int *code)
+{
+    if (*count == UART_MAX_COUNT || (*code == 1 && *count > DATA_MAX_COUNT))
+    {
+        *count = 0;
+        *code = 0;
+
+        return true;
+    }
+    return false;
+}
+
+static inline bool check_uart_receive_done(int *code, char ch)
+{
+    if (*code == 1 && ch == '\n')
+    {
+        *code = 0;
+
+        return true;
+    }
+    return false;
+}
+
+int uart_add_disp_task(char *str_rx, int data_len)
+{
+    struct disp_task *disp_task = NULL;
+    int id = atoi(str_rx);
+
+    if (id >= UART_IOCTL_COUNT)
+    {
+        rt_kprintf("invalid id: %d, uart ioctl count %d\n", id, UART_IOCTL_COUNT);
+        return -1;
+    }
+
+    disp_task = aicos_malloc(MEM_CMA, sizeof(struct disp_task));
+    if (!disp_task)
+    {
+        rt_kprintf("alloc task failed\n");
+        return -1;
+    }
+
+    disp_task->ioctl = &uart_ioctls[id];
+    disp_task->data_len = data_len - 4;
+    memcpy(disp_task->data, str_rx + 4, data_len - 4);
+
+    list_add_tail(&disp_task->next, &task);
+    return 0;
+}
+
+void elevator_uart_rx_thread_entry(void *parameter)
+{
+    char ch;
+    char str_rx[UART_MAX_COUNT] = {0};
+    int cnt = 0, code = 0;
+
+    while (1)
+    {
+        while (rt_device_read(elevator_uart, -1, &ch, 1) != 1)
+        {
+            str_rx[cnt] = ch;
+            cnt++;
+
+            if (check_uart_receive_over(&cnt, &code))
+                goto next;
+
+            if (check_uart_receive_done(&code, ch))
+            {
+                    rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER);
+
+                    uart_add_disp_task(str_rx, cnt);
+                    cnt = 0;
+                    rt_mutex_release(dynamic_mutex);
+            }
+
+            /* Got AA code */
+            if (cnt >= 2 && (str_rx[cnt -2] == 'A' && str_rx[cnt - 1] == 'A'))
+            {
+                memset(str_rx, 0, cnt);
+                cnt = 0;
+                code = 1;
+            }
+next:
+            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
+        }
+    }
+}
+
+static void command_callback(lv_timer_t *tmr)
+{
+    const struct uart_ioctl_desc *ioctl = NULL;
+    struct disp_task *t, *node;
+	uart_ui_ioctl_t *func;
+
+    rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER);
+
+    if (list_empty(&task))
+    {
+        rt_mutex_release(dynamic_mutex);
+        return;
+    }
+
+    list_for_each_entry_safe(t, node, &task, next) {
+        ioctl = t->ioctl;
+        func = ioctl->ui_func;
+
+        if (func)
+            func(t->data, t->data_len);
+
+        pr_debug("ioctl cmd: %d, name: %s\n", ioctl->cmd, ioctl->name);
+
+        list_del(&t->next);
+        aicos_free(MEM_CMA, t);
+    }
+
+    rt_mutex_release(dynamic_mutex);
+}
+
+int evevator_uart_main(void)
+{
+    int ret;
+
+    elevator_uart = rt_device_find(UART_DEVICE);
+    if (!elevator_uart)
+    {
+        rt_kprintf("find %s failed!\n", UART_DEVICE);
+        return -RT_ERROR;
+    }
+
+    ret = rt_device_open(elevator_uart,
+                            RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
+    if (ret != RT_EOK)
+    {
+        rt_kprintf("open %s failed : %d !\n", UART_DEVICE, ret);
+        return -RT_ERROR;
+    }
+
+    rt_device_set_rx_indicate(elevator_uart, elevator_uart_input);
+    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+
+    rt_thread_t thread_rx = rt_thread_create("uart_rx",
+                                                elevator_uart_rx_thread_entry,
+                                                RT_NULL,
+                                                1024 * 8,
+                                                15,
+                                                15);
+    if (thread_rx != RT_NULL)
+    {
+        rt_thread_startup(thread_rx);
+    }
+    else
+    {
+        rt_device_close(elevator_uart);
+        return -RT_ERROR;
+    }
+
+    dynamic_mutex = rt_mutex_create("dmutex", RT_IPC_FLAG_PRIO);
+    if (dynamic_mutex == RT_NULL)
+    {
+        rt_kprintf("create dynamic mutex failed.\n");
+        return -1;
+    }
+
+    lv_timer_create(command_callback, 150, 0);
+
+    return 0;
+}
+
+#endif /* RT_USING_FINSH */

packages/artinchip/lvgl-ui/aic_demo/elevator_demo/elevator_uart.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023-2024 ArtinChip Technology Co., Ltd.
+ * Authors:  Huahui Mai <huahui.mai@artinchip.com>
+ *
+ */
+
+#ifndef ELEVATOR_UART_H
+#define ELEVATOR_UART_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <aic_common.h>
+#include <aic_list.h>
+
+#define UART_IOCTL_NR(n)    (((n) >> 8) & 0xFF)
+
+#define UART_IOCTL_UP_DOWN _IOR(0x0, 'F', unsigned int)
+#define UART_IOCTL_LEVEL   _IOR(0x1, 'F', unsigned int)
+#define UART_IOCTL_REPLAY  _IOR(0x2, 'F', unsigned int)
+
+typedef int uart_ui_ioctl_t(void *data, unsigned int data_len);
+
+int evevator_uart_main(void);
+
+struct uart_ioctl_desc {
+	unsigned int cmd;
+	uart_ui_ioctl_t *ui_func;
+	const char *name;
+};
+
+struct disp_task {
+    const struct uart_ioctl_desc *ioctl;
+    unsigned int data_len;
+    char data[12];
+    struct list_head next;
+};
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* ELEVATOR_UART_H */
+

packages/artinchip/lvgl-ui/aic_demo/elevator_demo/elevator_ui.c

@@ -0,0 +1,579 @@
+/*
+ * Copyright (C) 2023-2024 ArtinChip Technology Co., Ltd.
+ * Authors:  Keliang Liu <keliang.liu@artinchip.com>
+ *          Huahui Mai <huahui.mai@artinchip.com>
+ */
+
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include "lvgl.h"
+#include "aic_ui.h"
+#include "aic_player.h"
+#include "elevator_ui.h"
+#include "lv_port_disp.h"
+#include "mpp_fb.h"
+
+#include "elevator_uart.h"
+
+FAKE_IMAGE_DECLARE(ELEVATOR_BG_WHITE)
+
+LV_FONT_DECLARE(ui_font_H1);
+LV_FONT_DECLARE(ui_font_Big);
+
+#define AIC_ELEVATOR_INSIDE 1
+
+#ifdef LV_ELEVATOR_UART_COMMAND
+extern rt_device_t elevator_uart;
+#endif
+
+struct elevator_player_context{
+    int file_cnt;
+    int file_index;
+    int player_state;
+    struct aic_player *player;
+    int sync_flag;
+    struct av_media_info media_info;
+    int demuxer_detected_flag;
+    int player_end;
+    struct mpp_size screen_size;
+    struct mpp_rect disp_rect;
+};
+
+lv_obj_t *outside_up_down;
+lv_obj_t *outside_level_1;
+lv_obj_t *outside_level_2;
+
+static int main_level;
+static bool main_is_up;
+static bool last_is_up;
+
+#if AIC_ELEVATOR_INSIDE
+lv_obj_t *title_date;
+lv_obj_t *inside_up_down;
+lv_obj_t *inside_level_1;
+lv_obj_t *inside_level_2;
+
+lv_obj_t *inside_up_down;
+lv_obj_t *inside_level_1;
+lv_obj_t *inside_level_2;
+lv_obj_t *inside_repari;
+char time_str[64];
+
+#define LVGL_PLAYER_STATE_PLAY      1
+#define LVGL_PLAYER_STATE_PAUSE     2
+#define LVGL_PLAYER_STATE_STOP      3
+struct elevator_player_context g_elevator_player_ctx;
+
+static int aic_elevator_lvgl_play(struct elevator_player_context *ctx)
+{
+    int ret = 0;
+
+    aic_player_set_uri(ctx->player, "/rodata/lvgl_data/elevator.mp4");
+    ctx->sync_flag = AIC_PLAYER_PREPARE_SYNC;
+    if (ctx->sync_flag == AIC_PLAYER_PREPARE_ASYNC)
+        ret = aic_player_prepare_async(ctx->player);
+    else
+        ret = aic_player_prepare_sync(ctx->player);
+
+    if (ret)
+        return -1;
+
+    if (ctx->sync_flag == AIC_PLAYER_PREPARE_SYNC) {
+        ret = aic_player_start(ctx->player);
+        if(ret != 0)
+            return -1;
+
+        aic_player_get_screen_size(ctx->player, &ctx->screen_size);
+        printf("screen_width:%d,screen_height:%d\n",ctx->screen_size.width,ctx->screen_size.height);
+        ctx->disp_rect.x = 222;
+        ctx->disp_rect.y = 80;
+        ctx->disp_rect.width = 800;
+        ctx->disp_rect.height = 460;
+
+        ret = aic_player_set_disp_rect(ctx->player, &ctx->disp_rect);
+        if(ret != 0) {
+            printf("aic_player_set_disp_rect error\n");
+            return -1;
+        }
+
+        ret =  aic_player_get_media_info(ctx->player,&ctx->media_info);
+        if (ret != 0)
+            return -1;
+
+        ret = aic_player_play(ctx->player);
+        if (ret != 0)
+            return -1;
+
+        ctx->player_end  = 0;
+    }
+    return 0;
+}
+
+s32 aic_player_event_handle(void* app_data,s32 event,s32 data1,s32 data2)
+{
+    int ret = 0;
+    struct elevator_player_context *ctx = (struct elevator_player_context *)app_data;
+
+    switch (event) {
+        case AIC_PLAYER_EVENT_PLAY_END:
+            ctx->player_end = 1;
+        case AIC_PLAYER_EVENT_PLAY_TIME:
+            break;
+        case AIC_PLAYER_EVENT_DEMUXER_FORMAT_DETECTED:
+            if (AIC_PLAYER_PREPARE_ASYNC == ctx->sync_flag)
+                ctx->demuxer_detected_flag = 1;
+
+            break;
+        case AIC_PLAYER_EVENT_DEMUXER_FORMAT_NOT_DETECTED:
+            if (AIC_PLAYER_PREPARE_ASYNC == ctx->sync_flag)
+                ctx->player_end = 1;
+
+            break;
+        default:
+            break;
+    }
+    return ret;
+}
+
+static void create_player(lv_obj_t * parent)
+{
+    lv_memset_00(&g_elevator_player_ctx, sizeof(struct elevator_player_context));
+    g_elevator_player_ctx.player = aic_player_create(NULL);
+    if (g_elevator_player_ctx.player == NULL) {
+        printf("aic_player_create fail!!!!\n");
+        return;
+    }
+
+    g_elevator_player_ctx.file_cnt =  1;
+    g_elevator_player_ctx.file_index = 0;
+    g_elevator_player_ctx.player_state = LVGL_PLAYER_STATE_STOP;
+    aic_player_set_event_callback(g_elevator_player_ctx.player, &g_elevator_player_ctx, aic_player_event_handle);
+
+    if (aic_elevator_lvgl_play(&g_elevator_player_ctx) != 0) {
+        g_elevator_player_ctx.player_state = LVGL_PLAYER_STATE_STOP;
+        g_elevator_player_ctx.player_end = 1;
+        return;
+    } else {
+        g_elevator_player_ctx.player_end  = 0;
+    }
+}
+
+static char *get_time_string()
+{
+    static const char *week_day[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
+    static time_t unix_time;
+    static struct tm *time_info;
+
+    unix_time = time(NULL);
+    time_info = localtime(&unix_time);
+
+    int year = time_info->tm_year+1900;
+    int month = time_info->tm_mon + 1;
+    int day = time_info->tm_mday;
+    int weekday = time_info->tm_wday;
+    int hour = time_info->tm_hour;
+    int minutes = time_info->tm_min;
+    int second = time_info->tm_sec;
+
+    snprintf(time_str, sizeof(time_str), "%04d-%02d-%02d %s %02d:%02d:%02d", year, month, day, week_day[weekday], hour, minutes, second);
+    return time_str;
+}
+
+static void create_data_time(lv_obj_t *parament_obj)
+{
+    title_date = lv_label_create(parament_obj);
+    lv_obj_align(title_date, LV_ALIGN_CENTER, 0, 0);
+    lv_label_set_text(title_date, get_time_string());
+    lv_obj_center(title_date);
+    lv_obj_set_style_text_color(title_date, lv_color_hex(0xFFFFFF), 0);
+    lv_obj_set_style_text_opa(title_date, 255, 0);
+    lv_obj_set_style_text_font(title_date, &ui_font_H1, 0);
+}
+
+#ifndef LV_ELEVATOR_UART_COMMAND
+static void update_data_time(lv_obj_t *inside_level_1)
+{
+    lv_label_set_text(title_date, get_time_string());
+}
+
+static void timer_inside_callback(lv_timer_t *tmr)
+{
+    char image_str[64];
+
+    if (main_is_up)
+        main_level ++;
+    else
+        main_level --;
+
+    if (main_level > ELEVATOR_MAX_LEVEL) {
+        main_is_up = false;
+        main_level = ELEVATOR_MAX_LEVEL;
+    }
+    if (main_level < 1) {
+        main_is_up = true;
+        main_level = 1;
+    }
+
+    if (main_is_up != last_is_up) {
+        if(main_is_up)
+            lv_img_set_src(inside_up_down, LVGL_PATH(inside/arrow_up_Image.png));
+        else
+            lv_img_set_src(inside_up_down, LVGL_PATH(inside/arrow_down_Image.png));
+
+        last_is_up = main_is_up;
+    }
+
+    if (main_level == 12) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_12A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 13) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_12B_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 14) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_15A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 15) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_15B_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 24) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_23A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 34) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_33A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level > 0 && main_level < 10) {
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level);
+        lv_img_set_src(inside_level_1, image_str);
+        lv_obj_set_pos(inside_level_1, 50 + 30, 80 + 50 + 121);
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level > 9 && main_level < 20) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_1_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 10);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    } else if (main_level > 19 && main_level < 30) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_2_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 20);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    } else if (main_level > 29 && main_level < 40) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_3_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 30);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    }
+
+    if(main_level % 2 == 0)
+        lv_img_set_src(inside_repari, LVGL_PATH(inside/repair_Image.png));
+    else
+        lv_img_set_src(inside_repari, LVGL_PATH(inside/siji_Image.png));
+
+    update_data_time(title_date);
+    return;
+}
+#endif
+
+#ifdef LV_ELEVATOR_UART_COMMAND
+int inside_up_down_ioctl(void *data, unsigned int data_len)
+{
+    char *str_rx = data;
+    int enable;
+
+    enable = atoi(str_rx);
+
+    if (enable)
+        lv_img_set_src(inside_up_down, LVGL_PATH(inside/arrow_down_Image.png));
+    else
+        lv_img_set_src(inside_up_down, LVGL_PATH(inside/arrow_up_Image.png));
+
+    return 0;
+}
+
+int inside_level_ioctl(void *data, unsigned int data_len)
+{
+    char *str_rx = data;
+    int main_level = atoi(str_rx);
+    char send_srt[16] = { 0 };
+    char image_str[64];
+
+    lv_snprintf(send_srt, sizeof(send_srt), "level: %d", main_level);
+    rt_device_write(elevator_uart, 0, send_srt, strlen(send_srt));
+
+    if (main_level == 12) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_12A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 13) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_12B_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 14) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_15A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 15) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_15B_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 24) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_23A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 34) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_3_33A_Image.png));
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level > 0 && main_level < 10) {
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level);
+        lv_img_set_src(inside_level_1, image_str);
+        lv_obj_set_pos(inside_level_1, 50 + 30, 80 + 50 + 121);
+        lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if(main_level > 9 && main_level < 20) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_1_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 10);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    } else if (main_level > 19 && main_level < 30) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_2_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str,sizeof(image_str),  LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 20);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    } else if (main_level > 29 && main_level < 40) {
+        lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_3_Image.png));
+        lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(inside/floor_l_%d_Image.png), main_level % 30);
+        lv_obj_clear_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(inside_level_2, image_str);
+    }
+
+    return 0;
+}
+
+int replayer_ioctl(void *data, unsigned int data_len)
+{
+#if AIC_ELEVATOR_INSIDE
+    char *str[] = { "replayer", "wait player" };
+
+    if(g_elevator_player_ctx.player_end == 1)
+    {
+        aic_player_stop(g_elevator_player_ctx.player);
+        aic_elevator_lvgl_play(&g_elevator_player_ctx);
+
+        rt_device_write(elevator_uart, 0, str[0], strlen(str[0]));
+    }
+    else
+    {
+        rt_device_write(elevator_uart, 0, str[1], strlen(str[1]));
+    }
+#endif
+    return 0;
+}
+#endif
+
+void aic_elevator_create_main(lv_obj_t *tab)
+{
+    FAKE_IMAGE_INIT(ELEVATOR_BG_WHITE, 1024, 600, 0, 0x00000000);
+    lv_obj_t * img_bg;
+    img_bg = lv_img_create(tab);
+
+    lv_img_set_src(img_bg, FAKE_IMAGE_NAME(ELEVATOR_BG_WHITE));
+    lv_obj_set_pos(img_bg, 0, 0);
+    lv_obj_clear_flag(tab, LV_OBJ_FLAG_SCROLLABLE);
+
+    //220 x 80
+    lv_obj_t * image_otistitle = lv_img_create(tab);
+    lv_img_set_src(image_otistitle, LVGL_PATH(inside/otistitle.png));
+    lv_obj_set_pos(image_otistitle, 0, 0);
+
+    //860 x 80
+    lv_obj_t * image_datetime = lv_img_create(tab);
+    lv_img_set_src(image_datetime, LVGL_PATH(inside/datetime.png));
+    lv_obj_set_pos(image_datetime, 222, 0);
+
+    create_data_time(image_datetime);
+
+    //200 x 520
+    lv_obj_t * image_panel = lv_img_create(tab);
+    lv_img_set_src(image_panel, LVGL_PATH(inside/panel.png));
+    lv_obj_set_pos(image_panel, 0 , 82);
+
+    //800 x 60
+    lv_obj_t * image_bottom = lv_img_create(tab);
+    lv_img_set_src(image_bottom, LVGL_PATH(inside/bottom.png));
+    lv_obj_set_pos(image_bottom, 222,  540);
+
+    lv_obj_t *title_wel= lv_label_create(image_bottom);
+    lv_obj_align(title_wel, LV_ALIGN_CENTER, 0, 0);
+    lv_label_set_text(title_wel, "Welcom to OTIS electric");
+    lv_obj_center(title_wel);
+    lv_obj_set_style_text_color(title_wel, lv_color_hex(0xFFFFFF), 0);
+    lv_obj_set_style_text_opa(title_wel, 255, 0);
+    lv_obj_set_style_text_font(title_wel, &ui_font_Big, 0);
+
+    //117 x 121
+    inside_up_down = lv_img_create(tab);
+    lv_img_set_src(inside_up_down, LVGL_PATH(inside/arrow_up_Image.png));
+    lv_obj_set_pos(inside_up_down, 50, 80 + 30);
+
+    //60 x 95
+    inside_level_1 = lv_img_create(tab);
+    lv_img_set_src(inside_level_1, LVGL_PATH(inside/floor_l_1_Image.png));
+    lv_obj_set_pos(inside_level_1, 50, 80 + 50 + 121);
+    inside_level_2 = lv_img_create(tab);
+    lv_img_set_src(inside_level_2, LVGL_PATH(inside/floor_l_1_Image.png));
+    lv_obj_set_pos(inside_level_2, 120, 80 + 50 + 121);
+    lv_obj_add_flag(inside_level_2, LV_OBJ_FLAG_HIDDEN);
+
+    //116 x 32
+    inside_repari = lv_img_create(tab);
+    lv_img_set_src(inside_repari, LVGL_PATH(inside/repair_Image.png));
+    lv_obj_set_pos(inside_repari, 50, 80 + 80 + 121 + 95 + 80);
+
+#ifndef LV_ELEVATOR_UART_COMMAND
+    lv_timer_create(timer_inside_callback, 500, 0);
+#endif
+}
+#endif
+
+static void timer_outside_callback(lv_timer_t *tmr)
+{
+    int x_margin = 20;
+    int y_margin = 20;
+    char image_str[64];
+
+    if(main_is_up)
+        main_level ++;
+    else
+        main_level --;
+
+    if (main_level > ELEVATOR_MAX_LEVEL) {
+        main_is_up = false;
+        main_level = ELEVATOR_MAX_LEVEL;
+    }
+    if (main_level < 1) {
+        main_is_up = true;
+        main_level = 1;
+    }
+
+    if (main_is_up != last_is_up) {
+        if (main_is_up)
+            lv_img_set_src(outside_up_down, LVGL_PATH(outside/arrow_up_Image.png));
+        else
+            lv_img_set_src(outside_up_down, LVGL_PATH(outside/arrow_down_Image.png));
+
+        last_is_up = main_is_up;
+    }
+
+    if (main_level == 12) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_12A_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 13) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_12B_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 14) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_15A_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 15) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_15B_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 24) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_23A_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if (main_level == 34) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_3_33A_Image.png));
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if(main_level > 0 && main_level < 10) {
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(outside/floor_l_%d_Image.png), main_level);
+        lv_img_set_src(outside_level_1, image_str);
+        lv_obj_set_pos(outside_level_1, 1024 / 2 + x_margin, 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+        lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+    } else if(main_level > 9 && main_level < 20) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_l_1_Image.png));
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(outside/floor_l_%d_Image.png), main_level % 10);
+        lv_obj_set_pos(outside_level_1, 1024 / 2 - x_margin, 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+        lv_obj_clear_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(outside_level_2, image_str);
+    } else if(main_level > 19 && main_level < 30) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_l_2_Image.png));
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(outside/floor_l_%d_Image.png), main_level % 20);
+        lv_obj_set_pos(outside_level_1, 1024 / 2 - x_margin, 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+        lv_obj_clear_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(outside_level_2, image_str);
+    } else if(main_level > 29 && main_level < 40) {
+        lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_l_3_Image.png));
+        snprintf(image_str, sizeof(image_str), LVGL_PATH(outside/floor_l_%d_Image.png),main_level % 30);
+        lv_obj_set_pos(outside_level_1, 1024 / 2 - x_margin, 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+        lv_obj_clear_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+        lv_img_set_src(outside_level_2, image_str);
+    }
+
+    return;
+}
+
+void aic_elevator_create_outside(lv_obj_t *tab)
+{
+    FAKE_IMAGE_INIT(ELEVATOR_BG_WHITE, 1024, 600, 0, 0xFFFFFFFF);
+    int x_margin = 20;
+    int y_margin = 20;
+    lv_obj_t * img_bg;
+    img_bg = lv_img_create(tab);
+
+    lv_img_set_src(img_bg, FAKE_IMAGE_NAME(ELEVATOR_BG_WHITE));
+    lv_obj_set_pos(img_bg, 0, 0);
+
+    //220 x 228
+    outside_up_down = lv_img_create(tab);
+    lv_img_set_src(outside_up_down, LVGL_PATH(outside/arrow_up_Image.png));
+    //lv_obj_align(outside_up_down, LV_ALIGN_CENTER, -70, -30);
+    lv_obj_set_pos(outside_up_down, 1024 / 2 - 220 - x_margin, 600 / 2 - 228 + y_margin);
+
+    //126 x 200
+    outside_level_1 = lv_img_create(tab);
+    lv_img_set_src(outside_level_1, LVGL_PATH(outside/floor_l_1_Image.png));
+    //lv_obj_align(outside_level_1, LV_ALIGN_CENTER, 10, -30);
+    lv_obj_set_pos(outside_level_1, 1024 / 2 - x_margin, 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+
+    //126 x 200
+    outside_level_2 = lv_img_create(tab);
+    lv_img_set_src(outside_level_2, LVGL_PATH(outside/floor_l_7_Image.png));
+    //lv_obj_align(outside_level_2, LV_ALIGN_CENTER, 10 + 60, -30);
+    lv_obj_set_pos(outside_level_2, 1024 / 2  + 126 - x_margin , 600 / 2 - 200 - (228 - 200) /2 + y_margin);
+    lv_obj_add_flag(outside_level_2, LV_OBJ_FLAG_HIDDEN);
+
+    //118 x 143
+    lv_obj_t *overload_image = lv_img_create(tab);
+    lv_img_set_src(overload_image, LVGL_PATH(outside/overload_Image.png));
+    lv_obj_align(overload_image, LV_ALIGN_CENTER, - (10 + 118), 100);
+
+    //118 x 143
+    lv_obj_t *nosmoke_image = lv_img_create(tab);
+    lv_img_set_src(nosmoke_image, LVGL_PATH(outside/nosmoke_Image.png));
+    lv_obj_align(nosmoke_image, LV_ALIGN_CENTER, 0, 100);
+
+    //118 x 143
+    lv_obj_t *fire_img = lv_img_create(tab);
+    lv_img_set_src(fire_img, LVGL_PATH(outside/fire_Image.png));
+    lv_obj_align(fire_img, LV_ALIGN_CENTER, 10 + 118, 100);
+
+    lv_timer_create(timer_outside_callback, 500, 0);
+}
+
+void elevator_ui_init()
+{
+    main_level = 1;
+    main_is_up = true; //0: down, 1: up
+    last_is_up = main_is_up;
+
+#if AIC_ELEVATOR_INSIDE
+    aic_elevator_create_main(lv_scr_act());
+    create_player(lv_scr_act());
+#ifdef LV_ELEVATOR_UART_COMMAND
+    evevator_uart_main();
+#endif
+#else
+    aic_elevator_create_outside(lv_scr_act());
+#endif
+}
+

packages/artinchip/lvgl-ui/aic_demo/elevator_demo/elevator_ui.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023-2024 ArtinChip Technology Co., Ltd.
+ * Authors:  Keliang Liu <keliang.liu@artinchip.com>
+ *          Huahui Mai <huahui.mai@artinchip.com>
+ */
+
+#ifndef ELEVATOR_UI_H
+#define ELEVATOR_UI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ELEVATOR_MAX_LEVEL 36
+
+void elevator_ui_init();
+
+#ifdef LV_ELEVATOR_UART_COMMAND
+int inside_up_down_ioctl(void *data, unsigned int data_len);
+int inside_level_ioctl(void *data, unsigned int data_len);
+int replayer_ioctl(void *data, unsigned int data_len);
+#endif
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* ELEVATOR_UI_H */
+