update prepare_for_master latest commit from 2023_open_source_contest from Liu_Weichao

it is OK

.gitmodules

@@ -1,24 +1,34 @@
 [submodule "Ubiquitous/RT-Thread_Fusion_XiUOS/rt-thread"]
 	path = Ubiquitous/RT-Thread_Fusion_XiUOS/rt-thread
-	url = https://code.gitlink.org.cn/chunyexixiaoyu/rt-thread.git
+	url = https://www.gitlink.org.cn/chunyexixiaoyu/rt-thread.git
 [submodule "Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/k210/kendryte-sdk/kendryte-sdk-source"]
 	path = Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/k210/kendryte-sdk/kendryte-sdk-source
-	url = https://code.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
+	url = https://www.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
 [submodule "Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/aiit-riscv64-board/kendryte-sdk/kendryte-sdk-source"]
 	path = Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/aiit-riscv64-board/kendryte-sdk/kendryte-sdk-source
-	url = https://code.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
+	url = https://www.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
 [submodule "Ubiquitous/XiZi/fs/lwext4/lwext4_submodule"]
 	path = Ubiquitous/XiZi/fs/lwext4/lwext4_submodule
 	url = https://gitlink.org.cn/xuos/lwext4_filesystem_support_XiUOS.git
 [submodule "Ubiquitous/Nuttx_Fusion_XiUOS/nuttx"]
 	path = Ubiquitous/Nuttx_Fusion_XiUOS/nuttx
-	url = https://code.gitlink.org.cn/wgzAIIT/incubator-nuttx.git
+	url = https://www.gitlink.org.cn/wgzAIIT/incubator-nuttx.git
 [submodule "Ubiquitous/Nuttx_Fusion_XiUOS/apps"]
 	path = Ubiquitous/Nuttx_Fusion_XiUOS/apps
-	url = https://code.gitlink.org.cn/wgzAIIT/incubator-nuttx-apps.git
+	url = https://www.gitlink.org.cn/wgzAIIT/incubator-nuttx-apps.git
 [submodule "APP_Framework/Applications/webnet/WebNet_XiUOS"]
 	path = APP_Framework/Applications/webnet/WebNet_XiUOS
 	url = https://gitlink.org.cn/xuos/WebNet_XiUOS.git
 [submodule "Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/xidatong-riscv64/kendryte-sdk/kendryte-sdk-source"]
 	path = Ubiquitous/RT-Thread_Fusion_XiUOS/aiit_board/xidatong-riscv64/kendryte-sdk/kendryte-sdk-source
-	url = https://code.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
+	url = https://www.gitlink.org.cn/chunyexixiaoyu/kendryte-sdk-source.git
+[submodule "APP_Framework/lib/lorawan/lora_radio_driver"]
+	path = APP_Framework/lib/lorawan/lora_radio_driver
+	url = https://gitlink.org.cn/IACU/lora_radio_driver.git
+[submodule "APP_Framework/lib/lorawan/lorawan_devicenode"]
+	path = APP_Framework/lib/lorawan/lorawan_devicenode
+	url = https://gitlink.org.cn/IACU/lorawan_devicenode.git
+	branch = master
+[submodule "APP_Framework/lib/lorawan/lorawan_gateway_single_channel"]
+	path = APP_Framework/lib/lorawan/lorawan_gateway_single_channel
+	url = https://gitlink.org.cn/IACU/lorawan_gateway_single_channel.git

APP_Framework/Applications/Make.defs

@@ -2,7 +2,6 @@
 # APP_Framework/Applications/Make.defs
 ############################################################################
 CONFIGURED_APPS += $(APPDIR)/../../../APP_Framework/Applications
-CONFIGURED_APPS += $(APPDIR)/../../../APP_Framework/Applications/app_test
 CONFIGURED_APPS += $(APPDIR)/../../../APP_Framework/Applications/general_functions/list
 
 include $(wildcard $(APPDIR)/../../../APP_Framework/Applications/*/Make.defs)

APP_Framework/Applications/Makefile

@@ -1,18 +1,19 @@
 include $(KERNEL_ROOT)/.config
 
-ifeq ($(CONFIG_ADD_NUTTX_FETURES),y)
+ifeq ($(CONFIG_ADD_NUTTX_FEATURES),y)
     include $(APPDIR)/Make.defs
-    CSRCS += framework_init.c
+    CSRCS +=
     include $(APPDIR)/Application.mk
 endif
 
 
-ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
+ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
     SRC_DIR := general_functions app_test 
 
-    SRC_FILES := main.c framework_init.c 
+    SRC_FILES := main.c
     ifeq ($(CONFIG_LIB_LV),y)
         SRC_DIR += lv_app
+        SRC_DIR += tinyttf_app
     endif
 
     ifeq ($(CONFIG_APPLICATION_OTA),y)

APP_Framework/Applications/app_test/Kconfig

@@ -8,7 +8,7 @@ menu "test app"
                 bool "Config test adc"
                 default n
                 if USER_TEST_ADC
-                    if ADD_XIZI_FETURES
+                    if ADD_XIZI_FEATURES
                         config ADC_DEV_DRIVER
                             string "Set ADC dev path"
                             default "/dev/adc1_dev"
@@ -19,13 +19,186 @@ menu "test app"
                 bool "Config test dac"
                 default n
                 if USER_TEST_DAC
-                    if ADD_XIZI_FETURES
+                    if ADD_XIZI_FEATURES
                         config DAC_DEV_DRIVER
                             string "Set DAC dev path"
                             default "/dev/dac_dev"
                     endif
                 endif
 
+            menuconfig USER_TEST_FS
+                bool "Config test fs with sd or usb"
+                default n
+                if USER_TEST_FS
+                    if ADD_XIZI_FEATURES
+                        config FPATH
+                            string "Set test file path"
+                            default "/test_file"
+                    endif
+                endif
+
+
+            menuconfig USER_TEST_GPIO
+                select BSP_USING_GPIO
+                select RESOURCES_PIN
+                select BSP_USING_LED
+                select BSP_USING_KEY
+                bool "Config test gpio with led and key"
+                default n
+                if USER_TEST_GPIO
+                    if ADD_XIZI_FEATURES
+                        config GPIO_DEV_DRIVER
+                            string "Set gpio dev path"
+                            default "/dev/pin_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_LORA
+                select BSP_USING_UART
+                select BSP_USING_GPIO
+                select RESOURCES_PIN
+                select BSP_USING_UART2
+                select BSP_USING_LORA
+                bool "Config test uart(loraE220)"
+                default n
+                if USER_TEST_LORA
+                    if ADD_XIZI_FEATURES
+                        config LORA_UART_DEV_DRIVER
+                            string "Set uart dev path"
+                            default "/dev/uart2_dev2"
+                        config LORA_PIN_DEV_DRIVER
+                            string "Set pin dev path"
+                            default "/dev/pin_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_RS485
+                select BSP_USING_UART
+                select BSP_USING_GPIO
+                select RESOURCES_PIN
+                select BSP_USING_UART1
+                bool "Config test uart(RS485)"
+                default n
+                if USER_TEST_RS485
+                    if ADD_XIZI_FEATURES
+                        config RS485_UART_DEV_DRIVER
+                            string "Set uart dev path"
+                            default "/dev/uart1_dev1"
+                        config RS485_PIN_DEV_DRIVER
+                            string "Set pin dev path"
+                            default "/dev/pin_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_RTC
+                select BSP_USING_RTC
+                bool "Config test rtc"
+                default n
+                if USER_TEST_RTC
+                    if ADD_XIZI_FEATURES
+                        config RTC_DEV_DRIVER
+                            string "Set rtc dev path"
+                            default "/dev/rtc_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_HWTIMER
+                select BSP_USING_HWTIMER
+                select BSP_USING_GPIO
+                select RESOURCES_PIN
+                select BSP_USING_LED
+                bool "Config test hwtimer"
+                default n
+                if USER_TEST_HWTIMER
+                    if ADD_XIZI_FEATURES
+                        config HWTIMER_TIMER_DEV_DRIVER
+                            string "Set pin dev path"
+                            default "/dev/timer0_dev0"
+                        config HWTIMER_PIN_DEV_DRIVER
+                            string "Set pin dev path"
+                            default "/dev/pin_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_WDT
+                select BSP_USING_WDT0
+                bool "Config test watchdog"
+                default n
+                if USER_TEST_WDT
+                    if ADD_XIZI_FEATURES
+                        config WDT0_DEV_DRIVER
+                            string "Set wdt dev path"
+                            default "/dev/wdt0_dev0"
+                    endif
+                endif
+
+            menuconfig USER_TEST_LCD_EDU
+                select BSP_USING_LCD
+                bool "Config test lcd in PrivOpen"
+                default n
+                if USER_TEST_LCD_EDU
+                    if ADD_XIZI_FEATURES
+                        config EDU_LCD_DEV_DRIVER
+                            string "Set lcd dev path"
+                            default "/dev/lcd_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_TOUCH
+                select BSP_USING_TOUCH
+                bool "Config test touch"
+                default n
+                if USER_TEST_TOUCH
+                    if ADD_XIZI_FEATURES
+                        config TOUCH_DEV_DRIVER
+                            string "Set touch dev path"
+                            default "/dev/touch_dev"
+                        config TOUCH_LCD_DEV_DRIVER
+                            string "Set lcd dev path"
+                            default "/dev/lcd_dev"
+                    endif
+                endif
+
+            menuconfig USER_TEST_I2C
+                select BSP_USING_I2C
+                bool "Config test i2c"
+                default n
+                if USER_TEST_I2C
+                    if ADD_XIZI_FEATURES
+                        config I2C_DEV_DRIVER
+                            string "Set i2c dev path"
+                            default "/dev/i2c1_dev0"
+                    endif
+                endif
+
+            menuconfig USER_TEST_CAN
+                select BSP_USING_CAN
+                bool "Config test can"
+                default n
+                if USER_TEST_CAN
+                    if ADD_XIZI_FEATURES
+                        config CAN_DEV_DRIVER
+                            string "Set can dev path"
+                            default "/dev/can2_dev1"
+                    endif
+                endif
+
+            menuconfig USER_TEST_CAMERA
+                select BSP_USING_CAMERA
+                select BSP_USING_LCD
+                bool "Config test camera with lcd"
+                default n
+                if USER_TEST_CAMERA
+                    if ADD_XIZI_FEATURES
+                        config CAMERA_DEV_DRIVER
+                            string "Set camera dev path"
+                            default "/dev/camera_dev"
+                        config CAMERA_LCD_DEV_DRIVER
+                            string "Set lcd dev path"
+                            default "/dev/lcd_dev"
+                    endif
+                endif
+
             config USER_TEST_SEMC
                 bool "Config test semc sdram"
                 default n
@@ -33,5 +206,43 @@ menu "test app"
             config USER_TEST_LCD
                 bool "Config test lcd device"
                 default n
+
+            menuconfig USER_TEST_ETHERNET
+                bool "Config test ethernet only for edu-riscv64"
+                default n
+                if USER_TEST_ETHERNET
+                    if ADD_XIZI_FEATURES
+                        choice 
+                            prompt "set ethernet role as client or server"
+                            default ETHERNET_AS_SERVER
+
+                            config ETHERNET_AS_SERVER
+                            bool "test as server"
+
+                            config ETHERNET_AS_CLIENT
+                            bool "test as client"
+                        endchoice
+                    endif
+                endif
+            
+            menuconfig USER_TEST_FLASH
+                bool "Config test w25q128 device"
+                default n
+                if USER_TEST_FLASH
+                    if ADD_XIZI_FEATURES
+                        config FLASH_DEV_DRIVER
+                            string "Set flash dev path"
+                            default "/dev/qspi_W25Q128"
+                    endif
+                endif
+
+            menuconfig USER_TEST_TIMER
+                bool "Config test soft timer"
+                default n
+            
+            menuconfig USER_TEST_RBTREE
+                bool "Config test red black tree"
+                default n
+
         endif
 endmenu

APP_Framework/Applications/app_test/Makefile

@@ -1,5 +1,5 @@
 include $(KERNEL_ROOT)/.config
-ifeq ($(CONFIG_ADD_NUTTX_FETURES),y)
+ifeq ($(CONFIG_ADD_NUTTX_FEATURES),y)
     include $(APPDIR)/Make.defs
 
     ifeq ($(CONFIG_USER_TEST_SEMC),y)
@@ -10,11 +10,19 @@ ifeq ($(CONFIG_ADD_NUTTX_FETURES),y)
         CSRCS += test_lcd.c
     endif
 
+    ifeq ($(CONFIG_BSP_USING_TOUCH),y)
+        CSRCS += test_touch.c
+    endif
+
+    ifeq ($(CONFIG_MUSL_LIBC),y)
+        CSRCS += test_musl.c
+    endif
+
     include $(APPDIR)/Application.mk
 
 endif
 
-ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
+ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
     SRC_FILES := test_shell.c
 
     ifeq ($(CONFIG_USER_TEST_ADC),y)
@@ -25,6 +33,10 @@ ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
         SRC_FILES += test_dac.c
     endif
 
+    ifeq ($(CONFIG_USER_TEST_FS),y)
+        SRC_FILES += test_fs.c
+    endif
+
     ifeq ($(CONFIG_USER_TEST_SEMC),y)
         SRC_FILES += test_extsram.c
     endif
@@ -33,5 +45,65 @@ ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
         SRC_FILES +=
     endif
 
+    ifeq ($(CONFIG_USER_TEST_I2C),y)
+        SRC_FILES += test_i2c.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_GPIO),y)
+        SRC_FILES += test_gpio.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_LORA),y)
+        SRC_FILES += test_loraE220.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_RTC),y)
+        SRC_FILES += test_rtc.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_RS485),y)
+        SRC_FILES += test_rs485.c
+    endif    
+
+    ifeq ($(CONFIG_USER_TEST_HWTIMER),y)
+        SRC_FILES += test_hwtimer.c
+    endif  
+
+    ifeq ($(CONFIG_USER_TEST_LCD_EDU),y)
+        SRC_FILES += test_lcd_edu.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_WDT),y)
+        SRC_FILES += test_wdt.c
+    endif 
+
+    ifeq ($(CONFIG_USER_TEST_TOUCH),y)
+        SRC_FILES += test_touch.c
+    endif 
+
+    ifeq ($(CONFIG_USER_TEST_CAMERA),y)
+        SRC_FILES += test_camera.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_ETHERNET),y)
+        SRC_FILES += test_ethernet.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_FLASH),y)
+        SRC_FILES += test_flash.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_CAN),y)
+        SRC_FILES += test_can.c
+    endif    
+
+    ifeq ($(CONFIG_USER_TEST_TIMER),y)
+        SRC_FILES += test_timer.c
+    endif
+
+    ifeq ($(CONFIG_USER_TEST_RBTREE),y)
+        SRC_FILES += test_rbtree/test_rbtree.c
+    endif    
+
     include $(KERNEL_ROOT)/compiler.mk
 endif

APP_Framework/Applications/app_test/test_adc.c

@@ -21,6 +21,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <transform.h>
+#ifdef ADD_XIZI_FEATURES
 
 void TestAdc(void)
 {
@@ -57,3 +58,4 @@ void TestAdc(void)
     return;
 }
 PRIV_SHELL_CMD_FUNCTION(TestAdc, a adc test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_camera.c

@@ -0,0 +1,120 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_camera.c
+* @brief:   a application of camera function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/7
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+static uint16_t image_buff[384000];
+
+void TestCamera(int argc, char *argv[])
+{
+    int frame_counter = 10000;
+    if (argc > 1)
+    {
+        frame_counter = atoi(argv[1]);
+    }
+    printf("This test will refresh %d frames\n", frame_counter);
+
+    int camera_fd = PrivOpen(CAMERA_DEV_DRIVER, O_RDWR);
+    if (camera_fd < 0)
+    {
+        printf("open camera fd error:%d\n", camera_fd);
+        return;
+    }
+    int lcd_fd = PrivOpen(CAMERA_LCD_DEV_DRIVER, O_RDWR);
+    if (lcd_fd < 0)
+    {
+        printf("open lcd fd error:%d\n", lcd_fd);
+        return;
+    }
+
+    //configure the camera's output address
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = CAMERA_TYPE;
+    struct CameraCfg camera_cfg ={
+        .gain_manu_enable = 0,
+        .gain = 0xFF,
+        .window_w = 800,
+        .window_h = 600,
+        .output_w = IMAGE_WIDTH,
+        .output_h = IMAGE_HEIGHT,
+        .window_xoffset = 0,
+        .window_yoffset = 0
+    };
+    ioctl_cfg.args = &camera_cfg;
+    if (0 != PrivIoctl(camera_fd, OPE_CFG, &ioctl_cfg))
+    {
+        printf("camera pin fd error %d\n", camera_fd);
+        PrivClose(camera_fd);
+        return;
+    }
+
+    ioctl_cfg.args = (void *)image_buff;
+
+    if (0 != PrivRead(camera_fd, image_buff, NULL_PARAMETER))
+    {
+        printf("camera pin fd error %d\n", camera_fd);
+        PrivClose(camera_fd);
+        return;
+    }
+
+    printf("address buff is %x\n", image_buff);
+
+
+    LcdWriteParam graph_param;
+    graph_param.type = LCD_DOT_TYPE;
+
+    //clear the LCD
+    uint16_t back_color[LCD_SIZE];
+    memset(back_color,0,sizeof(back_color));
+    for (int i = 0; i < LCD_SIZE; i++)
+    {
+        graph_param.pixel_info.pixel_color = &back_color;
+        graph_param.pixel_info.x_startpos = 0;
+        graph_param.pixel_info.y_startpos = i;
+        graph_param.pixel_info.x_endpos = LCD_SIZE -1;
+        graph_param.pixel_info.y_endpos = i;
+        PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+    }
+
+    //refresh the LCD using photo of camera
+    while (frame_counter--)
+    {
+        for (int i = 0; i < IMAGE_HEIGHT; i++)
+        {
+            graph_param.pixel_info.pixel_color = image_buff + i * IMAGE_WIDTH;
+            graph_param.pixel_info.x_startpos = 0;
+            graph_param.pixel_info.y_startpos = i + (LCD_SIZE - IMAGE_HEIGHT) / 2;
+            graph_param.pixel_info.x_endpos = IMAGE_WIDTH - 1;
+            graph_param.pixel_info.y_endpos = i + (LCD_SIZE - IMAGE_HEIGHT) / 2;
+            PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+        }
+    }
+
+    // close test
+    PrivClose(lcd_fd);
+    PrivClose(camera_fd);
+    printf("The camera test is finished successfully\n");
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestCamera, a camera test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_can.c

@@ -0,0 +1,87 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_can.c
+* @brief:   a application of can function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2023/2/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+
+void TestCAN(void)
+{
+    // config CAN pin(SCL:34.SDA:35) in menuconfig
+    int can_fd = PrivOpen(CAN_DEV_DRIVER, O_RDWR);
+    if (can_fd < 0)
+    {
+        printf("open can_fd fd error:%d\n", can_fd);
+        return;
+    }
+    printf("CAN open successful!\n");
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = CAN_TYPE;
+
+    struct CanDriverConfigure can_config;
+    can_config.brp  = 8U;
+    can_config.tbs1 = 1U + 8U;
+    can_config.tbs2 = 4U;
+    can_config.tsjw = 4U;
+    can_config.mode = 0U;
+
+    ioctl_cfg.args = (void *)&can_config;
+
+    if (0 != PrivIoctl(can_fd, OPE_INT, &ioctl_cfg))
+    {
+        printf("init can fd error %d\n", can_fd);
+        PrivClose(can_fd);
+        return;
+    }
+    printf("CAN configure successful!\n");
+
+    uint8_t data_buff[64u] = {1,2,3,4,4,3,2,1};
+    struct CanSendConfigure frame_send;
+    frame_send.ide=0;
+    frame_send.stdid = 0x55;
+    frame_send.rtr=0;
+    frame_send.data_lenth=8;
+    frame_send.data = data_buff;
+
+    struct CanSendConfigure frame_recv;
+    uint8_t recv_buff[65U] = {0};
+    frame_recv.data = recv_buff;
+
+    // CAN write
+    while (1)
+    {
+        PrivTaskDelay(500);
+        PrivWrite(can_fd, &frame_send, NONE);
+        PrivTaskDelay(500);
+        PrivRead(can_fd, &frame_recv, NONE);
+        // if any data has received,Then printf message
+        if(frame_recv.data_lenth > 0){
+            printf("ID %08x:%s\n",frame_recv.exdid,frame_recv.data);
+        }
+    }
+
+    PrivClose(can_fd);
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestCAN, a can test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_dac.c

@@ -17,10 +17,10 @@
 * @author:  AIIT XUOS Lab
 * @date:    2022/1/11
 */
-
 #include <stdio.h>
 #include <string.h>
 #include <transform.h>
+#ifdef ADD_XIZI_FEATURES
 
 void TestDac(void)
 {
@@ -57,3 +57,4 @@ void TestDac(void)
     return;
 }
 PRIV_SHELL_CMD_FUNCTION(TestDac, a dac test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_ethernet.c

@@ -0,0 +1,194 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_ethernet.c
+* @brief:   a application of ethernet function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#include <socket.h>
+
+#define BUFF_SIZE 128
+#define RECV_SIZE 16
+#define TCP_PORT  12345
+
+const static uint32_t sn = 0;
+
+#ifdef ETHERNET_AS_SERVER
+static int32_t wiz_server_op(uint8_t sn, uint8_t *buf, uint32_t buf_size,
+                      uint16_t port, enum TCP_OPTION opt) {
+  int32_t ret = 0;
+  uint16_t size = 0, sentsize = 0;
+  switch (getSn_SR(sn)) {
+    case SOCK_ESTABLISHED:
+      if (getSn_IR(sn) & Sn_IR_CON) {
+        printf("%d:Connected\r\n", sn);
+        setSn_IR(sn, Sn_IR_CON);
+      }
+      if (opt == SEND_DATA) {
+        uint32_t sent_size = 0;
+        memset(buf,0,buf_size);
+        strcpy(buf,"The message has been recved");
+        ret = wiz_sock_send(sn, buf, buf_size);
+        if (ret < 0) {
+          wiz_sock_close(sn);
+          return ret;
+        }
+      } else if (opt == RECV_DATA) {
+        uint32_t size = 0;
+        if ((size = getSn_RX_RSR(sn)) > 0) {
+          if (size > buf_size) size = buf_size;
+          memset(buf,0,buf_size);
+          ret = wiz_sock_recv(sn, buf, size);
+          printf("Recv message: %s\n",buf);
+          return ret;
+        }
+      }
+      break;
+    case SOCK_CLOSE_WAIT:
+      printf("%d:CloseWait\r\n", sn);
+      if ((ret = wiz_sock_disconnect(sn)) != SOCK_OK) return ret;
+      printf("%d:Closed\r\n", sn);
+      break;
+    case SOCK_INIT:
+      printf("%d:Listen, port [%d]\r\n", sn, port);
+      if ((ret = wiz_sock_listen(sn)) != SOCK_OK) return ret;
+      break;
+    case SOCK_CLOSED:
+      printf("%d:LBTStart\r\n", sn);
+      if ((ret = wiz_socket(sn, Sn_MR_TCP, port, 0x00)) != sn) return ret;
+      printf("%d:Opened\r\n", sn);
+      break;
+    default:
+      break;
+  }
+  return 0;
+}
+
+void TestSocketAsServer(int argc, char *argv[])
+{
+    x_err_t ret;
+    uint8_t buf[BUFF_SIZE] = {0};
+
+    while (1) {
+        ret = wiz_server_op(0, buf, BUFF_SIZE, TCP_PORT, RECV_DATA);
+        if (ret > 0) {
+        wiz_server_op(0, buf, BUFF_SIZE, TCP_PORT, SEND_DATA);
+        };
+    }
+
+    return ;
+    
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestSocketAsServer, a w5500 server test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+
+#elif defined ETHERNET_AS_CLIENT
+
+static uint32_t wiz_client_op(uint8_t sn, uint8_t *buf, uint32_t buf_size,
+                       uint8_t dst_ip[4], uint16_t dst_port,
+                       enum TCP_OPTION opt) {
+  // assert(buf_size <= g_wiznet_buf_size);
+  int32_t ret;
+  switch (getSn_SR(sn)) {
+    case SOCK_CLOSE_WAIT:
+      wiz_sock_disconnect(sn);
+      break;
+    case SOCK_CLOSED:
+      wiz_socket(sn, Sn_MR_TCP, 5000, 0x00);
+      break;
+    case SOCK_INIT:
+      KPrintf("[SOCKET CLIENT] sock init.\n");
+      wiz_sock_connect(sn, dst_ip, dst_port);
+      break;
+    case SOCK_ESTABLISHED:
+      if (getSn_IR(sn) & Sn_IR_CON) {
+        printf("[SOCKET CLIENT] %d:Connected\r\n", sn);
+        setSn_IR(sn, Sn_IR_CON);
+      }
+      if (opt == SEND_DATA) {
+        uint32_t sent_size = 0;
+        ret = wiz_sock_send(sn, buf, buf_size);
+        if (ret < 0) {
+          wiz_sock_close(sn);
+          return ret;
+        }
+      } else if (opt == RECV_DATA) {
+        uint32_t size = 0;
+        if ((size = getSn_RX_RSR(sn)) > 0) {
+          if (size > buf_size) size = buf_size;
+          ret = wiz_sock_recv(sn, buf, size);
+          if (ret <= 0) return ret;
+        }
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+
+void TestSocketAsClient(int argc, char *argv[])
+{
+    x_err_t ret;
+    uint8_t buf[BUFF_SIZE] = {0};
+    uint32_t tmp_ip[4];
+    uint32_t port;
+    const uint8_t client_sock = 2;
+
+    if(argc<3){
+      printf("Please enter command like TestSocketAsClient ip:port msg\n");
+    }
+
+    sscanf(argv[1],"%d.%d.%d.%d:%d",tmp_ip,tmp_ip+1,tmp_ip+2,tmp_ip+3,&port);
+    printf("Client to %d.%d.%d.%d:%d\n",tmp_ip[0],tmp_ip[1],tmp_ip[2],tmp_ip[3],port);
+    uint8_t destination_ip[4]={0};
+    for(int i=0;i<4;i++){
+      destination_ip[i]=tmp_ip[i];
+    }
+    
+    while(1){
+      ret = wiz_client_op(client_sock, argv[2], strlen(argv[2]), destination_ip, port,SEND_DATA);
+      printf("sizeof:%d\n",strlen(argv[2]));
+      PrivTaskDelay(1000); 
+      if (ret > 0) {
+        ret=wiz_client_op(client_sock, buf, BUFF_SIZE, destination_ip, port, RECV_DATA);
+        printf("read ret is %d\n",ret);
+        if(ret>0){
+          printf("client recv msg successfully!\n");
+          printf("%s\n",buf);            
+        }
+      };
+      PrivTaskDelay(1000);      
+    }
+
+
+    
+
+    return ;
+    
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestSocketAsClient, a w5500 client-ip-port-msg test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+
+
+#endif
+
+
+#endif

APP_Framework/Applications/app_test/test_flash.c

@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_flash.c
+* @brief:   a application of flash function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+void TestFlash(void)
+{
+    int fd = open(FLASH_DEV_DRIVER,O_RDWR);
+    if(fd<0){
+        printf("fs fd open error:%d\n",fd);
+        return;
+    }
+    struct BusBlockWriteParam flash_writer;
+    uint8_t read_buff[8] = {1,2,3,4,5,6,7,8};
+    flash_writer.pos = 0x000000L;
+    flash_writer.size = 8;
+    flash_writer.buffer = read_buff;
+    struct BusBlockReadParam flash_reader;
+    flash_reader.pos = 0x000000L;
+    flash_reader.size = 8;
+    flash_reader.buffer = read_buff;    
+
+    PrivRead(fd,&flash_reader,NONE);
+    printf("Read data is:");
+    for(int i=0;i<flash_writer.size;i++){
+        printf("%02x ",read_buff[i]);
+        read_buff[i]++;
+    }
+    printf("\n");
+
+    PrivWrite(fd,&flash_writer,NONE);
+
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestFlash, a flash test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_fs.c

@@ -0,0 +1,83 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_fs.c
+* @brief:   a application of file_system function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/11/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define MAX_READ_LENGTH 1000
+
+// sd card here is loaded as "/"
+void TestFs(void)
+{
+    //open the file in sdcard
+    int fd = open(FPATH,O_RDWR|O_CREAT);
+    if(fd<0){
+        printf("fs fd open error:%d\n",fd);
+        return;
+    }
+
+    char filewords[MAX_READ_LENGTH];
+    memset(filewords,0,MAX_READ_LENGTH);
+    const char *input_words = "these words are going to write in fs\n";
+
+    //read and write then close file
+    int err_flag = read(fd,filewords,MAX_READ_LENGTH);
+    if(err_flag<0){
+        printf("read failed,error:%d\n",err_flag);
+        return;
+    }
+    printf("read data is \n%s\n",filewords);
+    
+    err_flag = write(fd,input_words,strlen(input_words));
+    if(err_flag<0){
+        printf("write failed,error:%d\n",err_flag);
+        return;
+    }
+    err_flag = close(fd);
+    if(err_flag<0){
+        printf("close failed,error %d\n",err_flag);
+        return ;
+    }
+
+    //re-open the file and re-read the file
+    fd = open(FPATH,O_RDWR);
+     if(fd<0){
+        printf("fs fd open error:%d\n",fd);
+        return;
+    }   
+    err_flag = read(fd,filewords,MAX_READ_LENGTH);
+    if(err_flag<0){
+        printf("read failed,error:%d\n",err_flag);
+        return;
+    }    
+
+    printf("read data is \n%s\n",filewords);
+    err_flag = close(fd);
+    if(err_flag<0){
+        printf("close failed,error:%d\n",err_flag);
+        return;
+    }        
+
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestFs, a sd or usb filesystem test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_gpio.c

@@ -0,0 +1,98 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_gpio.c
+* @brief:   a application of GPIO function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#ifdef BOARD_EDU_RISCV64_EVB
+#define BSP_LED_PIN 29
+#define BSP_KEY_PIN 31
+#elif defined BOARD_HC32F4A0_EVB
+#define BSP_LED_PIN 134
+#define BSP_KEY_PIN 176
+#endif
+#define NULL_PARAMETER 0
+
+void  TestGpio(void)
+{
+    int pin_fd = PrivOpen(GPIO_DEV_DRIVER, O_RDWR);
+    if(pin_fd < 0) {
+        printf("open pin fd error:%d\n",pin_fd);
+        return;
+    }
+
+    //config led pin in board
+     struct PinParam parameter;
+     parameter.cmd = GPIO_CONFIG_MODE;
+     parameter.pin = BSP_LED_PIN;
+     parameter.mode = GPIO_CFG_OUTPUT;
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = PIN_TYPE;
+    ioctl_cfg.args =  (void *)&parameter;
+
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg)) {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }
+
+    //config key pin in board
+    parameter.pin = BSP_KEY_PIN;   
+    parameter.mode = GPIO_CFG_INPUT;
+
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg)) {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    } 
+
+    struct PinStat pin_led;
+    struct PinStat pin_key;
+
+    pin_led.pin = BSP_LED_PIN;
+    pin_key.pin = BSP_KEY_PIN;
+    
+    //recycle read pin and write pin until key break
+    while(1){
+        if(0 > PrivRead(pin_fd, &pin_key, NULL_PARAMETER)) {
+            printf("read pin fd error %d\n", pin_fd);
+            PrivClose(pin_fd);
+            return;
+        }
+
+        //led on if key pressed,or led off
+        if(pin_key.val){
+            pin_led.val = GPIO_HIGH;
+        }else{
+            pin_led.val = GPIO_LOW;
+        }            
+        
+        if(0 > PrivWrite(pin_fd, &pin_led, NULL_PARAMETER)) {
+            printf("write pin fd error %d\n", pin_fd);
+            PrivClose(pin_fd);
+            return;
+        }           
+    }
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestGpio, a gpio test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_hash/README.md

@@ -0,0 +1,58 @@
+# 基于cortex-m3-emulator实现哈希表并测试验证##
+
+## 1. 简介
+利用c语言实现了哈希表（HashMap），包括添加键值对(Put)，获取键对应的值(Get), 删除健（Delete），清空哈希表(Clear)， 迭代遍历哈希表(hashMapIterator)等功能
+操作。
+
+利用数组（Entry）作为存储空间，利用链表(*next)解决冲突。当哈希表的大小超过数组大小后，为避免发生冲突过多的情况，可以对哈希表扩容。
+
+## 2. 数据结构设计说明
+键值对结构
+typedef struct entry {
+    void * key;             // 键
+    void * value;           // 值
+    struct entry * next;    // 冲突链表
+}*Entry;
+
+哈希结构
+typedef struct hashMap {
+    int size;           // 当前大小
+    int listSize;       // 有效空间大小
+    HashCode hashCode;  // 哈希函数
+    Equal equal;        // 判等函数
+    Entry list;         // 存储区域
+    Put put;            // 添加键的函数
+    Get get;            // 获取键对应值的函数
+    Remove remove;      // 删除键
+    Clear clear;        // 清空Map
+    Exists exists;      // 判断键是否存在
+    Boolean autoAssign;	// 设定是否根据当前数据量动态调整内存大小，默认开启
+}*HashMap;
+
+包括以下函数功能，分别为：
+`createHashMap`：创建一个哈希结构
+`defaultPut`：添加键值对
+`defaultGet`：获取键对应值
+`defaultRemove`：删除指定键的键值对
+`defaultExists`：判断键值是否存在
+`defaultClear`：清空Map的函数类型
+`resetHashMap`：重新构建哈希表
+
+
+## 3. 测试程序说明
+测试了哈希表的插入键值对(Put)，判断键是否存在(Exist)，获取键对应的值(Get)， 删除健（Delete），迭代遍历哈希表(hashMapIterator)，清空哈希表(Clear)等操作。
+并展示了利用链地址法解决哈希冲突的示例, 两个不同的人(Bob和Li Ming)的hashcode相同。
+
+## 4. 运行结果（##需结合运行测试截图按步骤说明##）
+![image](ConfigOpen.png)
+打开menuconfig之后，将test_hash_map开启(y)，保存后退出
+
+![image](CompileSuccess.png)
+编译XiZi-cortex-m3-emulator.elf成功
+
+![image](ShellCommand.png)
+启动qemu模拟Xiuos操作系统，验证TestHash注册Shell命令
+
+![image](TestHash.png)
+执行TestHash命令，打印测试结果。
+

APP_Framework/Applications/app_test/test_hash/test_hash.c

@@ -0,0 +1,323 @@
+
+/**
+* @file:    test_hash.c
+* @brief:   a application of test hash function
+* @version: 3.0
+* @author:  Yao wenying
+* @date:    2023/05/26
+*/
+
+#include <transform.h>
+#include"test_hash.h"
+
+int defaultHashCode(HashMap hashMap, let key) {
+	char * k = (char *)key;
+	unsigned long h = 0;
+	while (*k) {
+		h = (h << 4) + *k++;
+		unsigned long g = h & 0xF0000000L;
+		if (g) {
+			h ^= g >> 24;
+		}
+		h &= ~g;
+	}
+	return h % hashMap->listSize;
+}
+
+Boolean defaultEqual(let key1, let key2) {
+	return strcmp((string)key1, (string)key2) ? False : True;
+}
+
+void resetHashMap(HashMap hashMap, int listSize) {
+
+	if (listSize < 8) return;
+
+	// 键值对临时存储空间
+	Entry tempList = newEntryList(hashMap->size);
+
+	HashMapIterator iterator = createHashMapIterator(hashMap);
+	int length = hashMap->size;
+	for (int index = 0; hasNextHashMapIterator(iterator); index++) {
+		// 迭代取出所有键值对
+		iterator = nextHashMapIterator(iterator);
+		tempList[index].key = iterator->entry->key;
+		tempList[index].value = iterator->entry->value;
+		tempList[index].next = NULL;
+	}
+	freeHashMapIterator(&iterator);
+
+	// 清除原有键值对数据
+	hashMap->size = 0;
+	for (int i = 0; i < hashMap->listSize; i++) {
+		Entry current = &hashMap->list[i];
+		current->key = NULL;
+		current->value = NULL;
+		if (current->next != NULL) {
+			while (current->next != NULL) {
+				Entry temp = current->next->next;
+				free(current->next);
+				current->next = temp;
+			}
+		}
+	}
+
+	// 更改内存大小
+	hashMap->listSize = listSize;
+	Entry relist = (Entry)realloc(hashMap->list, hashMap->listSize * sizeof(struct entry));
+	if (relist != NULL) {
+		hashMap->list = relist;
+		relist = NULL;
+	}
+
+	// 初始化数据
+	for (int i = 0; i < hashMap->listSize; i++) {
+		hashMap->list[i].key = NULL;
+		hashMap->list[i].value = NULL;
+		hashMap->list[i].next = NULL;
+	}
+
+	// 将所有键值对重新写入内存
+	for (int i = 0; i < length; i++) {
+		hashMap->put(hashMap, tempList[i].key, tempList[i].value);
+	}
+	free(tempList);
+}
+
+void defaultPut(HashMap hashMap, let key, let value) {
+	// 获取哈希值
+	int index = hashMap->hashCode(hashMap, key);
+
+	if (hashMap->list[index].key == NULL) {
+		hashMap->size++;
+		// 该地址为空时直接存储
+		hashMap->list[index].key = key;
+		hashMap->list[index].value = value;
+	}
+	else {
+
+		Entry current = &hashMap->list[index];
+		while (current != NULL) {
+			if (hashMap->equal(key, current->key)) {
+				// 对于键值已经存在的直接覆盖
+				current->value = value;
+				return;
+			}
+			current = current->next;
+		};
+
+		// 发生冲突则创建节点挂到相应位置的next上
+		Entry entry = newEntry();
+		entry->key = key;
+		entry->value = value;
+		entry->next = hashMap->list[index].next;
+		hashMap->list[index].next = entry;
+		hashMap->size++;
+	}
+
+	if (hashMap->autoAssign && hashMap->size >= hashMap->listSize) {
+
+		// 内存扩充至原来的两倍
+		// *注: 扩充时考虑的是当前存储元素数量与存储空间的大小关系，而不是存储空间是否已经存满，
+		// 例如: 存储空间为10，存入了10个键值对，但是全部冲突了，所以存储空间空着9个，其余的全部挂在一个上面，
+		// 这样检索的时候和遍历查询没有什么区别了，可以简单这样理解，当我存入第11个键值对的时候一定会发生冲突，
+		// 这是由哈希函数本身的特性(取模)决定的，冲突就会导致检索变慢，所以这时候扩充存储空间，对原有键值对进行
+		// 再次散列，会把冲突的数据再次分散开，加快索引定位速度。
+		resetHashMap(hashMap, hashMap->listSize * 2);
+	}
+}
+
+let defaultGet(HashMap hashMap, let key) {
+	if (hashMap->exists(hashMap, key)) {
+		int index = hashMap->hashCode(hashMap, key);
+		Entry entry = &hashMap->list[index];
+		while (entry != NULL) {
+			if (hashMap->equal(entry->key, key)) {
+				return entry->value;
+			}
+			entry = entry->next;
+		}
+	}
+	return NULL;
+}
+
+let defaultRemove(HashMap hashMap, let key) {
+	int index = hashMap->hashCode(hashMap, key);
+	Entry entry = &hashMap->list[index];
+	if (entry->key == NULL) {
+		return NULL;
+	}
+    let entryKey = entry->key;
+	Boolean result = False;
+	if (hashMap->equal(entry->key, key)) {
+		hashMap->size--;
+		if (entry->next != NULL) {
+			Entry temp = entry->next;
+			entry->key = temp->key;
+			entry->value = temp->value;
+			entry->next = temp->next;
+			free(temp);
+		}
+        else {
+            entry->key = NULL;
+            entry->value = NULL;
+        }
+		result = True;
+	}
+	else {
+		Entry p = entry;
+		entry = entry->next;
+		while (entry != NULL) {
+			if (hashMap->equal(entry->key, key)) {
+				hashMap->size--;
+				p->next = entry->next;
+				free(entry);
+				result = True;
+				break;
+			}
+			p = entry;
+			entry = entry->next;
+		};
+	}
+
+	// 如果空间占用不足一半，则释放多余内存
+	if (result && hashMap->autoAssign &&  hashMap->size < hashMap->listSize / 2) {
+		resetHashMap(hashMap, hashMap->listSize / 2);
+	}
+	return entryKey;
+}
+
+Boolean defaultExists(HashMap hashMap, let key) {
+	int index = hashMap->hashCode(hashMap, key);
+	Entry entry = &hashMap->list[index];
+	if (entry->key == NULL) {
+		return False;
+	}
+	else {
+		while (entry != NULL) {
+			if (hashMap->equal(entry->key, key)) {
+				return True;
+			}
+			entry = entry->next;
+		}
+		return False;
+	}
+}
+
+void defaultClear(HashMap hashMap) {
+	for (int i = 0; i < hashMap->listSize; i++) {
+		// 释放冲突值内存
+		Entry entry = hashMap->list[i].next;
+		while (entry != NULL) {
+			Entry next = entry->next;
+			free(entry);
+			entry = next;
+		}
+		hashMap->list[i].next = NULL;
+	}
+	// 释放存储空间
+	free(hashMap->list);
+	hashMap->list = NULL;
+	hashMap->size = -1;
+	hashMap->listSize = 0;
+}
+
+HashMap createHashMap(HashCode hashCode, Equal equal) {
+	HashMap hashMap = newHashMap();
+	if (hashMap == NULL) {
+		return NULL;
+	}
+	hashMap->size = 0;
+	hashMap->listSize = 8;
+	hashMap->hashCode = hashCode == NULL ? defaultHashCode : hashCode;
+	hashMap->equal = equal == NULL ? defaultEqual : equal;
+	hashMap->exists = defaultExists;
+	hashMap->get = defaultGet;
+	hashMap->put = defaultPut;
+	hashMap->remove = defaultRemove;
+	hashMap->clear = defaultClear;
+	hashMap->autoAssign = True;
+	
+	// 起始分配8个内存空间，溢出时会自动扩充
+	hashMap->list = newEntryList(hashMap->listSize);
+	if (hashMap->list == NULL) {
+		return NULL;
+	}
+	Entry p = hashMap->list;
+	for (int i = 0; i < hashMap->listSize; i++) {
+		p[i].key = p[i].value = p[i].next = NULL;
+	}
+	return hashMap;
+}
+
+HashMapIterator createHashMapIterator(HashMap hashMap) {
+	HashMapIterator iterator = newHashMapIterator();
+	if (iterator == NULL) {
+		return NULL;
+	}
+	iterator->hashMap = hashMap;
+	iterator->count = 0;
+	iterator->hashCode = -1;
+	iterator->entry = NULL;
+	return iterator;
+}
+
+Boolean hasNextHashMapIterator(HashMapIterator iterator) {
+	return iterator->count < iterator->hashMap->size ? True : False;
+}
+
+HashMapIterator nextHashMapIterator(HashMapIterator iterator) {
+	if (hasNextHashMapIterator(iterator)) {
+		if (iterator->entry != NULL && iterator->entry->next != NULL) {
+			iterator->count++;
+			iterator->entry = iterator->entry->next;
+			return iterator;
+		}
+		while (++iterator->hashCode < iterator->hashMap->listSize) {
+			Entry entry = &iterator->hashMap->list[iterator->hashCode];
+			if (entry->key != NULL) {
+				iterator->count++;
+				iterator->entry = entry;
+				break;
+			}
+		}
+	}
+	return iterator;
+}
+
+void freeHashMapIterator(HashMapIterator * iterator) {
+	free(*iterator);
+	*iterator = NULL;
+}
+
+#define Put(map, key, value) map->put(map, (void *)key, (void *)value);
+#define Get(map, key) (char *)map->get(map, (void *)key)
+#define Remove(map, key) map->remove(map, (void *)key)
+#define Existe(map, key) map->exists(map, (void *)key)
+
+void TestHash() {
+    HashMap map = createHashMap(NULL, NULL);
+    Put(map, "000123", "Annie");
+    Put(map, "000245", "Bob");
+    Put(map, "000284", "Daniel");
+    Put(map, "000281", "Luna");
+    Put(map, "000587", "Yao");
+    Put(map, "000985", "Li Ming");
+    Put(map, "000852", "Janne");
+
+    printf("print the key-values in hashmap:\n");
+    HashMapIterator iterator = createHashMapIterator(map);
+    while (hasNextHashMapIterator(iterator)) {
+        iterator = nextHashMapIterator(iterator);
+        printf("{ key: %s, key: %s, hashcode: %d }\n",
+            (char *)iterator->entry->key, (char *)iterator->entry->value, iterator->hashCode);
+    }
+    printf("key: 000852, exists: %s\n", Existe(map, "000852") ? "true" : "false");
+    printf("000852: %s\n", Get(map, "000852"));
+    printf("remove 000852 %s\n", Remove(map, "000852") ? "true" : "false");
+    printf("key: 000852, exists: %s\n", Existe(map, "000852") ? "true" : "false");
+
+    map->clear(map);
+    freeHashMapIterator(&iterator);
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestHash, Implement hash_map, PRIV_SHELL_CMD_MAIN_ATTR);

APP_Framework/Applications/app_test/test_hash/test_hash.h

@@ -0,0 +1,129 @@
+
+/**
+* @file:    test_hash.h
+* @brief:   a application of test hash function
+* @version: 3.0
+* @author:  Yao wenying
+* @date:    2023/05/26
+*/
+
+
+#ifndef __HASHMAP_H__
+#define __HASHMAP_H__
+
+#include<stdlib.h>
+#include<string.h>
+#include<stdio.h>
+
+
+// 实现数据的基本类型
+// 字符串类型
+#define string char *
+#define newString(str) strcpy((char *)malloc(strlen(str) + 1), str)
+#define NEW(type) (type *)malloc(sizeof(type))
+
+// 布尔类型
+enum _Boolean { True = 1, False = 0 };
+typedef enum _Boolean  Boolean;
+
+#define let void *
+
+typedef struct entry {
+	let key;				// 键
+	let value;				// 值
+	struct entry * next;	// 冲突链表
+}*Entry;
+
+#define newEntry() NEW(struct entry)
+#define newEntryList(length) (Entry)malloc(length * sizeof(struct entry))
+
+// 哈希结构
+typedef struct hashMap *HashMap;
+
+#define newHashMap() NEW(struct hashMap)
+
+// 哈希函数类型
+typedef int(*HashCode)(HashMap, let key);
+
+// 判等函数类型
+typedef Boolean(*Equal)(let key1, let key2);
+
+// 添加键函数类型
+typedef void(*Put)(HashMap hashMap, let key, let value);
+
+// 获取键对应值的函数类型
+typedef let(*Get)(HashMap hashMap, let key);
+
+// 删除键的函数类型
+typedef let(*Remove)(HashMap hashMap, let key);
+
+// 清空Map的函数类型
+typedef void(*Clear)(HashMap hashMap);
+
+// 判断键值是否存在的函数类型
+typedef Boolean(*Exists)(HashMap hashMap, let key);
+
+typedef struct hashMap {
+	int size;			// 当前大小
+	int listSize;		// 有效空间大小
+	HashCode hashCode;	// 哈希函数
+	Equal equal;		// 判等函数
+	Entry list;			// 存储区域
+	Put put;			// 添加键的函数
+	Get get;			// 获取键对应值的函数
+	Remove remove;		// 删除键
+	Clear clear;		// 清空Map
+	Exists exists;		// 判断键是否存在
+	Boolean autoAssign;	// 设定是否根据当前数据量动态调整内存大小，默认开启
+}*HashMap;
+
+// 迭代器结构
+typedef struct hashMapIterator {
+	Entry entry;	// 迭代器当前指向
+	int count;		// 迭代次数
+	int hashCode;	// 键值对的哈希值
+	HashMap hashMap;
+}*HashMapIterator;
+
+#define newHashMapIterator() NEW(struct hashMapIterator)
+
+// 默认哈希函数
+static int defaultHashCode(HashMap hashMap, let key);
+
+// 默认判断键值是否相等
+static Boolean defaultEqual(let key1, let key2);
+
+// 默认添加键值对
+static void defaultPut(HashMap hashMap, let key, let value);
+
+// 默认获取键对应值
+static let defaultGet(HashMap hashMap, let key);
+
+// 默认删除键
+static let defaultRemove(HashMap hashMap, let key);
+
+// 默认判断键是否存在
+static Boolean defaultExists(HashMap hashMap, let key);
+
+// 默认清空Map
+static void defaultClear(HashMap hashMap);
+
+// 重新构建
+static void resetHashMap(HashMap hashMap, int listSize);
+
+// 创建一个哈希结构
+HashMap createHashMap(HashCode hashCode, Equal equal);
+
+// 创建哈希结构迭代器
+HashMapIterator createHashMapIterator(HashMap hashMap);
+
+// 迭代器是否有下一个
+Boolean hasNextHashMapIterator(HashMapIterator iterator);
+
+// 迭代到下一次
+HashMapIterator nextHashMapIterator(HashMapIterator iterator);
+
+// 释放迭代器内存
+void freeHashMapIterator(HashMapIterator * iterator);
+
+#endif // !__HASHMAP_H__

APP_Framework/Applications/app_test/test_hwtimer.c

@@ -0,0 +1,97 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_hwtimer.c
+* @brief:   a application of hwtimer function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define BSP_LED_PIN 134
+#define NULL_PARAMETER 0
+
+static uint16_t pin_fd=0;
+static struct PinStat pin_led;
+
+void ledflip(void *parameter)
+{
+    pin_led.pin = BSP_LED_PIN;
+    pin_led.val = !pin_led.val;
+    PrivWrite(pin_fd,&pin_led,NULL_PARAMETER);
+}
+
+void TestHwTimer(void)
+{
+    x_ticks_t period = 100000;
+    
+    pin_fd = PrivOpen(HWTIMER_PIN_DEV_DRIVER, O_RDWR);
+    if(pin_fd<0){
+        printf("open pin fd error:%d\n",pin_fd);
+        return;
+    }
+
+    int timer_fd = PrivOpen(HWTIMER_TIMER_DEV_DRIVER, O_RDWR);
+    if(timer_fd<0){
+        printf("open timer fd error:%d\n",timer_fd);
+        return;
+    }
+
+    //config led pin in board
+     struct PinParam parameter;
+     parameter.cmd = GPIO_CONFIG_MODE;
+     parameter.pin = BSP_LED_PIN;
+     parameter.mode = GPIO_CFG_OUTPUT;
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = PIN_TYPE;
+    ioctl_cfg.args =  (void *)&parameter;
+
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg)) {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }
+
+    ioctl_cfg.ioctl_driver_type = TIME_TYPE;
+    ioctl_cfg.args = (void *)&ledflip;
+    if (0 != PrivIoctl(timer_fd, OPE_INT, &ioctl_cfg)) {
+        printf("timer pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }    
+
+    ioctl_cfg.args = (void *)&period;
+    if (0 != PrivIoctl(timer_fd, OPE_CFG, &ioctl_cfg)) {
+        printf("timer pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }    
+
+    while(1){
+        
+    }
+
+    // int32 timer_handle = KCreateTimer("LED on and off by 1s",&ledflip,&pin_fd,period,TIMER_TRIGGER_PERIODIC);
+    
+    // KTimerStartRun(timer_handle);
+    PrivClose(pin_fd);
+    PrivClose(timer_fd);
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestHwTimer, a timer test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_i2c.c

@@ -0,0 +1,71 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_i2c.c
+* @brief:   a application of i2c function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define I2C_SLAVE_ADDRESS 0x0012U
+
+void TestI2C(void)
+{
+    // config IIC pin(SCL:34.SDA:35) in menuconfig
+    int iic_fd = PrivOpen(I2C_DEV_DRIVER, O_RDWR);
+    if (iic_fd < 0)
+    {
+        printf("open iic_fd fd error:%d\n", iic_fd);
+        return;
+    }
+    printf("IIC open successful!\n");
+
+    // init iic
+    uint16 iic_address = I2C_SLAVE_ADDRESS;
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = I2C_TYPE;
+    ioctl_cfg.args = (void *)&iic_address;
+
+    if (0 != PrivIoctl(iic_fd, OPE_INT, &ioctl_cfg))
+    {
+        printf("ioctl iic fd error %d\n", iic_fd);
+        PrivClose(iic_fd);
+        return;
+    }
+    printf("IIC configure successful!\n");
+
+    // I2C read and write
+    char tmp_buff[100];
+    while (1)
+    {
+        PrivTaskDelay(1000);
+        PrivWrite(iic_fd, "Hello World!\n", sizeof("Hello World!\n"));
+        printf("msg send:%s\n", "Hello World!\n");
+        PrivTaskDelay(1000);
+        memset(tmp_buff, 0, sizeof(tmp_buff));
+        PrivRead(iic_fd, tmp_buff, sizeof(tmp_buff));
+        printf("msg recv:%s\n", tmp_buff);
+    }
+
+    PrivClose(iic_fd);
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestI2C, a iic test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_lcd.c

@@ -1,68 +1,63 @@
-/****************************************************************************
- * apps/examples/fb/fb_main.c
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.  The
- * ASF licenses this file to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the
- * License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
- * License for the specific language governing permissions and limitations
- * under the License.
- *
- ****************************************************************************/
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
 
-/****************************************************************************
- * Included Files
- ****************************************************************************/
+/**
+* @file:    test_lcd.c
+* @brief:   a application of dac function
+* @version: 2.0
+* @author:  AIIT XUOS Lab
+* @date:    2022/1/11
+*/
 
 #include <transform.h>
 
-#ifdef ADD_NUTTX_FETURES
+#ifdef ADD_NUTTX_FEATURES
 
 #ifdef CONFIG_K210_LCD
 void LcdDemo(void)
 {
-    int x1 = 50, y1 = 50, x2 = LCD_XSIZE_TFT - 50, y2 = LCD_YSIZE_TFT - 50;
+    int lcd_fd = PrivOpen("/dev/lcd_dev",O_RDWR);
+    LcdWriteParam disp_info;
 
-    Main_Image_Start_Address(LCD_START_ADDR);
-    Main_Image_Width(LCD_XSIZE_TFT);
-    Main_Window_Start_XY(0, 0);
-    Canvas_Image_Start_address(LCD_START_ADDR);
-    Canvas_image_width(LCD_XSIZE_TFT);
-    Active_Window_XY(0, 0);
-    Active_Window_WH(LCD_XSIZE_TFT, LCD_YSIZE_TFT);
-    up_mdelay(10);
-    Canvas_Image_Start_address(LCD_START_ADDR);
+    disp_info.type = 0;
+    disp_info.string_info.x_pos = 80;
+    disp_info.string_info.y_pos = 80;
+    disp_info.string_info.width = 250;
+    disp_info.string_info.height = 24;
+    disp_info.string_info.font_size = 24;
+    disp_info.string_info.addr = "wecome test lcd";
+    disp_info.string_info.font_color = GREEN;
+    disp_info.string_info.back_color = BLUE;
+    PrivWrite(lcd_fd, &disp_info, sizeof(LcdWriteParam));
+    PrivTaskDelay(2000);
 
-    for(int i = 0; i < 3; i++)
-    {
-        x1 = 50;
-        y1 = 50;
-        x2 = LCD_XSIZE_TFT - 50;
-        y2 = LCD_YSIZE_TFT - 50;
-        syslog(LOG_NOTICE, "Disp_demo %d (%d,%d - %d,%d)\n", i, x1, y1, x2, y2);
-        LT768_DrawSquare_Fill(x1, y1, x2, y2, Red);
-        up_mdelay(2000);
-        x1 += 20;
-        y1 += 20;
-        x2 -= 20;
-        y2 -= 20;
-        LT768_DrawSquare_Fill(x1, y1, x2, y2, Green);
-        up_mdelay(2000);
-        x1 += 20;
-        y1 += 20;
-        x2 -= 20;
-        y2 -= 20;
-        LT768_DrawSquare_Fill(x1, y1, x2, y2, Blue);
-        up_mdelay(2000);
-    }
+    disp_info.type = 1;
+    lv_color_t redcolor = {
+        .ch = {
+            .red   = 0b11111,
+            .green = 0,
+            .blue  = 0
+        }
+    };
+    disp_info.pixel_info.x_startpos =  0;
+    disp_info.pixel_info.x_endpos =  50;
+    disp_info.pixel_info.y_startpos = 0;
+    disp_info.pixel_info.y_endpos = 50;
+    disp_info.pixel_info.pixel_color = &redcolor;
+    PrivWrite(lcd_fd, &disp_info, sizeof(LcdWriteParam));
+    PrivTaskDelay(2000);
+    
+    disp_info.type = SHOW_TRIANGLE;
+    PrivWrite(lcd_fd, &disp_info, sizeof(LcdWriteParam));
 }
 
 #else

APP_Framework/Applications/app_test/test_lcd_edu.c

@@ -0,0 +1,89 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_lcd.c
+* @brief:   a application of lcd function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define GRAPHIC_CTRL_RECT_UPDATE 0x00
+#define LCD_STRING_TYPE 0
+#define LCD_DOT_TYPE 1
+#define LCD_FONT_RECT_WIDTH 150
+#define LCD_FONT_RECT_HEIGHT 50
+#define NULL_PARAMETER 0
+
+void TestLcd(void)
+{
+    int lcd_fd = PrivOpen(EDU_LCD_DEV_DRIVER, O_RDWR);
+    if (lcd_fd < 0)
+    {
+        printf("open lcd fd error:%d\n", lcd_fd);
+        return;
+    }
+
+    LcdWriteParam graph_param;
+
+    // black
+    uint16* color_select = malloc(sizeof(uint16) * 321 * 321);
+    memset(color_select, 0x00, sizeof(uint16) * 321 * 321);
+    graph_param.type = LCD_DOT_TYPE;
+    graph_param.pixel_info.x_startpos = 0;
+    graph_param.pixel_info.y_startpos = 0;
+    graph_param.pixel_info.x_endpos = 320;
+    graph_param.pixel_info.y_endpos = 320;
+    graph_param.pixel_info.pixel_color = color_select;
+    PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+    free(color_select);
+
+    // draw text
+    graph_param.type = LCD_STRING_TYPE;
+    graph_param.string_info.x_pos = 0;
+    graph_param.string_info.y_pos = 0;
+    graph_param.string_info.width = 250;
+    graph_param.string_info.height = 24;
+    graph_param.string_info.font_size = 24;
+    graph_param.string_info.back_color = 0xFFFF;
+    graph_param.string_info.font_color = 0x0000;
+    graph_param.string_info.addr = "hello_world!";
+    PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+
+    // draw line
+    color_select = malloc(sizeof(uint16) * 1 * 320);
+    for (int i = 0; i < 320; i++)
+    {
+        color_select[i] = 0xF800;
+    }
+    for (int i = 1; i <= 5; i++)
+    {
+        graph_param.type = LCD_DOT_TYPE;
+        graph_param.pixel_info.x_startpos = 0;
+        graph_param.pixel_info.y_startpos = i * 50;
+        graph_param.pixel_info.x_endpos = 319;
+        graph_param.pixel_info.y_endpos = i * 50;
+        graph_param.pixel_info.pixel_color = color_select;
+        PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+    }
+    free(color_select);
+
+    PrivClose(lcd_fd);
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestLcd, a lcd test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_loraE220.c

@@ -0,0 +1,168 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_loraE220.c
+* @brief:   a application of loraE220 function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define NULL_PARAMETER 0
+#define E220_CFG_LENGTH
+#define GPIOSET(fd, buf, bit)                        \
+    {                                                \
+        buf.val = bit;                               \
+        if (0 > PrivWrite(fd, &buf, NULL_PARAMETER)) \
+        {                                            \
+            printf("write pin fd error %d\n", fd);   \
+            PrivClose(fd);                           \
+            return;                                  \
+        }                                            \
+    }
+#define BSP_E220_M0_PIN 32
+#define BSP_E220_M1_PIN 33
+
+void TestLora(int argc, char *argv[])
+{
+    char uart_recvbuff[100];
+    memset(uart_recvbuff, 0, sizeof(uart_recvbuff));
+
+    int pin_fd = PrivOpen(LORA_PIN_DEV_DRIVER, O_RDWR);
+    if (pin_fd < 0)
+    {
+        printf("open pin fd error:%d\n", pin_fd);
+        return;
+    }
+
+    int uart_fd = PrivOpen(LORA_UART_DEV_DRIVER, O_RDWR);
+    if (uart_fd < 0)
+    {
+        printf("open pin fd error:%d\n", uart_fd);
+        return;
+    }
+    printf("uart and pin fopen success\n");
+
+    struct PinStat pin_m0;
+    struct PinStat pin_m1;
+    pin_m0.pin = BSP_E220_M0_PIN;
+    pin_m1.pin = BSP_E220_M1_PIN;
+
+    // config led pin in board
+    struct PrivIoctlCfg ioctl_cfg;
+    struct PinParam pin_param;
+    pin_param.cmd = GPIO_CONFIG_MODE;
+    pin_param.mode = GPIO_CFG_OUTPUT;
+    pin_param.pin = BSP_E220_M0_PIN;
+    ioctl_cfg.ioctl_driver_type = PIN_TYPE;
+    ioctl_cfg.args = &pin_param;
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg))
+    {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }
+
+    pin_param.pin = BSP_E220_M1_PIN;
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg))
+    {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }
+
+    printf("pin configure success\n");
+    struct SerialDataCfg uart_cfg;
+
+    // loraE220 support only 9600bps with 8N1 during initializing
+    uart_cfg.serial_baud_rate = BAUD_RATE_9600;
+    uart_cfg.serial_data_bits = DATA_BITS_8;
+    uart_cfg.serial_stop_bits = STOP_BITS_1;
+    uart_cfg.serial_parity_mode = PARITY_NONE;
+    uart_cfg.serial_bit_order = BIT_ORDER_LSB;
+    uart_cfg.serial_invert_mode = NRZ_NORMAL;
+    uart_cfg.serial_buffer_size = SERIAL_RB_BUFSZ;
+    uart_cfg.serial_timeout = 1000;
+    uart_cfg.is_ext_uart = 0;
+
+    ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
+    ioctl_cfg.args = (void *)&uart_cfg;
+
+    if (0 != PrivIoctl(uart_fd, OPE_INT, &ioctl_cfg))
+    {
+        printf("ioctl uart fd error %d\n", uart_fd);
+        PrivClose(uart_fd);
+        return;
+    }
+    printf("uart configure success\n");
+
+    GPIOSET(pin_fd, pin_m0, GPIO_HIGH);
+    GPIOSET(pin_fd, pin_m1, GPIO_HIGH);
+    printf("lora configure into sleep(configure) mode\n");
+
+    // send configure data, and receive the same length of data
+    // configure loraE220 as address 1949 CH17 36.8kps
+    char sendbuff[] = {0xC0, 0x00, 0x05, 0x19, 0x49, 0xE6, 0x00, 0x17}; 
+
+    PrivTaskDelay(2000);
+
+    printf("Sending lora configure information(SIZE:%d)\n", sizeof(sendbuff));
+    PrivWrite(uart_fd, sendbuff, sizeof(sendbuff));
+    printf("lora configure information send\n");
+
+    PrivTaskDelay(2000);
+
+    PrivRead(uart_fd, uart_recvbuff, sizeof(sendbuff));
+    printf("%x %x %x %x", uart_recvbuff[0], uart_recvbuff[1], uart_recvbuff[2], uart_recvbuff[3]);
+    printf("lora configure success\n");
+
+    // error when all bytes are 0xff
+    if (0xFF == (uart_recvbuff[0] & uart_recvbuff[1] & uart_recvbuff[2]))
+    {
+        printf("from lora receive error:%d\n", 0xff);
+        return;
+    }
+
+    uart_cfg.serial_baud_rate = BAUD_RATE_115200;
+    if (0 != PrivIoctl(uart_fd, OPE_INT, &ioctl_cfg))
+    {
+        printf("ioctl uart fd error %d\n", uart_fd);
+        PrivClose(uart_fd);
+        return;
+    }
+
+    // into transparent transmission mode
+    GPIOSET(pin_fd, pin_m0, GPIO_LOW);
+    GPIOSET(pin_fd, pin_m1, GPIO_LOW);
+    // receive and send "Hello World"
+    while (1)
+    {
+        PrivTaskDelay(500);
+        PrivWrite(uart_fd, "Hello_World!", sizeof("Hello_World!"));
+        printf("Data Send:\n%s\n", "Hello_World!");
+
+        PrivTaskDelay(500);
+        memset(uart_recvbuff, 0, sizeof(uart_recvbuff));
+        PrivRead(uart_fd, uart_recvbuff, sizeof(uart_recvbuff));
+        printf("Receive Data is :\n%s\n", uart_recvbuff);
+    }
+    PrivClose(pin_fd);
+    PrivClose(uart_fd);
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestLora, a lora test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_musl.c

@@ -0,0 +1,103 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_musl.c
+* @brief:   a application of musl test function
+* @version: 2.0
+* @author:  AIIT XUOS Lab
+* @date:    2022/11/8
+*/
+
+#include <transform.h>
+
+#ifdef ADD_NUTTX_FEATURES
+
+#if defined(CONFIG_MUSL_LIBC) && defined(CONFIG_FS_AUTOMOUNTER)
+
+static void file_read_and_write(void)
+{
+    FILE *p;
+    char s[] = "good luck to you!";
+    char buffer[20];
+
+    if((p = fopen("/mnt/sdcard/test.txt","w+")) == NULL)
+    {
+      printf("Can not open file!\n");
+    }
+    fwrite(s, sizeof(s) + 1, 1, p);
+    fseek(p, SEEK_SET, 0);
+    fread(buffer, sizeof(buffer) + 1, 1, p);
+    printf("read string is: %s\n", buffer);
+    fclose(p);
+}
+
+static void file_operations(void)
+{
+   int ret;
+   FILE *fp;
+   char filename1[] = "/mnt/sdcard/file1.txt";
+   char filename2[] = "/mnt/sdcard/file2.txt";
+
+   fp = fopen(filename1, "w");
+
+   fprintf(fp, "%s", "this is runoob.com");
+   fclose(fp);
+   
+   ret = remove(filename1);
+
+   if(ret == 0) 
+   {
+      printf("remove file1 success!\n");
+   }
+   else 
+   {
+      printf("error,can not remove file1!\n");
+   }
+
+   ret = remove(filename2);
+   if(ret == 0) 
+   {
+      printf("remove file2 success!\n");
+   }
+   else 
+   {
+      printf("error,can not remove file2!\n");
+   }
+}
+
+static void malloc_and_free(void)
+{
+  int *p;
+  int len;
+  for(int i = 0; i < 100; i++)
+  {
+    len = 1024*(i+1);
+    p = malloc(len);
+    if(p)
+    {
+      printf("malloc %d bytes success!\n",len);
+      free(p);
+    }
+  }
+}
+void Testmusl(void)
+{
+  printf("--------start test file read and write!--------\n");
+  file_read_and_write();
+  printf("----------start test file operationsn!---------\n");
+  file_operations();
+  printf("---------start test malloc and free!-----------\n");
+  malloc_and_free();
+}
+#endif
+#endif

APP_Framework/Applications/app_test/test_radix_tree/README.md

@@ -0,0 +1,67 @@
+# 基于k210-emulator实现基数树并测试验证
+
+## 1. 简介
+
+基于矽璓模拟器k210-emulator，实现基数树，并编写测试程序在shell终端打印结果。
+
+## 2. 数据结构设计说明
+
+基数树节点设计为：
+
+```c
+typedef struct _node {
+​    void* value;
+​    struct _node* next[NODE_SIZE];
+} node;
+```
+
+其中，节点在树中的路径即为键，`value` 存储值，`NODE_SIZE` 定义为 128，足以容纳所有 ASCII 值。
+
+一共实现了 5 个函数，分别为：
+
+- `CreateNode`：创建一个基数树节点
+- `InsertNode`：将一对键值对插入基数树
+- `DeleteNode`：删除指定键的键值对
+- `FindNode`：查找指定键对应的值
+- `DestroyTree`：销毁整个基数树
+
+## 3. 测试程序说明
+
+测试程序 `TestRadix` 已经注册为 shell 命令，可以调用执行。
+
+测试程序定义了以下键值对：
+
+```c
+char keys[][MAX_WORD_LEN] = {
+    "what",
+    "where",
+    "why",
+    "how",
+    "hello!",
+    "apple",
+    "12345"
+};
+int values[] = {1, 2, 3, 4, 5, 6, 7};
+```
+
+1. 程序的第一部分创建了基数树，并且将定义的 7 个键值对的前 6 个插入了基数树，然后分别查找 7 个键，前 6 个均可以找到对应的值，最后一个未插入，因此无法找到
+2. 程序的第二部分从基数树中删除了 `where` 和 `how` 两个键，再次分别查找 7 个键，删除的键值对和未插入的键值对均无法找到
+3. 程序的第三部分重新插入了已删除的 `where` 和未插入过的 `12345` ，再次分别查找 7 个键，新插入的值可以检索到
+4. 程序的第四部分将基数树销毁，再次分别查找 7 个键，所有的键值对均无法找到
+
+## 4. 运行结果（##需结合运行测试截图按步骤说明##）
+
+1. 在工作区终端中输入命令：`make BOARD=k210-emulator menuconfig`，进入配置页面
+![fig1](fig1.png)
+2. 依次进入 `APP_Framework` -> `Applications` -> `test app` 目录，将 `Enable application test function` 选项置为 `Y`
+![fig2](fig2.png)
+3. 进入 `Enable application test function` 将 `Config test radix tree` 选项置为 `Y`
+![fig3](fig3.png)
+4. 一直选择 `Exit` 退出配置，在最后需要确认的页面选择 `Yes` 保存配置
+![fig4](fig4.png)
+5. 执行编译命令：`make BOARD=k210-emulator`，正常情况下应当编译无误
+![fig5](fig5.png)
+6. 在 `qemu` 中运行：`qemu-system-riscv64 -nographic -machine sifive_u -bios build/XiZi-k210-emulator.elf`
+![fig6](fig6.png)
+7. 在 shell 中运行命令 `TestRadix`，执行结果与预期一致，验证完成。
+![fig7](fig7.png)

APP_Framework/Applications/app_test/test_radix_tree/test_radix_tree.c

@@ -0,0 +1,187 @@
+/**
+* @file:    test_radix_tree.c
+* @brief:   Implement a simple radix tree
+* @version: 1.0
+* @date:    2023/5/24
+*/
+
+#include <transform.h>
+#include "test_radix_tree.h"
+
+/**
+ * @description: Create a radix tree node
+ * @return node pointer
+ */
+node* CreateNode()
+{
+    node* n = (node*)malloc(sizeof(node));
+    n->value = NULL;
+    for (int i = 0; i < NODE_SIZE; i++) {
+        n->next[i] = NULL;
+    }
+    return n;
+}
+
+/**
+ * @description: Insert a new node to radix tree
+ * @param root - radix tree root
+ * @param key - new node key
+ * @param value - new node value
+ * @return void
+ */
+void InsertNode(node* root, const char* key, void* value)
+{
+    if (root == NULL) {
+        return;
+    }
+    node* cur = root;
+    size_t len = strlen(key);
+    for (size_t i = 0; i < len; i++) {
+        uint8_t b = (uint8_t)key[i];
+        if (cur->next[b] == NULL) {
+            cur->next[b] = CreateNode();
+        }
+        cur = cur->next[b];
+    }
+    cur->value = value;
+}
+
+/**
+ * @description: Delete a node from radix tree
+ * @param root - radix tree root
+ * @param key - key which is needed to delete
+ * @return void
+ */
+void DeleteNode(node* root, const char* key)
+{
+    if (root == NULL) {
+        return;
+    }
+    node** cur = &root;
+    size_t len = strlen(key);
+    for (size_t i = 0; i < len; i++) {
+        uint8_t b = (uint8_t)key[i];
+        if ((*cur)->next[b] == NULL) {
+            return;
+        }
+        cur = &((*cur)->next[b]);
+    }
+
+    if ((*cur)->value == NULL) {
+        return;
+    }
+
+    (*cur)->value = NULL;
+
+    int has_children = 0;
+    for (int i = 0; i < NODE_SIZE; i++) {
+        if ((*cur)->next[i] != NULL) {
+            has_children = 1;
+            break;
+        }
+    }
+    if (!has_children) {
+        free(*cur);
+        (*cur) = NULL;
+    }
+}
+
+/**
+ * @description: find a node by key
+ * @param root - radix tree root
+ * @param key - key which is needed to find
+ * @return value pointer corresponding to key
+ */
+void* FindNode(node* root, const char* key)
+{
+    if (root == NULL) {
+        return NULL;
+    }
+    node* cur = root;
+    size_t len = strlen(key);
+    for (size_t i = 0; i < len; i++) {
+        uint8_t b = (uint8_t)key[i];
+        if (cur->next[b] == NULL) {
+            return NULL;
+        }
+        cur = cur->next[b];
+    }
+    return cur->value;
+}
+
+/**
+ * @description: Destroy the radix tree
+ * @param root - radix tree root
+ * @return void
+ */
+void DestroyTree(node* root)
+{
+    if (root == NULL) {
+        return;
+    }
+    for (int i = 0; i < NODE_SIZE; i++) {
+        DestroyTree(root->next[i]);
+    }
+    free(root);
+}
+
+void TestRadix()
+{
+    char keys[][MAX_WORD_LEN] = {
+        "what",
+        "where",
+        "why",
+        "how",
+        "hello!",
+        "apple",
+        "12345"
+    };
+    int values[] = {1, 2, 3, 4, 5, 6, 7};
+
+    printf("\nCreate tree and add key & value:\n");
+    node* root = CreateNode();
+    if (!root) printf("Create node failed.\n");
+
+    int num = sizeof(keys) / sizeof(keys[0]);
+    for (int i = 0; i < num - 1; ++i) {
+        InsertNode(root, keys[i], &values[i]);
+    }
+
+    for (int i = 0; i < num; ++i) {
+        int* v = (int*)FindNode(root, keys[i]);
+        if (v) printf("keys[%d] \"%s\"'v = %d, values[%d] = %d\n", i, keys[i], *v, i, values[i]);
+        else printf("keys[%d] \"%s\" not found\n", i, keys[i]);
+    }
+
+    printf("\nDelete \"where\" and \"how\":\n");
+    DeleteNode(root, keys[1]);
+    DeleteNode(root, keys[3]);
+    
+    for (int i = 0; i < num; ++i) {
+        int* v = (int*)FindNode(root, keys[i]);
+        if (v) printf("keys[%d] \"%s\"'v = %d, values[%d] = %d\n", i, keys[i], *v, i, values[i]);
+        else printf("keys[%d] \"%s\" not found\n", i, keys[i]);
+    }
+
+    printf("\nInsert \"where\" and \"12345\":\n");
+    InsertNode(root, keys[1], &values[1]);
+    InsertNode(root, keys[6], &values[6]);
+
+    for (int i = 0; i < num; ++i) {
+        int* v = (int*)FindNode(root, keys[i]);
+        if (v) printf("keys[%d] \"%s\"'v = %d, values[%d] = %d\n", i, keys[i], *v, i, values[i]);
+        else printf("keys[%d] \"%s\" not found\n", i, keys[i]);
+    }
+
+    printf("\nDestroy tree:\n");
+    DestroyTree(root);
+    root = NULL;
+
+    for (int i = 0; i < num; ++i) {
+        int* v = (int*)FindNode(root, keys[i]);
+        if (v) printf("keys[%d] \"%s\"'v = %d, values[%d] = %d\n", i, keys[i], *v, i, values[i]);
+        else printf("keys[%d] \"%s\" not found\n", i, keys[i]);
+    }
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestRadix, Implement a simple radix tree, PRIV_SHELL_CMD_MAIN_ATTR);

APP_Framework/Applications/app_test/test_radix_tree/test_radix_tree.h

@@ -0,0 +1,20 @@
+/**
+* @file:    test_radix_tree.h
+* @brief:   Implement a simple radix tree
+* @version: 1.0
+* @date:    2023/5/24
+*/
+
+#define NODE_SIZE 128
+#define MAX_WORD_LEN 128
+
+typedef struct _node {
+    void* value;
+    struct _node* next[NODE_SIZE];
+} node;
+
+node* CreateNode();
+void InsertNode(node* root, const char* key, void* value);
+void DeleteNode(node* root, const char* key);
+void* FindNode(node* root, const char* key);
+void DestroyTree(node* root);

APP_Framework/Applications/app_test/test_rbtree/README.md

@@ -0,0 +1,69 @@
+# 基于cortex-m4-emulator实现红黑树并测试验证
+
+## 1. 简介
+红黑树是一种自平衡的二叉查找树，具有良好的插入、删除和查找性能，本次提交结果为红黑树数据结构的简单实现。test_rbtree.h中定义了红黑树的数据结构和声明插入、删除、查找相关操作函数;test_rbtree.c中为操作函数的定义，并提供了测试函数TestRBTree用于验证红黑树的正确性。
+
+
+## 2. 数据结构设计说明
+
+**RBNodeType 结构体**
+用来存储一个红黑树结点的相关信息
+- key：节点的键值
+- left_child：指向左子节点的指针
+- right_child：指向右子节点的指针
+- parent：指向父节点的指针
+- is_red：表示节点的颜色，true表示红色，false表示黑色
+
+**RBTreeType 结构体**
+用来存储一个红黑树的相关信息
+- root：指向红黑树的根节点的指针
+- leaf：红黑树的叶节点，由于叶节点并不需要存储数据，故每棵树只分配一个叶节点
+
+
+**RBTreeTraversal 函数**
+该函数用于遍历红黑树并打印节点的键值。采用中序遍历的方式，递归地遍历左子树、当前节点和右子树。
+
+**RBTreeLeftRotate 函数**
+该函数实现红黑树的左旋转操作。接受一个当前节点指针作为参数，并按照左旋转的规则调整节点和子树的位置。
+
+**RBTreeRightRotate 函数**
+该函数实现红黑树的右旋转操作。接受一个当前节点指针作为参数，并按照右旋转的规则调整节点和子树的位置。
+
+**InsertFixup 函数**
+该函数用于插入节点后修复红黑树的平衡性。接受一个当前节点指针作为参数，并根据红黑树的性质进行旋转和着色操作，以恢复平衡。
+
+**RBTreeInsert 函数**
+该函数用于向红黑树中插入一个新节点。接受一个新节点指针作为参数，并根据新节点的键值插入到适当的位置，然后调用 InsertFixup 进行修复。
+
+**DeleteFixup 函数**
+该函数用于删除节点后修复红黑树的平衡性。接受一个当前节点指针作为参数，并根据红黑树的性质进行旋转和着色操作，以恢复平衡。
+
+**RBTreeDelete 函数**
+该函数用于从红黑树中删除指定节点。接受一个目标节点指针作为参数，并根据不同的情况进行节点的替换和删除操作，然后调用 DeleteFixup 进行修复。
+
+**FindSuccessor 函数**
+该函数用于查找给定节点的后继节点。接受一个当前节点指针作为参数，并在红黑树中找到当前节点的后继节点。
+
+**RBTreeSearch 函数**
+该函数用于在红黑树中查找指定键值的节点。接受一个键值作为参数，并在红黑树中进行查找，返回找到的节点指针。
+
+## 3. 测试程序说明
+TestRBTree用于验证红黑树的功能和正确性,下面是该程序的使用步骤和说明:
+- 函数中定义一个默认关键字数组，其中包含了20个整数关键字，运行时自动遍历数组构建红黑树，构建完成后中序遍历输出结果，可以根据输出结果验证红黑树的节点顺序以及颜色是否符合预期。
+- 对关键字数组中的每个关键字，在红黑树中进行搜索，并输出找到节点的父节点、左子节点和右子节点的关键字，随后删除该节点。
+- 在每次删除操作后，程序会询问是否显示当前的红黑树。如果输入 "Y" 或 "y"，将再次进行中序遍历，并输出当前红黑树中的结点，可以根据输出结果查看结点是否符合预期。当树空时结束程序。
+
+
+## 4. 运行结果（##需结合运行测试截图按步骤说明##）
+
+根据默认关键字数组构建红黑树
+
+![Alt text](image.png)
+
+根据键值查找结点，输出相关信息并删除，可以输入'Y'或'y'展示删除后的红黑树
+
+![Alt text](image-1.png)
+
+到达空树，退出程序
+
+![Alt text](image-2.png)

APP_Framework/Applications/app_test/test_rbtree/test_rbtree.c

@@ -0,0 +1,341 @@
+/*
+* Copyright (c) 2023 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_rbtree.c
+* @brief:   a application of red-black tree function
+* @version: 1.0
+* @author:  AIIT XUOS Lab
+* @date:    2023/6/23
+*/
+#include<string.h>
+#include <transform.h>
+#include"test_rbtree.h"
+#ifdef ADD_XIZI_FETURES
+
+void RBTreeTraversal(RBTreeType *tree, RBNodeType *node) 
+{
+	if (node != tree->leaf) {
+		RBTreeTraversal(tree, node->left_child);
+		printf("key:%d, color:%s\n", node->key, (node->is_red ? "Red" : "Black"));
+		RBTreeTraversal(tree, node->right_child);
+	}
+}
+
+RBNodeType* RBTreeSearch(RBTreeType *tree, int key)
+{
+    RBNodeType* current_node = tree->root;
+    while (current_node != tree->leaf){
+        if (key < current_node->key)
+            current_node = current_node->left_child;
+        else if (key > current_node->key)
+            current_node = current_node->right_child;
+        else
+            return current_node;
+    }
+
+    return tree->leaf;
+}
+
+void RBTreeLeftRotate(RBTreeType *tree, RBNodeType *current_node)
+{
+    RBNodeType* child_node = current_node->right_child;
+
+    current_node->right_child = child_node->left_child;
+    if (child_node->left_child != tree->leaf)
+        child_node->left_child->parent = current_node;
+
+    child_node->parent = current_node->parent;
+    if (current_node->parent == tree->leaf)
+        tree->root = child_node;
+    else if (current_node == current_node->parent->left_child)
+        current_node->parent->left_child = child_node;
+    else
+        current_node->parent->right_child = child_node;
+    
+    child_node->left_child = current_node;
+    current_node->parent = child_node;
+}
+
+void RBTreeRightRotate(RBTreeType *tree, RBNodeType* current_node)
+{
+    RBNodeType* child_node = current_node->left_child;
+
+    current_node->left_child = child_node->right_child;
+    if (child_node->right_child != tree->leaf)
+        child_node->right_child->parent = current_node;
+
+    child_node->parent = current_node->parent;
+    if (current_node->parent == tree->leaf)
+        tree->root = child_node;
+    else if (current_node == current_node->parent->right_child)
+        current_node->parent->right_child = child_node;
+    else
+        current_node->parent->left_child = child_node;
+    
+    child_node->right_child = current_node;
+    current_node->parent = child_node;
+}
+
+void InsertFixup(RBTreeType *tree, RBNodeType* current_node)
+{
+    while (current_node->parent->is_red){
+        /* The parent of current_node is the left subtree of the grandfather */
+        if (current_node->parent == current_node->parent->parent->left_child){
+            RBNodeType * uncle_node = current_node->parent->parent->right_child;
+            if (uncle_node->is_red){    /* case1:red uncle and red parent, change color */
+                uncle_node->is_red = false;
+                current_node->parent->is_red = false;
+                current_node->parent->parent->is_red = true;
+
+                current_node = current_node->parent->parent;
+            }else{                      /* case2:black uncle and red parent, need rotation */
+                if (current_node->parent->right_child == current_node){
+                    current_node = current_node->parent;
+                    RBTreeLeftRotate(tree, current_node);
+                }
+
+                current_node->parent->is_red = false;
+                current_node->parent->parent->is_red = true;
+                RBTreeRightRotate(tree, current_node->parent->parent);
+            }
+        /* The parent of current_node is the right subtree of the grandfather, same with left subtree */
+        }else{
+            RBNodeType * uncle_node = current_node->parent->parent->left_child;
+            if (uncle_node->is_red){
+                uncle_node->is_red = false;
+                current_node->parent->is_red = false;
+                current_node->parent->parent->is_red = true;
+
+                current_node = current_node->parent->parent;
+            }else{
+                if (current_node->parent->left_child == current_node){
+                    current_node = current_node->parent;
+                    RBTreeRightRotate(tree, current_node);
+                }
+
+                current_node->parent->is_red = false;
+                current_node->parent->parent->is_red = true;
+                RBTreeLeftRotate(tree, current_node->parent->parent);
+            }
+        }
+    }
+    tree->root->is_red = false;
+}
+
+void RBTreeInsert(RBTreeType *tree, RBNodeType* new_node)
+{
+    RBNodeType* previous_node = tree->root;
+    RBNodeType* current_node = tree->root;
+
+    while (current_node != tree->leaf){
+        previous_node = current_node;
+        if (new_node->key > current_node->key)
+            current_node = current_node->right_child;
+        else if (new_node->key < current_node->key)
+            current_node = current_node->left_child;
+        else
+            return;
+    }
+
+    if (previous_node == tree->leaf){
+        tree->root = new_node;
+        tree->root->parent = tree->leaf;
+    }else{
+        new_node->parent = previous_node;
+
+        if (previous_node->key > new_node->key)
+            previous_node->left_child = new_node;
+        else
+            previous_node->right_child = new_node;
+    }
+
+    InsertFixup(tree, new_node);
+}
+
+RBNodeType* FindSuccessor(RBTreeType *tree, RBNodeType* current_node)
+{
+    RBNodeType* parent_node = current_node->parent;
+    if (current_node->right_child != tree->leaf){
+        current_node = current_node->right_child;
+        while (current_node->left_child != tree->leaf)
+            current_node = current_node->left_child;
+        return current_node;
+    }
+
+    while ((parent_node != tree->leaf) && (current_node == parent_node->right_child)){
+        current_node = parent_node;
+        parent_node = parent_node->parent;
+    }
+    return parent_node;
+}
+
+void DeleteFixup(RBTreeType *tree, RBNodeType* current_node)
+{
+    while ((current_node != tree->root) && (current_node->is_red == false)){
+        if (current_node == current_node->parent->left_child){
+            
+            RBNodeType* brother_node = current_node->parent->right_child;
+            if (brother_node->is_red){
+                brother_node->is_red = false;
+                current_node->parent->is_red = true;
+                RBTreeLeftRotate(tree, current_node->parent);
+                brother_node = current_node->parent->right_child;
+            }
+
+            if ((brother_node->left_child->is_red == false) && (brother_node->right_child->is_red == false)){
+                brother_node->is_red = true;
+                current_node = current_node->parent;
+            }else{
+                if (brother_node->right_child->is_red == false){
+                    brother_node->left_child->is_red = false;
+                    brother_node->is_red = true;
+                    RBTreeRightRotate(tree, brother_node);
+                    brother_node = current_node->parent->right_child;
+                }
+
+                brother_node->is_red = current_node->parent->is_red;
+                current_node->parent->is_red = false;
+                brother_node->right_child->is_red = false;
+                RBTreeLeftRotate(tree, current_node->parent);
+                current_node = tree->root;
+            }
+        }else{
+            RBNodeType* brother_node = current_node->parent->left_child;
+            if (brother_node->is_red){
+                brother_node->is_red = false;
+                current_node->parent->is_red = true;
+                RBTreeRightRotate(tree, current_node->parent);
+                brother_node = current_node->parent->left_child;
+            }
+
+            if ((brother_node->left_child->is_red == false) && (brother_node->right_child->is_red == false)){
+                brother_node->is_red = true;
+                current_node = current_node->parent;
+            }else{
+                if (brother_node->left_child->is_red == false){
+                    brother_node->right_child->is_red = false;
+                    brother_node->is_red = true;
+                    RBTreeLeftRotate(tree, brother_node);
+                    brother_node = current_node->parent->left_child;
+                }
+
+                brother_node->is_red = current_node->parent->is_red;
+                current_node->parent->is_red = false;
+                brother_node->left_child->is_red = false;
+                RBTreeRightRotate(tree, current_node->parent);
+                current_node = tree->root;
+            }
+        }
+    }
+    current_node->is_red = false;
+}
+
+void RBTreeDelete(RBTreeType *tree, RBNodeType* target_node)
+{
+    RBNodeType* delete_node = tree->leaf;
+    RBNodeType* replace_node = tree->leaf;
+
+    if ((target_node->left_child == tree->leaf) || (target_node->right_child == tree->leaf))
+        delete_node = target_node;
+    else
+        delete_node = FindSuccessor(tree, target_node);
+    
+    if (delete_node->left_child != tree->leaf) /* successor still has subtree */
+        replace_node = delete_node->left_child;
+    else if (delete_node->right_child != tree->leaf)
+        replace_node = delete_node->right_child;
+    
+    replace_node->parent = delete_node->parent;
+
+    if (delete_node->parent == tree->leaf) /* delete a root node */
+        tree->root = replace_node;
+    else if (delete_node == delete_node->parent->left_child)
+        delete_node->parent->left_child = replace_node;
+    else
+        delete_node->parent->right_child = replace_node;
+
+    if (delete_node != target_node)
+        target_node->key = delete_node->key;
+    
+    if (delete_node->is_red == false)
+        DeleteFixup(tree, replace_node);
+
+    free(delete_node);
+}
+
+
+void TestRBTree(void)
+{
+    int default_key[] = { 16, 25, 23, 5, 2, 6, 17, 37, 38, 98, 20, 19, 47, 49, 12, 21, 9, 18, 14, 15 };
+    int array_size = sizeof(default_key) / sizeof(default_key[0]);
+    
+    printf("Test Red Black Tree\n");
+    printf("default_key array: ");
+    for (int i = 0; i < array_size; i++)
+        printf("%d  ", default_key[i]);
+    printf("\n%d elements\n", array_size);
+
+	RBTreeType *tree = (RBTreeType *)malloc(sizeof(RBTreeType));
+	if (tree == NULL) {
+		printf("malloc failed\n");
+        return;
+	}
+
+	tree->leaf = (RBNodeType*)malloc(sizeof(RBNodeType));
+    tree->leaf->left_child = NULL;
+    tree->leaf->right_child = NULL;
+    tree->leaf->parent = NULL;
+    tree->leaf->is_red = false;
+    tree->leaf->key = -1;
+	tree->root = tree->leaf;
+
+	RBNodeType *node = tree->leaf;
+
+	for (int i = 0; i < array_size; i++) {
+		node = (RBNodeType*)malloc(sizeof(RBNodeType));
+        node->left_child = tree->leaf;
+        node->right_child = tree->leaf;
+        node->parent = NULL;
+        node->is_red = true;
+        node->key = default_key[i];
+		printf("insert key[%d]=%d\n",i,default_key[i]);
+		RBTreeInsert(tree, node);
+	}
+
+	printf("------------------Inorder Traversal------------------\n");
+	RBTreeTraversal(tree, tree->root);
+
+	for (int i = 0; i < array_size; i++) {
+		printf("search key = %d\n", default_key[i]);
+		node = RBTreeSearch(tree, default_key[i]);
+        printf("search succeeded, parent node: %d, left-child: %d, right-child: %d\n", node->parent->key, node->left_child->key, node->right_child->key);
+
+    	printf("delete key = %d\n", node->key);
+        RBTreeDelete(tree, node);
+		
+		printf("Show current tree?Y/N \n");
+        char ch;
+        scanf("%c", &ch);
+         if (ch == 'Y' || ch == 'y') {
+            printf("------------------Inorder Traversal Tree After Deletion------------------\n");
+            if (tree->root != tree->leaf)
+	            RBTreeTraversal(tree, tree->root);
+            else
+                printf("the tree is empty.\n");
+        }
+	}
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestRBTree, a red-black tree test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+
+#endif

APP_Framework/Applications/app_test/test_rbtree/test_rbtree.h

@@ -0,0 +1,60 @@
+/*
+* Copyright (c) 2023 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_rbtree.h
+* @brief:   a head file of red-black tree structure
+* @version: 1.0
+* @author:  AIIT XUOS Lab
+* @date:    2023/6/23
+*/
+#ifndef REDBLACKTREE_H_
+#define REDBLACKTREE_H_
+#include <stdbool.h>
+#include <stdio.h>
+
+typedef struct RedBlackNode
+{
+    int key;
+    struct RedBlackNode *left_child;
+    struct RedBlackNode *right_child;
+    struct RedBlackNode *parent;
+    bool is_red;
+} RBNodeType;
+
+typedef struct RedBlackTree
+{
+    RBNodeType *root;
+    RBNodeType *leaf;
+} RBTreeType;
+
+void TestRBTree(void);
+
+void RBTreeTraversal(RBTreeType *tree, RBNodeType *node);
+
+void RBTreeLeftRotate(RBTreeType *tree, RBNodeType *current_node);
+
+void RBTreeRightRotate(RBTreeType *tree, RBNodeType* current_node);
+
+void InsertFixup(RBTreeType *tree, RBNodeType* current_node);
+
+void RBTreeInsert(RBTreeType *tree, RBNodeType* new_node);
+
+void DeleteFixup(RBTreeType *tree, RBNodeType* current_node);
+
+void RBTreeDelete(RBTreeType *tree, RBNodeType* target_node);
+
+RBNodeType* FindSuccessor(RBTreeType *tree, RBNodeType* current_node);
+
+RBNodeType* RBTreeSearch(RBTreeType *tree, int key);
+
+#endif

APP_Framework/Applications/app_test/test_rs485.c

@@ -0,0 +1,107 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_rs485.c
+* @brief:   a application of rs485 function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+#define BSP_485_DIR_PIN 24
+
+void Test485(void)
+{
+    int pin_fd = PrivOpen(RS485_PIN_DEV_DRIVER, O_RDWR);
+    if (pin_fd < 0)
+    {
+        printf("open pin fd error:%d\n", pin_fd);
+        return;
+    }
+
+    int uart_fd = PrivOpen(RS485_UART_DEV_DRIVER, O_RDWR);
+    if (uart_fd < 0)
+    {
+        printf("open pin fd error:%d\n", uart_fd);
+        return;
+    }
+    printf("uart and pin fopen success\n");
+
+    //config led pin in board
+    struct PinParam pin_parameter;
+    memset(&pin_parameter, 0, sizeof(struct PinParam));
+    pin_parameter.cmd = GPIO_CONFIG_MODE;
+    pin_parameter.pin = BSP_485_DIR_PIN;
+    pin_parameter.mode = GPIO_CFG_OUTPUT;
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = PIN_TYPE;
+    ioctl_cfg.args =  (void *)&pin_parameter;
+
+    if (0 != PrivIoctl(pin_fd, OPE_CFG, &ioctl_cfg)) {
+        printf("ioctl pin fd error %d\n", pin_fd);
+        PrivClose(pin_fd);
+        return;
+    }
+
+    struct SerialDataCfg uart_cfg;
+    memset(&uart_cfg, 0, sizeof(struct SerialDataCfg));
+
+    uart_cfg.serial_baud_rate = BAUD_RATE_115200;
+    uart_cfg.serial_data_bits = DATA_BITS_8;
+    uart_cfg.serial_stop_bits = STOP_BITS_1;
+    uart_cfg.serial_parity_mode = PARITY_NONE;
+    uart_cfg.serial_bit_order = BIT_ORDER_LSB;
+    uart_cfg.serial_invert_mode = NRZ_NORMAL;
+    uart_cfg.serial_buffer_size = SERIAL_RB_BUFSZ;
+    uart_cfg.serial_timeout = 1000;
+    uart_cfg.is_ext_uart = 0;
+
+    ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
+    ioctl_cfg.args = (void *)&uart_cfg;
+
+    if (0 != PrivIoctl(uart_fd, OPE_INT, &ioctl_cfg))
+    {
+        printf("ioctl uart fd error %d\n", uart_fd);
+        PrivClose(uart_fd);
+        return;
+    }
+
+    struct PinStat pin_dir;
+    pin_dir.pin = BSP_485_DIR_PIN;
+    while (1)
+    {
+        pin_dir.val = GPIO_HIGH;
+        PrivWrite(pin_fd,&pin_dir,0);
+        PrivWrite(uart_fd,"Hello world!\n",sizeof("Hello world!\n"));
+        PrivTaskDelay(100);
+
+        pin_dir.val = GPIO_LOW;
+        PrivWrite(pin_fd,&pin_dir,0);
+        char recv_buff[100];
+        memset(recv_buff,0,sizeof(recv_buff));
+        PrivRead(uart_fd,recv_buff,20);
+        printf("%s",recv_buff);
+        PrivTaskDelay(100);
+    }
+    PrivClose(pin_fd);
+    PrivClose(uart_fd);
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(Test485, a RS485 test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_rtc.c

@@ -0,0 +1,62 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_rtc.c
+* @brief:   a application of rtc function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+void TestRTC(int argc,char *argv[])
+{
+    int rtc_fd = PrivOpen(RTC_DEV_DRIVER, O_RDWR);
+    if(rtc_fd<0){
+        printf("open rtc fd error:%d\n",rtc_fd);
+        return;
+    }
+    
+    if(argc>1){
+        int times = atoi(argv[1]);
+        printf("Time will be printf %d times\n",times);
+
+        struct RtcDrvConfigureParam rtc_para;
+        time_t my_time=0;
+
+        rtc_para.rtc_operation_cmd = OPER_RTC_SET_TIME;
+        rtc_para.time = &my_time;
+
+        struct PrivIoctlCfg ioctl_cfg;
+        ioctl_cfg.ioctl_driver_type = RTC_TYPE;
+        ioctl_cfg.args =  (void *)&rtc_para;
+
+        PrivIoctl(rtc_fd,0,&ioctl_cfg);
+
+        rtc_para.rtc_operation_cmd = OPER_RTC_GET_TIME;
+        for(size_t i=0;i<times;i++){
+            PrivIoctl(rtc_fd,0,&ioctl_cfg);
+            printf("The time now is %d\n",*(rtc_para.time));
+            PrivTaskDelay(5000);  
+        }
+    }
+    
+    PrivClose(rtc_fd);
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestRTC, a rtc test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_timer.c

@@ -0,0 +1,67 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_timer.c
+* @brief:   a application of soft timer function
+* @version: 3.0
+* @author:  AIIT XUOS Lab
+* @date:    2023/03/09
+*/
+
+#include <transform.h>
+
+void TimerFunction(union sigval sig_val)
+{
+    static int cnt = 0;
+    printf("%s cnt %d\n", __func__, cnt++);
+}
+
+void TestTimer(void)
+{
+    int ret = 0;
+    int timer_flags;
+    timer_t timer_id;
+    struct sigevent evp;
+    memset(&evp, 0, sizeof(struct sigevent));
+
+    timer_flags = TIMER_TRIGGER_PERIODIC;
+    
+    evp.sigev_notify = SIGEV_THREAD; 
+    evp.sigev_notify_function = TimerFunction;
+    evp.sigev_notify_attributes = &timer_flags;
+
+    ret = timer_create(CLOCK_REALTIME, &evp, &timer_id);
+    if (ret < 0) {
+        printf("%s create timer failed ret %d\n", __func__, ret);
+        return;
+    }
+
+    struct itimerspec value; 
+    //active time interval
+    value.it_interval.tv_sec = 2; 
+    value.it_interval.tv_nsec = 0;
+
+    //first timer set time 
+    value.it_value.tv_sec = 2; 
+    value.it_value.tv_nsec = 0; 
+
+    ret = timer_settime(timer_id, 1, &value, NULL);
+    if (ret < 0) { 
+        printf("%s set timer time failed ret %d\n", __func__, ret);
+        return;
+    }
+
+    printf("%s success\n", __func__);
+}
+PRIV_SHELL_CMD_FUNCTION(TestTimer, soft timer test, PRIV_SHELL_CMD_MAIN_ATTR);
+

APP_Framework/Applications/app_test/test_touch.c

@@ -0,0 +1,113 @@
+/****************************************************************************
+ * apps/examples/fb/fb_main.c
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.  The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <transform.h>
+
+#ifdef ADD_NUTTX_FEATURES
+
+#ifdef CONFIG_BSP_USING_TOUCH
+void TestTouch(void)
+{
+  int fd;
+	TouchDataParam point = {0, 0, 0};
+	fd = PrivOpen("/dev/touch_dev", O_RDWR);
+	while(1)
+	{
+		PrivRead(fd,&point,1);
+		printf("Now touch point:(%d,%d)\n",point.x,point.y);
+	}
+}
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+
+#define NULL_PARAMETER 0
+#define LCD_DOT_TYPE 1
+#define LCD_SIZE 320
+
+#elif defined ADD_XIZI_FEATURES
+
+void TestTouch(void)
+{
+    int touch_fd = PrivOpen(TOUCH_DEV_DRIVER, O_RDWR);
+    if (touch_fd < 0)
+    {
+        printf("open touch fd error:%d\n", touch_fd);
+        return;
+    }
+    int lcd_fd = PrivOpen(TOUCH_LCD_DEV_DRIVER, O_RDWR);
+    if (lcd_fd < 0)
+    {
+        printf("open lcd fd error:%d\n", lcd_fd);
+        return;
+    }
+
+    // draw text
+    struct TouchDataStandard touch_pixel;
+    memset(&touch_pixel,0,sizeof(touch_pixel));
+    LcdWriteParam graph_param;
+    
+    
+    graph_param.type = LCD_DOT_TYPE;
+
+    uint16_t back_color[LCD_SIZE];
+    memset(back_color,0x00,sizeof(back_color));
+    for (int i = 0; i < LCD_SIZE; i++)
+    {
+        graph_param.pixel_info.pixel_color = &back_color;
+        graph_param.pixel_info.x_startpos = 0;
+        graph_param.pixel_info.y_startpos = i;
+        graph_param.pixel_info.x_endpos = LCD_SIZE -1;
+        graph_param.pixel_info.y_endpos = i;
+        PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+    }
+    
+    uint16 color_select[LCD_SIZE];
+    memset(color_select,0xff,sizeof(color_select));
+    graph_param.pixel_info.pixel_color = &color_select;
+    while(1){
+        if(0 > PrivRead(touch_fd, &touch_pixel, NULL_PARAMETER)){
+            printf("read touch error\n");
+            return;            
+        }
+        printf("touch pixel position x:%d,y:%d\n",touch_pixel.x,touch_pixel.y);
+        graph_param.pixel_info.x_startpos = touch_pixel.x-10>0?touch_pixel.x-10:0;
+        graph_param.pixel_info.y_startpos = touch_pixel.y;
+        graph_param.pixel_info.x_endpos = touch_pixel.x+10;
+        graph_param.pixel_info.y_endpos = touch_pixel.y;
+        PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+        graph_param.pixel_info.x_startpos = touch_pixel.x;
+        graph_param.pixel_info.y_startpos = touch_pixel.y-10>0?touch_pixel.y-10:0;
+        graph_param.pixel_info.x_endpos = touch_pixel.x;
+        graph_param.pixel_info.y_endpos = touch_pixel.y+10;
+        PrivWrite(lcd_fd, &graph_param, NULL_PARAMETER);
+    }
+    PrivClose(lcd_fd);
+    PrivClose(touch_fd);
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestTouch, a touch test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/app_test/test_wdt.c

@@ -0,0 +1,66 @@
+/*
+* Copyright (c) 2020 AIIT XUOS Lab
+* XiUOS is licensed under Mulan PSL v2.
+* You can use this software according to the terms and conditions of the Mulan PSL v2.
+* You may obtain a copy of Mulan PSL v2 at:
+*        http://license.coscl.org.cn/MulanPSL2
+* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+* See the Mulan PSL v2 for more details.
+*/
+
+/**
+* @file:    test_wdt.c
+* @brief:   a application of wdt function
+* @version: 1.1
+* @author:  AIIT XUOS Lab
+* @date:    2022/12/17
+*/
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#ifdef ADD_XIZI_FEATURES
+
+void TestWDT(int argc, char *agrv[])
+{
+    int wdt_fd = PrivOpen(WDT0_DEV_DRIVER, O_RDWR);
+    if (wdt_fd < 0)
+    {
+        printf("open wdt_fd fd error:%d\n", wdt_fd);
+        return;
+    }
+    printf("hw watchdog open!\n");
+
+    // init watchdog
+    int wdt_time = 1000;
+
+    struct PrivIoctlCfg ioctl_cfg;
+    ioctl_cfg.ioctl_driver_type = WDT_TYPE;
+    ioctl_cfg.args = (void *)&wdt_time;
+
+    if (0 != PrivIoctl(wdt_fd, OPER_WDT_SET_TIMEOUT, &ioctl_cfg))
+    {
+        printf("ioctl wdt fd error %d\n", wdt_fd);
+        PrivClose(wdt_fd);
+        return;
+    }
+
+    int test_counter = 100;
+
+    // wdt feed or not according to argc,if argc!=1 then dog won't be feed
+    while (test_counter--)
+    {
+        if (1 == argc)
+        {
+            printf("dog is feed\n");
+            PrivIoctl(wdt_fd, OPER_WDT_KEEPALIVE, &ioctl_cfg); // feed dog
+        }
+        PrivTaskDelay(100);
+    }
+    PrivClose(wdt_fd);
+    return;
+}
+
+PRIV_SHELL_CMD_FUNCTION(TestWDT, a wdt test sample, PRIV_SHELL_CMD_MAIN_ATTR);
+#endif

APP_Framework/Applications/connection_app/4g_app/4g_app.c

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file 4g_app.c
+ * @brief support get data from and send data to 4g server
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.12.12
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#include <adapter.h>
+
+static uint8_t adapter_4g_status = 0;
+static pthread_t recv_4g_heart_task;
+struct Adapter *adapter_4g;
+
+static const uint8_t server_addr[] = "xxx.xxx.xxx.xxx";
+static const uint8_t server_port[] = "xxx";
+
+#define ADAPTER_4G_HEART "HEART"
+
+int Adapter4GConnectFunction(struct Adapter *adapter, uint8_t reconnect)
+{
+    int ret = 0;
+    int baud_rate = BAUD_RATE_115200;
+    
+    if (1 != reconnect) {
+        ret = AdapterDeviceOpen(adapter);
+        if (ret < 0) {
+            goto out;
+        }
+
+        ret = AdapterDeviceControl(adapter, OPE_INT, &baud_rate);
+        if (ret < 0) {
+            goto out;
+        }
+    }
+
+    ret = AdapterDeviceConnect(adapter, CLIENT, server_addr, server_port, IPV4);
+    if (ret < 0) {
+        goto out;
+    }
+
+out:
+    if (ret < 0) {
+        AdapterDeviceClose(adapter);
+    }
+    return ret;
+}
+
+void Adapter4gSend(uint8_t *send_data, size_t length)
+{
+    if (adapter_4g_status) {
+        AdapterDeviceSend(adapter_4g, send_data, length);
+    }
+}
+
+static void *Receive4gHeartTask(void* parameter)
+{
+    char recv_msg[16] = {0};
+    ssize_t recv_length = 0;
+    uint8_t net_status_cnt = 0;
+    
+    while (1) {
+
+        SetTaskStatus(0x01);
+
+        if (net_status_cnt > 5) {
+            adapter_4g_status = 0;
+
+            while (Adapter4GConnectFunction(adapter_4g, 1) < 0) {
+                PrivTaskDelay(10000);
+            }
+
+            net_status_cnt = 0;
+        }
+
+        adapter_4g_status = 1;
+
+        recv_length = AdapterDeviceRecv(adapter_4g, recv_msg, 6);
+        if (recv_length > 0) {
+            //if (0 == strcmp(recv_msg, ADAPTER_4G_HEART)) {
+                net_status_cnt = 0;
+            //}
+        } else {
+            printf("4G recv heart error re-recv cnt %d\n", net_status_cnt);
+            net_status_cnt++;
+        }
+        memset(recv_msg, 0, sizeof(recv_msg));
+    }
+}
+
+int Adapter4GActive(void)
+{
+    int ret = 0;
+    adapter_4g = AdapterDeviceFindByName(ADAPTER_4G_NAME);
+
+#ifdef ADAPTER_EC200T
+    adapter_4g->socket.socket_id = 0;
+
+    ret = Adapter4GConnectFunction(adapter_4g, 0);
+    if (ret < 0) {
+        printf("Adapter4GConnect failed %d\n", ret);
+    }
+
+    adapter_4g_status = 1;
+
+    pthread_attr_t attr;
+    attr.schedparam.sched_priority = 22;
+    attr.stacksize = 2048;
+
+    PrivTaskCreate(&recv_4g_heart_task, &attr, &Receive4gHeartTask, NULL);
+    PrivTaskStartup(&recv_4g_heart_task);
+
+#endif
+
+    return ret;    
+}
+
+

APP_Framework/Applications/connection_app/4g_app/Makefile

@@ -0,0 +1,3 @@
+SRC_FILES := 4g_app.c 
+
+include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/connection_app/Makefile

@@ -1,14 +1,15 @@
-
-ifeq ($(CONFIG_SOCKET_DEMO),y)
-
 include $(KERNEL_ROOT)/.config
 
-ifeq ($(CONFIG_ADD_NUTTX_FETURES),y)
+ifeq ($(CONFIG_ADD_NUTTX_FEATURES),y)
     include $(APPDIR)/Make.defs
     include $(APPDIR)/Application.mk
 endif
 
-ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
+ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
+
+	ifeq ($(CONFIG_CONNECTION_ADAPTER_4G),y)
+		SRC_DIR += 4g_app
+	endif
 
 	ifeq ($(CONFIG_RESOURCES_LWIP),y)
 		SRC_DIR += socket_demo
@@ -17,4 +18,3 @@ ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
     include $(KERNEL_ROOT)/compiler.mk
 endif
 
-endif

APP_Framework/Applications/connection_app/modbus_rtu_app/modbus_rtu_app.c

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file modbus_rtu_app.c
+ * @brief support get data from and send data to Modbus rtu server
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.12.12
+ */
+#include <stdio.h>
+#include <string.h>
+#include <transform.h>
+#include <adapter.h>
+
+#define ADAPTER_RTU_DATA_LENGTH 112
+#define ADAPTER_RTU_TRANSFER_DATA_LENGTH ADAPTER_RTU_DATA_LENGTH + 16
+
+uint8_t client_join_data[ADAPTER_RTU_TRANSFER_DATA_LENGTH];
+
+/* ----------------------- Modbus includes ----------------------------------*/
+#include "mb.h"
+#include "mbport.h"
+
+/* ----------------------- Defines ------------------------------------------*/
+#define REG_INPUT_START 1000
+#define REG_INPUT_NREGS 4
+
+/* ----------------------- Static variables ---------------------------------*/
+static USHORT   usRegInputStart = REG_INPUT_START;
+static USHORT   usRegInputBuf[REG_INPUT_NREGS];
+
+/* ----------------------- Start implementation -----------------------------*/
+
+eMBErrorCode
+eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
+{
+    eMBErrorCode    eStatus = MB_ENOERR;
+    int             iRegIndex;
+
+    if( ( usAddress >= REG_INPUT_START )
+        && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
+    {
+        iRegIndex = ( int )( usAddress - usRegInputStart );
+        while( usNRegs > 0 )
+        {
+            *pucRegBuffer++ =
+                ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
+            *pucRegBuffer++ =
+                ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
+            iRegIndex++;
+            usNRegs--;
+        }
+    }
+    else
+    {
+        eStatus = MB_ENOREG;
+    }
+
+    return eStatus;
+}
+
+eMBErrorCode
+eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
+                 eMBRegisterMode eMode )
+{
+    return MB_ENOREG;
+}
+
+
+eMBErrorCode
+eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
+               eMBRegisterMode eMode )
+{
+    return MB_ENOREG;
+}
+
+eMBErrorCode
+eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
+{
+    return MB_ENOREG;
+}
+
+
+/******************Modbus RTU TEST*********************/
+int AdapterModbusRtuTest(void)
+{
+    const char *send_msg = "Adapter_Modbus_Rtu Test";
+    char recv_msg[256] = {0};
+    int baud_rate = BAUD_RATE_115200;
+
+    struct Adapter* adapter =  AdapterDeviceFindByName(ADAPTER_MODBUS_RTU_NAME);
+
+    struct AdapterData priv_rtu_net;
+    priv_rtu_net.len = ADAPTER_RTU_TRANSFER_DATA_LENGTH;
+    priv_rtu_net.buffer = client_join_data;
+
+
+    AdapterDeviceOpen(adapter);
+    AdapterDeviceControl(adapter, OPE_INT, &baud_rate);
+
+    AdapterDeviceJoin(adapter,(uint8_t *)&priv_rtu_net);
+
+    
+
+    eMBErrorCode    eStatus;
+
+    eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_EVEN );
+
+    /* Enable the Modbus Protocol Stack. */
+    eStatus = eMBEnable(  );
+
+    for( ;; )
+    {
+        ( void )eMBPoll(  );//判断事件的发生，并执行对应的回调函数
+
+        /* Here we simply count the number of poll cycles. */
+        usRegInputBuf[0]++;
+    }
+
+    // while (1) {
+    //     AdapterDeviceSend(adapter, send_msg, strlen(send_msg));
+    //     AdapterDeviceRecv(adapter, recv_msg, 256);
+    //     printf("4G recv msg %s\n", recv_msg);
+    //     memset(recv_msg, 0, 256);
+    // }
+
+
+    return 0;    
+}
+PRIV_SHELL_CMD_FUNCTION(AdapterModbusRtuTest, a Modbus Rtu adpter sample, PRIV_SHELL_CMD_FUNC_ATTR);
+

APP_Framework/Applications/connection_app/socket_demo/Makefile

@@ -1,10 +1,10 @@
-ifeq ($(CONFIG_ADD_XIZI_FETURES),y)
+ifeq ($(CONFIG_ADD_XIZI_FEATURES),y)
 SRC_FILES := lwip_tcp_socket_demo.c lwip_udp_socket_demo.c
 include $(KERNEL_ROOT)/compiler.mk
 endif
 
 include $(KERNEL_ROOT)/.config
-ifeq ($(CONFIG_ADD_NUTTX_FETURES),y)
+ifeq ($(CONFIG_ADD_NUTTX_FEATURES),y)
     include $(APPDIR)/Make.defs
     CSRCS += lwip_tcp_socket_demo.c lwip_udp_socket_demo.c
     include $(APPDIR)/Application.mk

APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c

@@ -20,24 +20,32 @@
 
 #include <transform.h>
 
-#ifdef ADD_XIZI_FETURES
-#include "sys_arch.h"
+#ifdef ADD_XIZI_FEATURES
+#include <sys_arch.h>
 #include <lwip/sockets.h>
 #include "lwip/sys.h"
 #endif
 
-#ifdef ADD_NUTTX_FETURES
+#ifdef ADD_NUTTX_FEATURES
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include "stdio.h"
 #endif
 
-#define TCP_DEMO_BUF_SIZE 65535
+#define TCP_DEMO_BUF_SIZE                    65535
+#define TCP_DEMO_SEND_TIMES                  20
+#define LWIP_TCP_DEMO_TASK_STACK_SIZE        4096
+#define LWIP_TCP_DEMO_TASK_PRIO              20
 
-char tcp_socket_ip[] = {192, 168, 250, 252};
+static pthread_t tcp_client_task;
+static pthread_t tcp_server_task;
 
-#ifdef ADD_NUTTX_FETURES
+static char tcp_demo_ipaddr[] = {192, 168, 131, 77};
+static char tcp_demo_netmask[] = {255, 255, 254, 0};
+static char tcp_demo_gwaddr[] = {192, 168, 131, 1};
+
+#ifdef ADD_NUTTX_FEATURES
 #define lw_print printf
 #define lw_notice printf
 #define lw_error printf
@@ -46,8 +54,8 @@ char tcp_socket_ip[] = {192, 168, 250, 252};
 #define LWIP_TARGET_PORT 4840
 #endif
 
-uint16_t tcp_socket_port = LWIP_TARGET_PORT;
-char tcp_ip_str[128] = {0};
+static uint16_t tcp_socket_port = 8888;
+static char tcp_ip_str[128] = {0};
 
 /******************************************************************************/
 void TcpSocketConfigParam(char *ip_str)
@@ -55,35 +63,23 @@ void TcpSocketConfigParam(char *ip_str)
     int ip1, ip2, ip3, ip4, port = 0;
 
     if(ip_str == NULL)
-    {
         return;
-    }
 
-    if(sscanf(ip_str, "%d.%d.%d.%d:%d", &ip1, &ip2, &ip3, &ip4, &port))
-    {
+    if(sscanf(ip_str, "%d.%d.%d.%d:%d", &ip1, &ip2, &ip3, &ip4, &port)) {
         printf("config ip %s port %d\n", ip_str, port);
         strcpy(tcp_ip_str, ip_str);
-        tcp_socket_ip[0] = ip1;
-        tcp_socket_ip[1] = ip2;
-        tcp_socket_ip[2] = ip3;
-        tcp_socket_ip[3] = ip4;
         if(port)
             tcp_socket_port = port;
         return;
     }
 
-    if(sscanf(ip_str, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4))
-    {
+    if(sscanf(ip_str, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4)) {
         printf("config ip %s\n", ip_str);
-        tcp_socket_ip[0] = ip1;
-        tcp_socket_ip[1] = ip2;
-        tcp_socket_ip[2] = ip3;
-        tcp_socket_ip[3] = ip4;
         strcpy(tcp_ip_str, ip_str);
     }
 }
 
-static void TcpSocketRecvTask(void *arg)
+static void *TcpSocketRecvTask(void *arg)
 {
     int fd = -1, clientfd;
     int recv_len;
@@ -91,18 +87,15 @@ static void TcpSocketRecvTask(void *arg)
     struct sockaddr_in tcp_addr;
     socklen_t addr_len;
 
-    while(1)
-    {
+    while(1) {
         recv_buf = (char *)malloc(TCP_DEMO_BUF_SIZE);
-        if (recv_buf == NULL)
-        {
+        if (recv_buf == NULL) {
             lw_error("No memory\n");
             continue;
         }
 
         fd = socket(AF_INET, SOCK_STREAM, 0);
-        if (fd < 0)
-        {
+        if (fd < 0) {
             lw_error("Socket error\n");
             free(recv_buf);
             continue;
@@ -113,8 +106,7 @@ static void TcpSocketRecvTask(void *arg)
         tcp_addr.sin_port = htons(tcp_socket_port);
         memset(&(tcp_addr.sin_zero), 0, sizeof(tcp_addr.sin_zero));
 
-        if (bind(fd, (struct sockaddr *)&tcp_addr, sizeof(struct sockaddr)) == -1)
-        {
+        if (bind(fd, (struct sockaddr *)&tcp_addr, sizeof(struct sockaddr)) == -1) {
             lw_error("Unable to bind\n");
             close(fd);
             free(recv_buf);
@@ -125,8 +117,7 @@ static void TcpSocketRecvTask(void *arg)
         lw_notice("\nLocal Port:%d\n", tcp_socket_port);
 
         // setup socket fd as listening mode
-        if (listen(fd, 5) != 0 )
-        {
+        if (listen(fd, 5) != 0 ) {
             lw_error("Unable to listen\n");
             close(fd);
             free(recv_buf);
@@ -137,13 +128,11 @@ static void TcpSocketRecvTask(void *arg)
         clientfd = accept(fd, (struct sockaddr *)&tcp_addr, (socklen_t*)&addr_len);
         lw_notice("client %s connected\n", inet_ntoa(tcp_addr.sin_addr));
 
-        while(1)
-        {
+        while(1) {
             memset(recv_buf, 0, TCP_DEMO_BUF_SIZE);
             recv_len = recvfrom(clientfd, recv_buf, TCP_DEMO_BUF_SIZE, 0,
                 (struct sockaddr *)&tcp_addr, &addr_len);
-            if(recv_len > 0)
-            {
+            if(recv_len > 0) {
                 lw_notice("Receive from : %s\n", inet_ntoa(tcp_addr.sin_addr));
                 lw_notice("Receive data : %d - %s\n\n", recv_len, recv_buf);
             }
@@ -157,26 +146,33 @@ static void TcpSocketRecvTask(void *arg)
 
 void TcpSocketRecvTest(int argc, char *argv[])
 {
-    if(argc >= 2)
-    {
+    if(argc >= 2) {
         lw_print("lw: [%s] target ip %s\n", __func__, argv[1]);
         TcpSocketConfigParam(argv[1]);
     }
 
-#ifdef ADD_XIZI_FETURES
-    lwip_config_tcp(lwip_ipaddr, lwip_netmask, tcp_socket_ip);
-    sys_thread_new("TcpSocketRecvTask", TcpSocketRecvTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO);
+#ifdef ADD_XIZI_FEATURES
+    lwip_config_tcp(0, tcp_demo_ipaddr, tcp_demo_netmask, tcp_demo_gwaddr);
+
+    pthread_attr_t attr;
+    attr.schedparam.sched_priority = LWIP_TCP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_TCP_DEMO_TASK_STACK_SIZE;
 #endif
 
-#ifdef ADD_NUTTX_FETURES
-    TcpSocketRecvTask(NULL);
+#ifdef ADD_NUTTX_FEATURES
+    pthread_attr_t attr = PTHREAD_ATTR_INITIALIZER;
+    attr.priority = LWIP_TCP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_TCP_DEMO_TASK_STACK_SIZE;
 #endif
+
+    PrivTaskCreate(&tcp_server_task, &attr, &TcpSocketRecvTask, NULL);
+    PrivTaskStartup(&tcp_server_task);
 }
 PRIV_SHELL_CMD_FUNCTION(TcpSocketRecvTest, a tcp receive sample, PRIV_SHELL_CMD_MAIN_ATTR);
 
-static void TcpSocketSendTask(void *arg)
+static void *TcpSocketSendTask(void *arg)
 {
-    int cnt = LWIP_DEMO_TIMES;
+    int cnt = TCP_DEMO_SEND_TIMES;
     int fd = -1;
     int ret;
     char send_msg[128];
@@ -186,10 +182,9 @@ static void TcpSocketSendTask(void *arg)
 
     memset(send_msg, 0, sizeof(send_msg));
     fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (fd < 0)
-    {
+    if (fd < 0) {
         lw_print("Socket error\n");
-        return;
+        return NULL;
     }
 
     struct sockaddr_in tcp_sock;
@@ -200,17 +195,15 @@ static void TcpSocketSendTask(void *arg)
     memset(&(tcp_sock.sin_zero), 0, sizeof(tcp_sock.sin_zero));
 
     ret = connect(fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr));
-    if (ret)
-    {
-        lw_print("Unable to connect %s = %d\n", tcp_ip_str, ret);
+    if (ret < 0) {
+        lw_print("Unable to connect %s:%d = %d\n", tcp_ip_str, tcp_socket_port, ret);
         close(fd);
-        return;
+        return NULL;
     }
 
     lw_print("TCP connect %s:%d success, start to send.\n", tcp_ip_str, tcp_socket_port);
 
-    while (cnt --)
-    {
+    while (cnt --) {
         lw_print("Lwip client is running.\n");
         snprintf(send_msg, sizeof(send_msg), "TCP test package times %d\r\n", cnt);
         send(fd, send_msg, strlen(send_msg), 0);
@@ -219,24 +212,31 @@ static void TcpSocketSendTask(void *arg)
     }
 
     close(fd);
-    return;
+    return NULL;
 }
 
 void TcpSocketSendTest(int argc, char *argv[])
 {
-    if(argc >= 2)
-    {
+    if(argc >= 2) {
         lw_print("lw: [%s] target ip %s\n", __func__, argv[1]);
         TcpSocketConfigParam(argv[1]);
     }
 
-#ifdef ADD_XIZI_FETURES
-    lwip_config_tcp(lwip_ipaddr, lwip_netmask, tcp_socket_ip);
-    sys_thread_new("Tcp Socket Send", TcpSocketSendTask, NULL, LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO);
+#ifdef ADD_XIZI_FEATURES
+    lwip_config_tcp(0, tcp_demo_ipaddr, tcp_demo_netmask, tcp_demo_gwaddr);
+
+    pthread_attr_t attr;
+    attr.schedparam.sched_priority = LWIP_TCP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_TCP_DEMO_TASK_STACK_SIZE;
 #endif
-#ifdef ADD_NUTTX_FETURES
-    TcpSocketSendTask(NULL);
+#ifdef ADD_NUTTX_FEATURES
+    pthread_attr_t attr = PTHREAD_ATTR_INITIALIZER;
+    attr.priority = LWIP_TCP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_TCP_DEMO_TASK_STACK_SIZE;
 #endif
+
+    PrivTaskCreate(&tcp_client_task, &attr, &TcpSocketSendTask, NULL);
+    PrivTaskStartup(&tcp_client_task);
 }
 PRIV_SHELL_CMD_FUNCTION(TcpSocketSendTest, a tcp send sample, PRIV_SHELL_CMD_MAIN_ATTR);
 

APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c

@@ -19,12 +19,12 @@
 */
 #include <transform.h>
 
-#ifdef ADD_XIZI_FETURES
-#include "sys_arch.h"
+#ifdef ADD_XIZI_FEATURES
+#include <sys_arch.h>
 #include "lwip/sockets.h"
 #endif
 
-#ifdef ADD_NUTTX_FETURES
+#ifdef ADD_NUTTX_FEATURES
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
@@ -38,11 +38,20 @@
 #define lw_print printf
 #endif
 
-#define UDP_BUF_SIZE 65536
+#define UDP_DEMO_BUF_SIZE                    65535
+#define UDP_DEMO_SEND_TIMES                  20
+#define LWIP_UDP_DEMO_TASK_STACK_SIZE        4096
+#define LWIP_UDP_DEMO_TASK_PRIO              20
 
-char udp_socket_ip[] = {192, 168, 250, 252};
-char udp_ip_str[128] = {0};
-uint16_t udp_socket_port = LWIP_LOCAL_PORT;
+static pthread_t udp_client_task;
+static pthread_t udp_server_task;
+
+static char udp_demo_ipaddr[] = {192, 168, 131, 77};
+static char udp_demo_netmask[] = {255, 255, 254, 0};
+static char udp_demo_gwaddr[] = {192, 168, 131, 1};
+
+static char udp_ip_str[128] = {0};
+static uint16_t udp_socket_port = 8888;
 
 /*****************************************************************************/
 void UdpSocketConfigParam(char *ip_str)
@@ -50,53 +59,38 @@ void UdpSocketConfigParam(char *ip_str)
     int ip1, ip2, ip3, ip4, port = 0;
 
     if(ip_str == NULL)
-    {
         return;
-    }
 
-    if(sscanf(ip_str, "%d.%d.%d.%d:%d", &ip1, &ip2, &ip3, &ip4, &port))
-    {
+    if(sscanf(ip_str, "%d.%d.%d.%d:%d", &ip1, &ip2, &ip3, &ip4, &port)) {
         printf("config ip %s port %d\n", ip_str, port);
         strcpy(udp_ip_str, ip_str);
-        udp_socket_ip[0] = ip1;
-        udp_socket_ip[1] = ip2;
-        udp_socket_ip[2] = ip3;
-        udp_socket_ip[3] = ip4;
         if(port)
             udp_socket_port = port;
         return;
     }
 
-    if(sscanf(ip_str, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4))
-    {
+    if(sscanf(ip_str, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4)) {
         printf("config ip %s\n", ip_str);
-        udp_socket_ip[0] = ip1;
-        udp_socket_ip[1] = ip2;
-        udp_socket_ip[2] = ip3;
-        udp_socket_ip[3] = ip4;
         strcpy(udp_ip_str, ip_str);
     }
 }
 
-static void UdpSocketRecvTask(void *arg)
+static void *UdpSocketRecvTask(void *arg)
 {
     int fd = -1;
     char *recv_buf;
     struct sockaddr_in udp_addr, server_addr;
     int recv_len;
 
-    while(1)
-    {
-        recv_buf = (char *)malloc(UDP_BUF_SIZE);
-        if(recv_buf == NULL)
-        {
+    while(1) {
+        recv_buf = (char *)PrivMalloc(UDP_DEMO_BUF_SIZE);
+        if(recv_buf == NULL) {
             lw_error("No memory\n");
             continue;
         }
 
         fd = socket(AF_INET, SOCK_DGRAM, 0);
-        if(fd < 0)
-        {
+        if(fd < 0) {
             lw_error("Socket error\n");
             free(recv_buf);
             continue;
@@ -107,8 +101,7 @@ static void UdpSocketRecvTask(void *arg)
         udp_addr.sin_port = htons(udp_socket_port);
         memset(&(udp_addr.sin_zero), 0, sizeof(udp_addr.sin_zero));
 
-        if(bind(fd, (struct sockaddr *)&udp_addr, sizeof(struct sockaddr)) == -1)
-        {
+        if(bind(fd, (struct sockaddr *)&udp_addr, sizeof(struct sockaddr)) == -1) {
             lw_error("Unable to bind\n");
             close(fd);
             free(recv_buf);
@@ -118,12 +111,10 @@ static void UdpSocketRecvTask(void *arg)
         lw_notice("UDP bind success, start to receive.\n");
         lw_notice("\n\nLocal Port:%d\n\n", udp_socket_port);
 
-        while(1)
-        {
-            memset(recv_buf, 0, UDP_BUF_SIZE);
-            recv_len = recv(fd, recv_buf, UDP_BUF_SIZE, 0);
-            if(recv_len > 0)
-            {
+        while(1) {
+            memset(recv_buf, 0, UDP_DEMO_BUF_SIZE);
+            recv_len = recv(fd, recv_buf, UDP_DEMO_BUF_SIZE, 0);
+            if(recv_len > 0) {
                 lw_notice("Receive from : %s\n", inet_ntoa(server_addr.sin_addr));
                 lw_notice("Receive data : %s\n\n", recv_buf);
             }
@@ -137,36 +128,41 @@ static void UdpSocketRecvTask(void *arg)
 
 void UdpSocketRecvTest(int argc, char *argv[])
 {
-    if(argc >= 2)
-    {
+    if(argc >= 2) {
         lw_notice("lw: [%s] target ip %s\n", __func__, argv[1]);
         UdpSocketConfigParam(argv[1]);
     }
 
-#ifdef ADD_XIZI_FETURES
-    lwip_config_tcp(lwip_ipaddr, lwip_netmask, udp_socket_ip);
-    sys_thread_new("UdpSocketRecvTask", UdpSocketRecvTask, NULL,
-        LWIP_TASK_STACK_SIZE, LWIP_DEMO_TASK_PRIO);
+#ifdef ADD_XIZI_FEATURES
+    lwip_config_tcp(0, udp_demo_ipaddr, udp_demo_netmask, udp_demo_gwaddr);
+
+    pthread_attr_t attr;
+    attr.schedparam.sched_priority = LWIP_UDP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_UDP_DEMO_TASK_STACK_SIZE;
 #endif
-#ifdef ADD_NUTTX_FETURES
-    UdpSocketRecvTask(NULL);
+#ifdef ADD_NUTTX_FEATURES
+    pthread_attr_t attr = PTHREAD_ATTR_INITIALIZER;
+    attr.priority = LWIP_UDP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_UDP_DEMO_TASK_STACK_SIZE;
 #endif
+
+    PrivTaskCreate(&udp_server_task, &attr, &UdpSocketRecvTask, NULL);
+    PrivTaskStartup(&udp_server_task);
 }
 PRIV_SHELL_CMD_FUNCTION(UdpSocketRecvTest, a udp receive sample, PRIV_SHELL_CMD_MAIN_ATTR);
 
-static void UdpSocketSendTask(void *arg)
+static void *UdpSocketSendTask(void *arg)
 {
-    int cnt = LWIP_DEMO_TIMES;
+    int cnt = UDP_DEMO_SEND_TIMES;
     char send_str[128];
     int fd = -1;
 
     memset(send_str, 0, sizeof(send_str));
 
     fd = socket(AF_INET, SOCK_DGRAM, 0);
-    if(fd < 0)
-    {
+    if(fd < 0) {
         lw_error("Socket error\n");
-        return;
+        return NULL;
     }
 
     struct sockaddr_in udp_sock;
@@ -175,19 +171,17 @@ static void UdpSocketSendTask(void *arg)
     udp_sock.sin_addr.s_addr = inet_addr(udp_ip_str);
     memset(&(udp_sock.sin_zero), 0, sizeof(udp_sock.sin_zero));
 
-    if(connect(fd, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr)))
-    {
-        lw_error("Unable to connect\n");
+    if(connect(fd, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr)) < 0) {
+        lw_error("Unable to connect %s:%d\n", udp_ip_str, udp_socket_port);
         close(fd);
-        return;
+        return NULL;
     }
 
     lw_print("UDP connect %s:%d success, start to send.\n",
         udp_ip_str,
         udp_socket_port);
 
-    while(cnt --)
-    {
+    while(cnt --) {
         snprintf(send_str, sizeof(send_str), "UDP test package times %d\r\n", cnt);
         send(fd, send_str, strlen(send_str), 0);
         lw_notice("Send UDP msg: %s ", send_str);
@@ -195,25 +189,31 @@ static void UdpSocketSendTask(void *arg)
     }
 
     close(fd);
-    return;
+    return NULL;
 }
 
 void UdpSocketSendTest(int argc, char *argv[])
 {
-    if(argc >= 2)
-    {
+    if(argc >= 2) {
         lw_notice("lw: [%s] target ip %s\n", __func__, argv[1]);
         UdpSocketConfigParam(argv[1]);
     }
 
-#ifdef ADD_XIZI_FETURES
-    lwip_config_tcp(lwip_ipaddr, lwip_netmask, udp_socket_ip);
-    sys_thread_new("UdpSocketSendTask", UdpSocketSendTask, NULL, LWIP_TASK_STACK_SIZE,
-        LWIP_DEMO_TASK_PRIO);
+#ifdef ADD_XIZI_FEATURES
+    lwip_config_tcp(0, udp_demo_ipaddr, udp_demo_netmask, udp_demo_gwaddr);
+
+    pthread_attr_t attr;
+    attr.schedparam.sched_priority = LWIP_UDP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_UDP_DEMO_TASK_STACK_SIZE;
 #endif
-#ifdef ADD_NUTTX_FETURES
-    UdpSocketSendTask(NULL);
+#ifdef ADD_NUTTX_FEATURES
+    pthread_attr_t attr = PTHREAD_ATTR_INITIALIZER;
+    attr.priority = LWIP_UDP_DEMO_TASK_PRIO;
+    attr.stacksize = LWIP_UDP_DEMO_TASK_STACK_SIZE;
 #endif
+
+    PrivTaskCreate(&udp_client_task, &attr, &UdpSocketSendTask, NULL);
+    PrivTaskStartup(&udp_client_task);
 }
 PRIV_SHELL_CMD_FUNCTION(UdpSocketSendTest, a udp send sample, PRIV_SHELL_CMD_MAIN_ATTR);
 

APP_Framework/Applications/control_app/plc_demo/Makefile

@@ -1,3 +1,3 @@
-SRC_DIR := advantech beckhoff br delta mitsubishi omron schneider siemens
+SRC_DIR := advantech beckhoff br delta mitsubishi omron schneider siemens ge xinje inovance keyence
 
 include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/br/Makefile

@@ -1,3 +1,3 @@
-SRC_FILES := br_x20cp0410.c br_x20cp1381.c br_x20cp1586.c
+SRC_FILES := br_x20cp0410.c br_x20cp1381.c br_x20cp1586.c br_ppc2100.c
 
 include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/br/README.md

@@ -0,0 +1,23 @@
+# 贝加莱 PPC2100通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 网口
+  * 通过ETH1 RJ45 网口连接
+  * 网口参数：IP：192.168.250.26  Port：502
+  * 测试的协议:Modbus TCP
+
+## 存储区
+
+- 贝加莱PLC与其他PLC不同，没有明确类似M，D等这样的存储区的概念，Modbus地址取决于库函数中结构体变量索引。
+
+## 通信测试
+
+-  共测试BOOL，INT16，INT32，FLOAT,DOUBLE 共五种类型数据。
+-  测试BOOL型变量，用功能码01，测其他类型变量用功能码03。
+-  
+
+
+

APP_Framework/Applications/control_app/plc_demo/br/br_ppc2100.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file br_ppc2100.c
+ * @brief PLC BR PPC2100 app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.5.8
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlBrTest_PPC2100(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_tcp_protocol = ControlProtocolFind();
+    if (NULL == modbus_tcp_protocol) {
+        printf("%s get modbus tcp protocol %p failed\n", __func__, modbus_tcp_protocol);
+        return;
+    }
+
+    printf("%s get modbus tcp protocol %p successfull\n", __func__, modbus_tcp_protocol);
+
+    if (CONTROL_REGISTERED == modbus_tcp_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_tcp_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_tcp_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus tcp data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlBrTest_PPC2100, Delta ppc2100 Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/br/test_recipe_br_ppc2100.json

@@ -0,0 +1,93 @@
+{
+    "device_id": 1,
+    "device_name": "BR_PPC2100",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.26",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.254.0",
+        "port": 502
+    },
+    "protocol_type": 2,
+    "read_period": 2000,
+  "read_item_list": [
+    {
+      "value_name": "motorrun",
+      "value_type": 1,
+      "function_code": 2,
+      "start_address": 0,
+      "quantity": 1
+    },
+    {
+      "value_name": "motorstop",
+      "value_type": 1,
+      "function_code": 2,
+      "start_address": 1,
+      "quantity": 1
+    },
+    {
+      "value_name": "valueopen",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 100,
+      "quantity": 1
+    },
+    {
+      "value_name": "valueclose",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 101,
+      "quantity": 1
+    },
+    {
+      "value_name": "step",
+      "value_type": 3,
+      "function_code": 4,
+      "start_address": 100,
+      "quantity": 1
+    },
+    {
+      "value_name": "temperature",
+      "value_type": 9,
+      "function_code": 4,
+      "start_address": 101,
+      "quantity": 2
+    },
+    {
+      "value_name": "status",
+      "value_type": 4,
+      "function_code": 4,
+      "start_address": 103,
+      "quantity": 2
+    },
+    {
+      "value_name": "mode",
+      "value_type": 3,
+      "function_code": 3,
+      "start_address": 200,
+      "quantity": 1
+    },
+    {
+      "value_name": "setTemperature",
+      "value_type": 9,
+      "function_code": 3,
+      "start_address": 201,
+      "quantity": 2
+    },
+    {
+      "value_name": "setConuter",
+      "value_type": 4,
+      "function_code": 3,
+      "start_address": 203,
+      "quantity": 2
+    },
+    {
+      "value_name": "LrealTest",
+      "value_type": 8,
+      "function_code": 3,
+      "start_address": 205,
+      "quantity": 4
+    }
+  ]
+}

APP_Framework/Applications/control_app/plc_demo/delta/Makefile

@@ -1,3 +1,3 @@
-SRC_FILES := delta_as228t.c
+SRC_FILES := delta_as228t.c delta_as332t.c delta_dvp.c
 
 include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/delta/README.md

@@ -0,0 +1,22 @@
+# 台达 DVP通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 网口
+  * 通过自带 RJ45 网口连接
+  * 网口参数：IP：192.168.250.27  Port：502
+  * 测试的协议:Modbus TCP
+
+## 存储区
+
+- 含M，D，X，Y。台达PLC中 各存储区地址和Modbus地址有明确的对应表，详见台达DVP协议解析测试文档。
+
+## 通信测试
+
+-  共测试BOOL，INT16，INT32，FLOAT 共四种类型数据。
+-  测试D区，M区和Y区。
+
+
+

APP_Framework/Applications/control_app/plc_demo/delta/delta_dvp.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file delta_dvp.c
+ * @brief PLC DELTA DVP app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.9.27
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlDeltadvpTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_tcp_protocol = ControlProtocolFind();
+    if (NULL == modbus_tcp_protocol) {
+        printf("%s get modbus tcp protocol %p failed\n", __func__, modbus_tcp_protocol);
+        return;
+    }
+
+    printf("%s get modbus tcp protocol %p successfull\n", __func__, modbus_tcp_protocol);
+
+    if (CONTROL_REGISTERED == modbus_tcp_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_tcp_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_tcp_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus tcp data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlDeltadvpTest, Delta dvp Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/delta/test_recipe_delta_dvp.json

@@ -0,0 +1,80 @@
+{
+    "device_id": 1,
+    "device_name": "DELTA_DVP",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.27",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.254.0",
+        "port": 502
+    },
+    "protocol_type": 2,
+    "read_period": 2000,
+    "read_item_list": [
+        {
+            "value_name": "M20",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 2068,
+            "quantity": 1
+        },
+        {
+            "value_name": "M100",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address":2148,
+            "quantity": 1
+        },
+        {
+            "value_name": "Y10",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 1288,
+            "quantity": 1
+        },
+        {
+            "value_name": "D200",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address":4296,
+            "quantity": 1
+        },
+        {
+            "value_name": "D201",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 4297,
+            "quantity": 1
+        },
+        {
+            "value_name": "D220",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 4316,
+            "quantity": 2
+        },
+        {
+            "value_name": "D222",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 4318,
+            "quantity": 2
+        },
+        {
+            "value_name": "D300",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 4396,
+            "quantity": 2
+        },
+        {
+            "value_name": "D302",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 4398,
+            "quantity": 2
+        }
+        
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/ge/Makefile

@@ -0,0 +1,3 @@
+SRC_FILES := ge_versamax001.c ge_cpe100.c
+
+include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/ge/ge README.md

@@ -0,0 +1,57 @@
+---
+typora-copy-images-to: upload
+---
+
+# 艾默生（原GE） 通信测试
+
+[TOC]
+
+## 小型VersaMAX CPU001测试
+
+### 通信接线及参数设置
+
+* 串口
+  * COM2为15孔D型 RS485。波特率：19200，数据位：8位，停止位：1位，校验：偶校验。接线按下图典型双线接法。
+  
+    ![ge_versamax_serial](./img/ge_versamax_serial.png)
+
+### 存储区
+
+- 存储区 I，Q，AI，R区。其他内存区如M，AQ不能直接访问，要通过程序转换访问。
+
+### 通信测试
+
+-  共测试BOOL，INT16，FLOAT共三种类型数据。
+
+
+- 测试R区及Q区数据。
+
+
+- R区数据测试，用功能码03，以字为单位读取。配方中start_address字段为PLC地址直接减1。
+
+
+- Q区数据测试，用功能码01，以位为单位读取。配方中start_address字段为PLC地址直接减1。
+
+## 中型PLC CPE100通信测试
+
+### 通信接线及参数设置
+
+- 网口
+  - 网口RJ45，参数 IP：192.168.250.28 端口号：502
+
+### 存储区
+
+- 存储区 I，Q，AI，R区。其他内存区如M，AQ不能直接访问，要通过程序转换访问。
+
+### 通信测试
+
+-   共测试BOOL，INT16，INT32，FLOAT，DOUBLE共五种类型数据。
+
+
+- 测试R区及Q区数据。
+
+
+- R区数据测试，用功能码03，以字为单位读取。配方中start_address字段为PLC地址直接减1。
+
+
+- Q区数据测试，用功能码01，以位为单位读取。配方中start_address字段为PLC地址直接减1。

APP_Framework/Applications/control_app/plc_demo/ge/ge_cpe100.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file ge_cpe100.c
+ * @brief PLC GE Versamax app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.9.27
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlGecpe100Test(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_tcp_protocol = ControlProtocolFind();
+    if (NULL == modbus_tcp_protocol) {
+        printf("%s get modbus tcp protocol %p failed\n", __func__, modbus_tcp_protocol);
+        return;
+    }
+
+    printf("%s get modbus tcp protocol %p successfull\n", __func__, modbus_tcp_protocol);
+
+    if (CONTROL_REGISTERED == modbus_tcp_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_tcp_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_tcp_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus tcp data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlGecpe100Test, ge cpe100 Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/ge/ge_versamax001.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file ge_versamax001.c
+ * @brief PLC GE Versamax app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.9.27
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlGeversamaxTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_rtu_protocol = ControlProtocolFind();
+    if (NULL == modbus_rtu_protocol) {
+        printf("%s get modbus rtu protocol %p failed\n", __func__, modbus_rtu_protocol);
+        return;
+    }
+
+    printf("%s get modbus rtu protocol %p successfull\n", __func__, modbus_rtu_protocol);
+
+    if (CONTROL_REGISTERED == modbus_rtu_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_rtu_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_rtu_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus rtu data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_rtu_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlGeversamaxTest, ge versamax001 Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/ge/test_recipe_ge_cpe_tcp.json

@@ -0,0 +1,73 @@
+{
+    "device_id": 1,
+    "device_name": "GE_CPE100_TCP",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.28",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.254.0",
+        "port": 502
+    },
+    "protocol_type": 2,
+    "read_period": 2000,
+    "read_item_list": [
+        {
+            "value_name": "Q001",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 0,
+            "quantity": 1
+        },
+        {
+            "value_name": "Q010",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address":9,
+            "quantity": 1
+        },
+        {
+            "value_name": "Q066",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 65,
+            "quantity": 1
+        },
+        {
+            "value_name": "Q100",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address":99,
+            "quantity": 1
+        },
+        {
+            "value_name": "R11",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 10,
+            "quantity": 1
+        },
+        {
+            "value_name": "R12",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 11,
+            "quantity": 2
+        },
+        {
+            "value_name": "R14",
+            "value_type": 8,
+            "function_code": 3,
+            "start_address": 13,
+            "quantity": 4
+        },
+        {
+            "value_name": "R18",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 17,
+            "quantity": 2
+        }
+        
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/ge/test_recipe_ge_versamax_rtu.json

@@ -0,0 +1,58 @@
+{
+    "device_id": 1,
+    "device_name": "GE_VersaMAX_RTU",
+    "communication_type": 1,
+    "serial_config": {
+        "station": 1,
+        "baud_rate": 19200,
+        "data_bits": 8,
+        "stop_bits": 1,
+        "check_mode": 2
+    },
+    "protocol_type": 3,
+    "read_period": 2000,
+  "read_item_list": [
+    {
+      "value_name": "Q001",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 0,
+      "quantity": 1
+    },
+    {
+       "value_name": "Q010",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 9,
+      "quantity": 1
+    },
+    {
+       "value_name": "Q066",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 65,
+      "quantity": 1
+    },
+    {
+       "value_name": "Q100",
+      "value_type": 1,
+      "function_code": 1,
+      "start_address": 99,
+      "quantity": 1
+    },
+    {
+       "value_name": "R11",
+      "value_type": 3,
+      "function_code": 3,
+      "start_address": 10,
+      "quantity": 1
+    },
+    {
+      "value_name": "R12",
+      "value_type": 9,
+      "function_code": 3,
+      "start_address": 11,
+      "quantity": 2
+    }
+  ]
+}

APP_Framework/Applications/control_app/plc_demo/inovance/Makefile

@@ -0,0 +1,3 @@
+SRC_FILES := inovance_am401_cpu1608tn_ethernet.c  inovance_am401_cpu1608tn_uart.c
+
+include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/inovance/README.md

@@ -0,0 +1,26 @@
+# INOVANCE AM4011608TN通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 网口
+
+  * CN3 EtherNET,Mosbus TCP协议，IP：192.168.250.50，Port：502
+
+* 串口
+  * CN1 RS485，AM401只支持一路串口，AM600可支持两路串口。AM401接线：pin1:485-，pin2:485+。波特率：9600，数据位：8位，停止位：1位，校验：偶校验
+
+## 存储区
+
+- 存储区 I，Q，M区。
+
+## 通信测试
+
+（1）共测试BOOL，INT16，INT32，FLOAT共四种类型数据。
+
+（2）测试M区及Q区数据。
+
+（3）M区数据测试，用功能码03，以字为单位读取。如读MX0.3,则读取MW0，然后按位拆解。如读MW100，则配方文件中起始地址则直接写100即可。如读MDx，则配方文件中起始地址应为2*x，这是汇川的地址编码规则决定，如MD200，则对应400。
+
+（4）Q区数据测试，用功能码01，以位为单位读取。如读QX.Y，则配方文件中起始地址为X*8+Y；如读QW，QD等，则需按位进行读取后然后组合得到。

APP_Framework/Applications/control_app/plc_demo/inovance/inovance_am401_cpu1608tn_ethernet.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file inovance_am401_cpu1608tn_ethernet.c
+ * @brief PLC inovance am401 app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.4.25
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlInovanceam401EthernetTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_tcp_protocol = ControlProtocolFind();
+    if (NULL == modbus_tcp_protocol) {
+        printf("%s get modbus tcp protocol %p failed\n", __func__, modbus_tcp_protocol);
+        return;
+    }
+
+    printf("%s get modbus tcp protocol %p successfull\n", __func__, modbus_tcp_protocol);
+
+    if (CONTROL_REGISTERED == modbus_tcp_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_tcp_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_tcp_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus tcp data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlInovanceam401EthernetTest, inovance am401 ethernet Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/inovance/inovance_am401_cpu1608tn_uart.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file inovance_am401_cpu1608tn_ethernet.c
+ * @brief PLC inovance am401 app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.5.15
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlInovanceam401UartTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType modbus_rtu_protocol = ControlProtocolFind();
+    if (NULL == modbus_rtu_protocol) {
+        printf("%s get modbus rtu protocol %p failed\n", __func__, modbus_rtu_protocol);
+        return;
+    }
+
+    printf("%s get modbus rtu protocol %p successfull\n", __func__, modbus_rtu_protocol);
+
+    if (CONTROL_REGISTERED == modbus_rtu_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_rtu_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_rtu_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus rtu data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_rtu_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlInovanceam401UartTest, inovance am401 uart Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/inovance/test_recipe_inovance_am401_tcp.json

@@ -0,0 +1,80 @@
+{
+    "device_id": 1,
+    "device_name": "INOVANCE_AM401_TCP",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.50",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.254.0",
+        "port": 502
+    },
+    "protocol_type": 2,
+    "read_period": 2000,
+    "read_item_list": [
+        {
+            "value_name": "q00",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 0,
+            "quantity": 1
+        },
+        {
+            "value_name": "q01",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address":1,
+            "quantity": 1
+        },
+        {
+            "value_name": "q10",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 8,
+            "quantity": 1
+        },
+        {
+            "value_name": "mw100",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 100,
+            "quantity": 1
+        },
+        {
+            "value_name": "mw101",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 101,
+            "quantity": 1
+        },
+        {
+            "value_name": "md200",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 400,
+            "quantity": 2
+        },
+        {
+            "value_name": "md201",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 402,
+            "quantity": 2
+        },
+        {
+            "value_name": "md300",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 600,
+            "quantity": 2
+        },
+        {
+            "value_name": "md301",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 602,
+            "quantity": 2
+        }
+        
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/inovance/test_recipe_inovance_am401_uart.json

@@ -0,0 +1,80 @@
+{
+     "device_id": 1,
+    "device_name": "INOVANCE_am401_RTU",
+    "communication_type": 1,
+    "serial_config": {
+        "station": 1,
+        "baud_rate": 9600,
+        "data_bits": 8,
+        "stop_bits": 1,
+        "check_mode":3
+    },
+    "protocol_type": 3,
+    "read_period": 2000,
+    "read_item_list": [
+        {
+            "value_name": "q00",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 0,
+            "quantity": 1
+        },
+        {
+            "value_name": "q01",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address":1,
+            "quantity": 1
+        },
+        {
+            "value_name": "q10",
+            "value_type": 1,
+            "function_code": 1,
+            "start_address": 8,
+            "quantity": 1
+        },
+        {
+            "value_name": "mw100",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 100,
+            "quantity": 1
+        },
+        {
+            "value_name": "mw101",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 101,
+            "quantity": 1
+        },
+        {
+            "value_name": "md200",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 400,
+            "quantity": 2
+        },
+        {
+            "value_name": "md201",
+            "value_type": 4,
+            "function_code": 3,
+            "start_address": 402,
+            "quantity": 2
+        },
+        {
+            "value_name": "md300",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 600,
+            "quantity": 2
+        },
+        {
+            "value_name": "md301",
+            "value_type": 9,
+            "function_code": 3,
+            "start_address": 602,
+            "quantity": 2
+        }
+        
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/keyence/Makefile

@@ -0,0 +1,3 @@
+SRC_FILES := kv_8000.c
+
+include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/keyence/README.md

@@ -0,0 +1,22 @@
+# KEYENCE 通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 网口
+
+  *Mosbus TCP协议，IP：192.168.250.40，Port：502
+
+## 存储区
+
+- 存储区ZF区。
+
+## 通信测试
+
+（1）共测试INT16类型数据。
+
+（2）测试ZF区数据。
+
+（3）D区数据测试，用功能码03和06，以字为单位读写。如读写ZF1，则配方文件中起始地址则直接写1即可。
+

APP_Framework/Applications/control_app/plc_demo/keyence/kv_8000.c

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file kv_8000.c
+ * @brief PLC KEYENCE KV-8000 app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.4.12
+ */
+
+#include <control.h>
+void ControlKV8000Test(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+    ControlProtocolType modbus_tcp_protocol = ControlProtocolFind();
+    if (NULL == modbus_tcp_protocol) {
+        printf("%s get modbus tcp protocol %p failed\n", __func__, modbus_tcp_protocol);
+        return;
+    }
+    printf("%s get modbus tcp protocol %p successfull\n", __func__, modbus_tcp_protocol);
+
+    if (CONTROL_REGISTERED == modbus_tcp_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_tcp_protocol);
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_tcp_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus tcp data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));          
+            PrivTaskDelay(10000);
+        }
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlKV8000Test, KEYENCE Plc KV_8000 Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/keyence/test_recipe_KV_8000.json

@@ -0,0 +1,37 @@
+{
+    "device_id": 1,
+    "device_name": "GJ2",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.40",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.255.0",
+        "port": 502
+    },
+    "protocol_type": 2,
+    "read_period": 100,
+    "read_item_list": [
+        {
+            "value_name": "ZF0",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 0,
+            "quantity": 1
+        },
+        {
+            "value_name": "ZF1",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 1,
+            "quantity": 1
+        },
+        {
+            "value_name": "ZF2",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 2,
+            "quantity": 1
+        }
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/mitsubishi/Makefile

@@ -1,3 +1,3 @@
-SRC_FILES := mitsubishi_fx3u.c mitsubishi_fx5u.c
+SRC_FILES := mitsubishi_fx3u.c mitsubishi_fx5u.c mitsubishi_fx2n.c mitsubishi_q02u.c
 
 include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/mitsubishi/README.md

@@ -0,0 +1,24 @@
+# 三菱 FX2N通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 串口
+  * FX2N自带8针圆口422，用于程序的下载。全系列不支持网口，且需购买串口拓展模块FX2N-485-BD用于通信测试。
+  * 接线：RDA和SDA短接，引出A；RDB与SDB短接，引出B。
+  * 串口模块支持MC-1C协议，通信速率：9600；数据位：7bit；停止位：1bit；校验：偶校验
+
+## 存储区
+
+- 存储区 I，Q，M，D区。
+
+## 通信测试
+
+-  共测试BOOL，INT16，FLOAT共三种类型数据。
+
+
+-  测试M区及D区数据。
+
+
+

APP_Framework/Applications/control_app/plc_demo/mitsubishi/mitsubishi_fx2n.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file mitsubishi_fx2n.c
+ * @brief PLC MITSUBISHI FX2N app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.9.27
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlFx2nTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType melsec_1c_protocol = ControlProtocolFind();
+    if (NULL == melsec_1c_protocol) {
+        printf("%s get melsec 1c protocol %p failed\n", __func__, melsec_1c_protocol);
+        return;
+    }
+
+    printf("%s get melsec 1c protocol %p successfull\n", __func__, melsec_1c_protocol);
+
+    if (CONTROL_REGISTERED == melsec_1c_protocol->protocol_status) {
+        ControlProtocolOpen(melsec_1c_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(melsec_1c_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] melsec 1c data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(melsec_1c_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlFx2nTest, Mitsubishi FX2N Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/mitsubishi/mitsubishi_fx3u.c

@@ -18,6 +18,47 @@
  * @date 2022.9.27
  */
 
-
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlFx3uTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType melsec_1e_protocol = ControlProtocolFind();
+    if (NULL == melsec_1e_protocol) {
+        printf("%s get melsec 1e protocol %p failed\n", __func__, melsec_1e_protocol);
+        return;
+    }
+
+    printf("%s get melsec 1e protocol %p successfull\n", __func__, melsec_1e_protocol);
+
+    if (CONTROL_REGISTERED == melsec_1e_protocol->protocol_status) {
+        ControlProtocolOpen(melsec_1e_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(melsec_1e_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] melsec 1e data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_tcp_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlFx3uTest, Mitsubishi fx3u Demo, PRIV_SHELL_CMD_MAIN_ATTR);
 
 

APP_Framework/Applications/control_app/plc_demo/mitsubishi/mitsubishi_q02u.c

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file mitsubishi_q02u.c
+ * @brief PLC MITSUBISHI Q02U app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2022.9.27
+ */
+
+#include <control.h>
+
+extern int Adapter4GActive(void);
+
+void ControlQ02uTest(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+#ifdef CONNECTION_ADAPTER_4G
+    Adapter4GActive();
+#endif
+
+    ControlProtocolType melsec_3e_protocol = ControlProtocolFind();
+    if (NULL == melsec_3e_protocol) {
+        printf("%s get melsec 3e protocol %p failed\n", __func__, melsec_3e_protocol);
+        return;
+    }
+
+    printf("%s get melsec 3e protocol %p successfull\n", __func__, melsec_3e_protocol);
+
+    if (CONTROL_REGISTERED == melsec_3e_protocol->protocol_status) {
+        ControlProtocolOpen(melsec_3e_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(melsec_3e_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] melsec 3c data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(melsec_3c_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlQ02uTest, Mitsubishi Q02U Demo, PRIV_SHELL_CMD_MAIN_ATTR);
+
+

APP_Framework/Applications/control_app/plc_demo/mitsubishi/test_recipe_mc_1c.json

@@ -0,0 +1,331 @@
+{
+    "device_id": 769,
+    "device_name": "S01",
+    "communication_type": 1,
+    "serial_config": {
+         "station": 1,
+        "baud_rate": 9600,
+        "data_bits": 7,
+        "stop_bits": 1,
+        "check_mode": 3
+    },
+    "protocol_type": 9,
+    "read_period": 1000,
+    "read_item_list": [
+        {
+            "value_name": "启动",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "0",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "停止",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "1",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "使能",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "2",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "回零",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "3",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "急停",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "4",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "正限位",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "5",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "负限位",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "6",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "自动运行中",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "20",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "故障",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "21",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "待机",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "22",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "手动模式",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "23",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "自动模式",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "24",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "运行方向",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "25",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "复位",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "26",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "备用1",
+            "value_type": 1,
+            "device_code": "M",
+            "head_device_number_string": "27",
+            "device_points_count": 1,
+            "command_type": 0,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "产量",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "0",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型1",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "1",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型2",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "2",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型3",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "3",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型4",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "4",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型5",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "5",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型6",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "50",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型7",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "51",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型8",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "52",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "整型9",
+            "value_type": 3,
+            "device_code": "D",
+            "head_device_number_string": "53",
+            "device_points_count": 1,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "速度",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "200",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "加速度",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "202",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "减速度",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "204",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "起始位置",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "206",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "终点位置",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "208",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "张力值",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "300",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "浮点型1",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "302",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "浮点型2",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "304",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "浮点型3",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "306",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        },
+        {
+            "value_name": "浮点型4",
+            "value_type": 9,
+            "device_code": "D",
+            "head_device_number_string": "308",
+            "device_points_count": 2,
+            "command_type": 1,
+            "monitoring_timer": 100
+        }
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/omron/Makefile

@@ -1,3 +1,3 @@
-SRC_FILES := omron_cj2m.c omron_nj501.c omron_nx102.c
+SRC_FILES := omron_cj2m.c omron_nj501.c omron_nx102.c omron_cp1h.c omron_cp1l.c
 
 include $(KERNEL_ROOT)/compiler.mk

APP_Framework/Applications/control_app/plc_demo/omron/README.md

@@ -0,0 +1,70 @@
+# OMRON_CP1L通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 本体无接口，增加CP1W-CIF41网络板卡
+
+* FINS协议，PLC IP：192.168.250.31，Port：9600
+
+## 存储区
+
+- 存储区 W，D区。
+
+## JSON配方设计
+
+* 共测试BOOL，INT16共2种类型数据,以下为JSON文件解释。
+
+  - ```json
+    {
+        "device_id": 1,                     //设备ID默认是1，此参数无效
+        "device_name": "CP1L",              //设备名称，自定义
+        "communication_type": 0,            //通讯协议类型 0是以太网，1是串口 
+        "socket_config": {                  //以太网配置
+            "plc_ip": "192.168.250.31",     //PLC的IP地址
+            "local_ip": "192.168.250.233",  //矽达通IP地址设定
+            "gateway": "192.168.250.1",     //矽达通的网关地址设定
+            "netmask": "255.255.255.0",     //矽达通子网掩码设定
+            "port": 9600                    //端口号设定
+        },
+        "protocol_type": 5,                 //通讯协议，5代表FINS协议
+        "read_period": 100,                 //交互周期ms
+        "read_item_list": [
+            {
+                "value_name": "停止",  //变量名称，自定义
+                "value_type": 1,      //变量类型，BOOL = 1,INT8 = 2,INT16,INT32,UINT8,UINT16,UINT32,DOUBLE,FLOAT = 9
+                "area_char": "W",     //变量功能块
+                "data_type": 0,       //数据传输类型，BOOL = 0,WORD = 1
+            	"start_address": 100, //起始地址
+                "bit_address": 1,     //BOOL地址偏移位，采集变量地址是W100.1
+                "data_length": 1      //BOOL长度，默认是1，代表读取1个BOOL长度
+            },
+            {
+                "value_name": "转速",  //变量名称，自定义
+                "value_type": 3,      //变量类型，BOOL = 1,INT8 = 2,INT16,INT32,UINT8,UINT16,UINT32,DOUBLE,FLOAT = 9
+                "area_char": "D",     //变量功能块
+                "data_type": 1,       //数据传输类型，BOOL = 0,WORD = 1
+                "start_address": 101, //起始地址
+                "bit_address": 0,     //以WORD采集方式时此参数无效，采集变量地址是D101
+                "data_length": 1      //WORD长度，默认是1，代表读取1个WORD长度，2个字节
+            }
+        ]
+    }
+    ```
+
+## 通信测试
+
+ (1) 新增1个通信demo，命名为omron_cp1l.c；
+
+ (2) 复制样例代码程序到omron_cp1l.c文件中；
+
+ (3) void **ControlOmronCP1LTest**(void) 更改函数名；
+
+ (4) PRIV_SHELL_CMD_FUNCTION(**ControlOmronCP1LTest**, **Omron Plc Cp1l Demo**, PRIV_SHELL_CMD_MAIN_ATTR);更改测试指令；
+
+  (5) 剪裁配置完成后，用过烧写器下载至矽达通中，重启后完成测试。
+
+
+
+ 

APP_Framework/Applications/control_app/plc_demo/omron/omron_cj2m.c

@@ -18,6 +18,32 @@
  * @date 2022.9.27
  */
 
+#include <control.h>
 
+void ControlOmronTest(void)
+{
+    int i = 0;
+    uint16_t read_data_length = 0;
+    uint8_t read_data[1024] = {0};
+    ControlProtocolType fins_protocol = ControlProtocolFind();
+    if (NULL == fins_protocol) {
+        printf("%s get fins protocol %p failed\n", __func__, fins_protocol);
+        return;
+    }
 
+    printf("%s get fins protocol %p successfull\n", __func__, fins_protocol);
 
+    if (CONTROL_REGISTERED == fins_protocol->protocol_status) {
+        ControlProtocolOpen(fins_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(fins_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] fins data %d using receipe file\n", __func__, i, read_data_length);
+            i++;
+            PrivTaskDelay(100000);
+        }
+
+        //ControlProtocolClose(fins_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlOmronTest, Omron Plc FINS Demo, PRIV_SHELL_CMD_MAIN_ATTR);

APP_Framework/Applications/control_app/plc_demo/omron/omron_cp1h.c

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file omron_cp1h.c
+ * @brief PLC OMRON CP1H app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.4.1
+ */
+
+#include <control.h>
+
+void ControlOmronCP1HTest(void)
+{
+    int i = 0;
+    uint16_t read_data_length = 0;
+    uint8_t read_data[1024] = {0};
+    ControlProtocolType fins_protocol = ControlProtocolFind();
+    if (NULL == fins_protocol) {
+        printf("%s get fins protocol %p failed\n", __func__, fins_protocol);
+        return;
+    }
+
+    printf("%s get fins protocol %p successfull\n", __func__, fins_protocol);
+
+    if (CONTROL_REGISTERED == fins_protocol->protocol_status) {
+        ControlProtocolOpen(fins_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(fins_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] fins data %d using receipe file\n", __func__, i, read_data_length);
+            i++;
+            PrivTaskDelay(100000);
+        }
+
+        //ControlProtocolClose(fins_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlOmronCP1HTest, Omron Plc Cp1h Demo, PRIV_SHELL_CMD_MAIN_ATTR);

APP_Framework/Applications/control_app/plc_demo/omron/omron_cp1l.c

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2022 AIIT XUOS Lab
+ * XiUOS is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *        http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+/**
+ * @file omron_.cp1l.c
+ * @brief PLC OMRON CP1L app
+ * @version 3.0
+ * @author AIIT XUOS Lab
+ * @date 2023.2.10
+ */
+#include <control.h>
+
+void ControlOmronCP1LTest(void)
+{
+    int i = 0;
+    uint16_t read_data_length = 0;
+    uint8_t read_data[1024] = {0};
+    ControlProtocolType fins_protocol = ControlProtocolFind();
+    if (NULL == fins_protocol) {
+        printf("%s get fins protocol %p failed\n", __func__, fins_protocol);
+        return;
+    }
+
+    printf("%s get fins protocol %p successfull\n", __func__, fins_protocol);
+
+    if (CONTROL_REGISTERED == fins_protocol->protocol_status) {
+        ControlProtocolOpen(fins_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(fins_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] fins data %d using receipe file\n", __func__, i, read_data_length);
+            i++;
+            PrivTaskDelay(100000);
+        }
+
+        //ControlProtocolClose(fins_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlOmronCP1LTest, Omron Plc Cp1l Demo, PRIV_SHELL_CMD_MAIN_ATTR);

APP_Framework/Applications/control_app/plc_demo/omron/omron_nx102.c

@@ -18,6 +18,34 @@
  * @date 2022.9.27
  */
 
-
+#include <control.h>
+
+void ControlOmronNX102Test(void)
+{
+    int i = 0;
+    uint16_t read_data_length = 0;
+    uint8_t read_data[1024] = {0};
+    ControlProtocolType fins_protocol = ControlProtocolFind();
+    if (NULL == fins_protocol) {
+        printf("%s get fins protocol %p failed\n", __func__, fins_protocol);
+        return;
+    }
+
+    printf("%s get fins protocol %p successfull\n", __func__, fins_protocol);
+
+    if (CONTROL_REGISTERED == fins_protocol->protocol_status) {
+        ControlProtocolOpen(fins_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(fins_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] fins data %d using receipe file\n", __func__, i, read_data_length);
+            i++;
+            PrivTaskDelay(10000);
+        }
+
+        // ControlProtocolClose(fins_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlOmronNX102Test, Omron Plc FINS Demo, PRIV_SHELL_CMD_MAIN_ATTR);
 
 

APP_Framework/Applications/control_app/plc_demo/omron/test_recipe_CP1H.json

@@ -0,0 +1,70 @@
+{
+    "device_id": 1,
+    "device_name": "CP1H",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.46",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.255.0",
+        "port": 9600
+    },
+    "protocol_type": 5,
+    "read_period": 100,
+    "read_item_list": [
+        {
+            "value_name": "启动",
+            "value_type": 1,
+            "area_char": "W",
+            "data_type": 0,
+            "start_address": 10,
+            "bit_address": 0,
+            "data_length": 1
+        },
+        {
+            "value_name": "停止",
+            "value_type": 1,
+            "area_char": "W",
+            "data_type": 0,
+            "start_address": 10,
+            "bit_address": 1,
+            "data_length": 1
+        },
+		{
+            "value_name": "暂停",
+            "value_type": 1,
+            "area_char": "W",
+            "data_type": 0,
+            "start_address": 10,
+            "bit_address": 2,
+            "data_length": 1
+        },
+        {
+            "value_name": "整型1",
+            "value_type": 3,
+            "area_char": "D",
+            "data_type": 1,
+            "start_address": 100,
+            "bit_address": 0,
+            "data_length": 1
+        },
+        {
+            "value_name": "整型2",
+            "value_type": 3,
+            "area_char": "D",
+            "data_type": 1,
+            "start_address": 101,
+            "bit_address": 0,
+            "data_length": 1
+        },
+		{
+            "value_name": "浮点",
+            "value_type": 9,
+            "area_char": "D",
+            "data_type": 1,
+            "start_address": 110,
+            "bit_address": 0,
+            "data_length": 2
+        }
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/omron/test_recipe_CP1L.json

@@ -0,0 +1,52 @@
+{
+    "device_id": 1,
+    "device_name": "CP1L",
+    "communication_type": 0,
+    "socket_config": {
+        "plc_ip": "192.168.250.31",
+        "local_ip": "192.168.250.233",
+        "gateway": "192.168.250.1",
+        "netmask": "255.255.255.0",
+        "port": 9600
+    },
+    "protocol_type": 5,
+    "read_period": 100,
+    "read_item_list": [
+        {
+            "value_name": "启动",
+            "value_type": 1,
+            "area_char": "W",
+            "data_type": 0,
+            "start_address": 100,
+            "bit_address": 0,
+            "data_length": 1
+        },
+        {
+            "value_name": "停止",
+            "value_type": 1,
+            "area_char": "W",
+            "data_type": 0,
+            "start_address": 100,
+            "bit_address": 1,
+            "data_length": 1
+        },
+        {
+            "value_name": "转速",
+            "value_type": 3,
+            "area_char": "D",
+            "data_type": 1,
+            "start_address": 101,
+            "bit_address": 0,
+            "data_length": 1
+        },
+        {
+            "value_name": "产量",
+            "value_type": 3,
+            "area_char": "D",
+            "data_type": 1,
+            "start_address": 102,
+            "bit_address": 0,
+            "data_length": 1
+        }
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/schneider/README.md

@@ -0,0 +1,21 @@
+# SCHNEIDER M241通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 串口
+  * M241支持2路485串口，本次采用的是serial2。波特率：9600，数据位：8位，停止位：1位，校验：偶校验
+
+## 存储区
+
+- 存储区MW区。
+
+## 通信测试
+
+（1）共测试INT16共1种类型数据。
+
+（2）测试MW区数据。
+
+（3）MW区数据测试，用功能码03，以字为单位读取。如读MW100，则配方文件中起始地址则直接写100即可。
+

APP_Framework/Applications/control_app/plc_demo/schneider/m241_recipe.json

@@ -0,0 +1,30 @@
+{
+    "device_id": 1,
+    "device_name": "m241",
+    "communication_type": 1,
+    "serial_config": {
+        "station": 1,
+        "baud_rate": 9600,
+        "data_bits": 8,
+        "stop_bits": 1,
+        "check_mode": 3
+    },
+    "protocol_type": 3,
+    "read_period": 100,
+    "read_item_list": [
+        {
+            "value_name": "MW0",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 0,
+            "quantity": 1
+        },
+        {
+            "value_name": "MW1",
+            "value_type": 3,
+            "function_code": 3,
+            "start_address": 1,
+            "quantity": 1
+        }
+    ]
+}

APP_Framework/Applications/control_app/plc_demo/schneider/schneider_m241.c

@@ -15,9 +15,47 @@
  * @brief PLC SCHNEIDER M241 app
  * @version 3.0
  * @author AIIT XUOS Lab
- * @date 2022.9.27
+ * @date 2023.2.1
  */
 
-
+#include <control.h>
+void ControlM241Test(void)
+{
+    int i, j = 0;
+    int read_data_length = 0;
+    uint8_t read_data[128] = {0};
+
+    #ifdef CONNECTION_ADAPTER_4G
+        Adapter4GActive();
+    #endif
+
+    ControlProtocolType modbus_rtu_protocol = ControlProtocolFind();
+    if (NULL == modbus_rtu_protocol) {
+        printf("%s get modbus rtu protocol %p failed\n", __func__, modbus_rtu_protocol);
+        return;
+    }
+
+    printf("%s get modbus rtu protocol %p successfull\n", __func__, modbus_rtu_protocol);
+
+    if (CONTROL_REGISTERED == modbus_rtu_protocol->protocol_status) {
+        ControlProtocolOpen(modbus_rtu_protocol);
+
+        for (;;) {
+            read_data_length = ControlProtocolRead(modbus_rtu_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] modbus rtu data %d using receipe file\n", __func__, i, read_data_length);
+            if (read_data_length) {
+                for (j = 0; j < read_data_length; j ++) {
+                    printf("j %d data 0x%x\n", j, read_data[j]);
+                }
+            }
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+
+        //ControlProtocolClose(modbus_rtu_protocol);
+    }
+}
+PRIV_SHELL_CMD_FUNCTION(ControlM241Test, Schneider M241 Demo, PRIV_SHELL_CMD_MAIN_ATTR);
 
 

APP_Framework/Applications/control_app/plc_demo/siemens/README.md

@@ -0,0 +1,79 @@
+# SIEMENS - S7-1512通信测试
+
+[TOC]
+
+## 通信接线及参数设置
+
+* 本体以太网口
+
+* S7协议，PLC IP：192.168.250.2，Port：102
+
+## 存储区
+
+- 存储区 Q，DB区。
+
+## JSON配方设计
+
+* 共测试BOOL，INT16共2种类型数据,以下为JSON文件解释。
+
+  - ```json
+    {
+        "device_id": 1,                     //设备ID默认是1，此参数无效
+        "device_name": "S7-1512",           //设备名称，自定义
+        "communication_type": 0,            //通讯协议类型 0是以太网，1是串口 
+        "socket_config": {                  //以太网配置
+            "plc_ip": "192.168.250.2",      //PLC的IP地址
+            "local_ip": "192.168.250.233",  //矽达通IP地址设定
+            "gateway": "192.168.250.1",     //矽达通的网关地址设定
+            "netmask": "255.255.255.0",     //矽达通子网掩码设定
+            "port": 102                     //端口号设定
+        },
+        "protocol_type": 1,                 //通讯协议，5代表FINS协议
+        "read_period": 100,                 //交互周期ms
+        "read_item_list": [
+            {
+                "value_name": "布尔1",    //变量名称，自定义
+                "value_type": 1,         //变量类型，BOOL = 1,INT8 = 2,INT16,INT32,UINT8,UINT16,UINT32,DOUBLE,FLOAT = 9
+                "area": "Q",             //变量功能块
+                "wordlen": "Bit",        //变量字长类型,有：Bit Byte Word DWord Real Counter Timer
+                "db_number": 1,          //如为DB区，填写对应的DB块编号,如不是DB区，无效
+                "start": 1,              //BOOL地址偏移位，采集变量地址是Q0.1   
+                "amount": 1              //BOOL长度，默认是1，代表读取1个BOOL长度
+            },
+    		{ 
+                "value_name": "整型",     //变量名称，自定义
+                "value_type": 3,         //变量类型，BOOL = 1,INT8 = 2,INT16,INT32,UINT8,UINT16,UINT32,DOUBLE,FLOAT = 9
+                "area": "DB",            //变量功能块
+                "wordlen": "Word",       //变量字长类型,有：Bit Byte Word DWord Real Counter Timer
+                "db_number": 18,         //如为DB区，即DB18块
+                "start": 2,              //Word地址偏移位，采集变量地址是DB18.DBW2 
+                "amount": 1              //Word长度，默认是1，代表读取1个WORD长度，2个字节
+            },
+            {
+                "value_name": "浮点数",   //变量名称，自定义
+                "value_type": 9,         //变量类型，BOOL = 1,INT8 = 2,INT16,INT32,UINT8,UINT16,UINT32,DOUBLE,FLOAT = 9
+                "area": "DB",            //变量功能块
+                "wordlen": "Real",       //变量字长类型,有：Bit Byte Word DWord Real Counter Timer
+                "db_number": 18,         //如为DB区，即DB18块
+                "start": 18,             //Real地址偏移位，采集变量地址是DB18.DBD18 
+                "amount": 1              //Real长度，默认是1，代表读取1个Real长度，4个字节
+            }
+        ]
+    }
+    ```
+
+## 通信测试
+
+ (1) 新增1个通信demo，命名为simens_s7_1500.c；
+
+ (2) 复制样例代码程序到simens_s7_1500.c文件中；
+
+ (3) void **ControlS71500Test**(void)更改函数名；
+
+ (4) PRIV_SHELL_CMD_FUNCTION(**ControlS71500Test, Siemens Plc S7_1512 Demo**, PRIV_SHELL_CMD_MAIN_ATTR)；更改测试指令；
+
+  (5) 剪裁配置完成后，用过烧写器下载至矽达通中，重启后完成测试。
+
+
+
+ 

APP_Framework/Applications/control_app/plc_demo/siemens/siemens_s7_1200.c

@@ -15,9 +15,6 @@
  * @brief PLC SIEMENS S7-1200 app
  * @version 3.0
  * @author AIIT XUOS Lab
- * @date 2022.9.27
+ * @date 2023.3.27
  */
 
-
-
-

APP_Framework/Applications/control_app/plc_demo/siemens/siemens_s7_1500.c

@@ -15,9 +15,31 @@
  * @brief PLC SIEMENS S7-1500 app
  * @version 3.0
  * @author AIIT XUOS Lab
- * @date 2022.9.27
+ * @date 2023.3.27
  */
 
+#include <control.h>
+void ControlS71500Test(void)
+{
+    int i = 0;
+    uint16_t read_data_length = 0;
+    uint8_t read_data[1024] = {0};
+    ControlProtocolType s7_protocol = ControlProtocolFind();
+    if (NULL == s7_protocol) {
+        printf("%s get s7 protocol %p failed\n", __func__, s7_protocol);
+        return;
+    }
+    printf("%s get s7 protocol %p successfull\n", __func__, s7_protocol);
+    if (CONTROL_REGISTERED == s7_protocol->protocol_status) {
+        ControlProtocolOpen(s7_protocol);
+        for (;;) {
+            read_data_length = ControlProtocolRead(s7_protocol, read_data, sizeof(read_data));
+            printf("%s read [%d] s7 data %d using receipe file\n", __func__, i, read_data_length);
+            i++;
+            memset(read_data, 0, sizeof(read_data));
+            PrivTaskDelay(10000);
+        }
+    } 
+}
 
-
-
+PRIV_SHELL_CMD_FUNCTION(ControlS71500Test, Siemens Plc S7_1512 Demo, PRIV_SHELL_CMD_MAIN_ATTR);