feat: ✨ 初步完成对外接口输入和输出

main/APP/main_app/main_app.c

@@ -95,6 +95,7 @@ uint8_t imp_main_app_task()
         // 10 ticks = 100ms
         msg_recv_ret = imp_msg_queue_recv_msg(msg_q_handle, &msg_item, 10);
         if (!msg_recv_ret) {
+            cdc_printf("get msg from %d  OK\r\n", msg_item.send_id);
             switch (msg_item.msg_type) {
             }
         }
@@ -103,7 +104,7 @@ uint8_t imp_main_app_task()
             cdc_printf("hello %d\r\n", i);
         }
 
-        if (i++ % 4 == 0) {
+        if (i++ % 30 == 0) {
             msg_item.msg_data = i;
             imp_msg_queue_send_msg(
                 msg_q_handle, IMP_TASK_ID_EXT_TRANS_SERVICE_TASK, &msg_item);

main/CMakeLists.txt

@@ -10,6 +10,7 @@ idf_component_register(
     "utilities/usb_cherry/CherryUSB/core/"
     "utilities/usb_cherry/CherryUSB/port/dwc2/"
     "utilities/imp_util_ring_queue/"
+    "utilities/imp_util_tlv_trans_protocol/"
     "utilities/imp_types/"
     "APP/main_app/"
     "components/msq_queue"
@@ -22,6 +23,7 @@ idf_component_register(
     "utilities/usb_cherry/CherryUSB/core/usbh_core.c"
     "utilities/usb_cherry/CherryUSB/port/dwc2/usb_hc_dwc2.c"
     "utilities/imp_util_ring_queue/ring_queue_test.c"
+    "utilities/imp_util_tlv_trans_protocol/imp_tlv_tp_test.c"
                     
     INCLUDE_DIRS 
     "."
@@ -40,6 +42,7 @@ idf_component_register(
     "components/msq_queue"
     "components/imp_out_port"
     "services/ext_trans_service"
+    "utilities/imp_util_tlv_trans_protocol/"
 
     LDFRAGMENTS 
     "utilities/letter_shell/port/esp-idf/shell.lf"

main/components/imp_out_port/imp_out_port.c

@@ -76,18 +76,17 @@ uint16_t imp_comp_out_port_write(imp_comp_out_port_type_e type, uint8_t* data,
 uint8_t imp_comp_out_port_ioctl(imp_comp_out_port_cmd_e cmd, uint8_t* data,
                                 uint16_t data_len)
 {
-    char *hello_string = "hello";
     if (NULL == data || handle.is_init == 0) {
         return 1;
     }
 
     switch (cmd) {
-        case EM_IMP_OUT_PORT_CMD_SET_OUT_TYPE:
+        case EM_IMP_OUT_PORT_CMD_SET_OUT_TYPE: {
-            handle.out_type = *((imp_comp_out_port_type_e*)data);
+            imp_comp_out_port_type_e type = *data;
-            break;
+            handle.out_type               = type;
+        } break;
         case EM_IMP_OUT_PORT_CMD_SET_OUT_WRIT_FUNC:
             handle.trans_writ = (uint16_t(*)(uint8_t*, uint16_t))data;
-            handle.trans_writ((uint8_t *)hello_string, strlen(hello_string));
             break;
         case EM_IMP_OUT_PORT_CMD_SET_OUT_READ_FUNC:
             handle.trans_read = (uint16_t(*)(uint8_t*, uint16_t))data;

main/components/msq_queue/imp_msg_queue.c

@@ -40,9 +40,9 @@ uint8_t imp_msg_queue_init()
     sg_imp_msg_queue =
         xQueueCreate(IMP_MSG_QUEUE_MAX_ITEM_COUNT, sizeof(imp_msg_item_t));
     if (sg_imp_msg_queue != NULL) {
-        cdc_printf("msg queue init ok!\n");
+        cdc_printf("msg queue init ok!\r\n");
     } else {
-        cdc_printf("msg queue init failed!\n");
+        cdc_printf("msg queue init failed!\r\n");
         return 1;
     }
     return 0;
@@ -51,7 +51,7 @@ uint8_t imp_msg_queue_init()
 imp_msg_queue_t* imp_msg_queue_create_handle(uint16_t task_id)
 {
     if (NULL == sg_imp_msg_queue) {
-        cdc_printf("msg queue create failed!\n");
+        cdc_printf("msg queue create failed!\r\n");
         return NULL;
     }
     imp_msg_queue_t* ptr  = (imp_msg_queue_t*)malloc(sizeof(imp_msg_queue_t*));
@@ -66,11 +66,13 @@ uint8_t imp_msg_queue_recv_msg(imp_msg_queue_t* handle, imp_msg_item_t* msg,
                                uint16_t timeout)
 {
     if (NULL == sg_imp_msg_queue || NULL == handle) {
-        cdc_printf("handle or msg queue is NULL\n");
+        cdc_printf("handle or msg queue is NULL\r\n");
         return 1;
     }
-    BaseType_t     msg_queue_return;
+    BaseType_t      msg_queue_return;
-    imp_msg_item_t item = { 0 };
+    imp_msg_item_t  item         = { 0 };
+    static uint16_t msg_peek_cnt = 0;
+    static uint16_t last_task_id = 0;
 
     msg_queue_return = xQueuePeek(handle->msg_queue_handle, &item, timeout);
     if (msg_queue_return != pdTRUE) {
@@ -79,10 +81,23 @@ uint8_t imp_msg_queue_recv_msg(imp_msg_queue_t* handle, imp_msg_item_t* msg,
         // read succeed
         if (item.recv_id == handle->task_id) {
             xQueueReceive(handle->msg_queue_handle, msg, 0);
+            msg_peek_cnt = 0;
             if (msg->recv_id == handle->task_id) {
                 return 0;
             }
             return 3;
+        } else {
+            if (last_task_id != handle->task_id) {
+                msg_peek_cnt++;
+            }
+            last_task_id = handle->task_id;
+            if (msg_peek_cnt >= IMP_MSG_QUEUE_MAX_PEEK_CNT) {
+                // drop a msg
+                xQueueReceive(handle->msg_queue_handle, &item, 0);
+                msg_peek_cnt = 0;
+                cdc_printf("[warning] msg queue drop msg from %d to %d\r\n",
+                           item.send_id, item.recv_id);
+            }
         }
     }
     return 4;
@@ -92,7 +107,7 @@ uint8_t imp_msg_queue_send_msg(imp_msg_queue_t* handle, uint16_t recv_id,
                                imp_msg_item_t* msg)
 {
     if (NULL == sg_imp_msg_queue || NULL == handle) {
-        cdc_printf("handle or msg queue is NULL\n");
+        cdc_printf("handle or msg queue is NULL\r\n");
         return 1;
     }
     BaseType_t msg_queue_return;
@@ -107,7 +122,7 @@ uint8_t imp_msg_queue_send_msg(imp_msg_queue_t* handle, uint16_t recv_id,
 uint8_t imp_msg_queue_destroy_handle(imp_msg_queue_t* handle)
 {
     if (NULL == sg_imp_msg_queue || NULL == handle) {
-        cdc_printf("handle or msg queue is NULL\n");
+        cdc_printf("handle or msg queue is NULL\r\n");
         return 1;
     }
 

main/components/msq_queue/imp_msg_queue.h

@@ -37,6 +37,9 @@ extern "C" {
 /* define --------------------------------------------------------------------*/
 
 #define IMP_MSG_QUEUE_MAX_ITEM_COUNT (20)
+
+/// @brief 一个消息最多阻塞在头部多少次，避免消息队列被持续阻塞
+#define IMP_MSG_QUEUE_MAX_PEEK_CNT (20)
 /* typedef -------------------------------------------------------------------*/
 
 /// @brief 消息队列的消息内容

main/main.c

@@ -94,7 +94,7 @@ static void _show_build_time(int argc, char** argv)
     cdc_printf("build at %s %s\r\n", __DATE__, __TIME__);
 }
 
-static uint8_t imp_restart_esp()
+uint8_t imp_restart_esp()
 {
     cdc_printf("Restarting now.\r\n");
     vTaskDelay(10);

main/main_common.c

@@ -23,9 +23,11 @@
 /* Includes ------------------------------------------------------------------*/
 #include "main_common.h"
 #include <stdarg.h>
+#include <stdlib.h>
 #include "shell_port.h"
 #include "main_app.h"
 #include "imp_msg_queue.h"
+#include "shell_port.h"
 /* define --------------------------------------------------------------------*/
 /* typedef -------------------------------------------------------------------*/
 /* variables -----------------------------------------------------------------*/
@@ -42,6 +44,22 @@ extern void     cdc_acm_msc_init();
 extern uint16_t cdc_usb_read_bytes(uint8_t* data, uint16_t len);
 extern uint16_t cdc_usb_writ_bytes(uint8_t* data, uint16_t len);
 
+uint8_t _imp_set_out_port(int argc, char** argv)
+{
+    if (argc < 2) {
+        cdc_printf("too few arg\r\n");
+        return 1;
+    }
+    uint8_t type = atoi(argv[1]);
+    cdc_printf("set outport type %d\r\n", type);
+    imp_comp_out_port_ioctl(EM_IMP_OUT_PORT_CMD_SET_OUT_TYPE, (uint8_t*)&type,
+                            1);
+    return 0;
+}
+
+SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN),
+                 oport, _imp_set_out_port, set out port);
+
 /* Exported functions --------------------------------------------------------*/
 
 uint8_t imp_main_common_init()
@@ -67,9 +85,11 @@ int cdc_printf(const char* fmt, ...)
     va_start(args, fmt);
     n = vsnprintf(aBuffer, sizeof(aBuffer), fmt, args);
     if (n > (int)sizeof(aBuffer)) {
-        cdc_usb_writ_bytes((uint8_t*)aBuffer, sizeof(aBuffer));
+        imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_STRING, (uint8_t*)aBuffer,
+                                sizeof(aBuffer));
     } else if (n > 0) {
-        cdc_usb_writ_bytes((uint8_t*)aBuffer, n);
+        imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_STRING, (uint8_t*)aBuffer,
+                                n);
     }
     va_end(args);
     return n;

main/services/ext_trans_service/ext_trans_service.c

@@ -26,22 +26,70 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "imp_msg_queue.h"
+#include "imp_util_tlv_tp.h"
+#include "imp_out_port.h"
+#include <string.h>
 
 /* define --------------------------------------------------------------------*/
 /* typedef -------------------------------------------------------------------*/
 /* variables -----------------------------------------------------------------*/
 
-static imp_msg_queue_t* msg_q_handle = NULL;
+static imp_msg_queue_t*  msg_q_handle      = NULL;
+static char*             string_hello      = "imp_util_tlv_trans_protocol";
+static imp_util_tlv_tp_t tlv_encode_handle = { 0 };
+static imp_util_tlv_tp_t tlv_decode_handle = { 0 };
+static uint8_t           frame_buf[256];
+static uint8_t           read_buf[256];
+static uint16_t          frame_encode_len = 0;
+
+// external process func of ext_trans_service_process.c
+extern uint8_t imp_ext_trans_service_process_pre_init(imp_util_tlv_tp_t* enc,
+                                                      imp_util_tlv_tp_t* dec,
+                                                      uint8_t* framebuf);
+extern uint8_t imp_ext_trans_service_process_idle(imp_tlv_packet_t* packet);
+extern uint8_t
+imp_ext_trans_service_process_set_oport(imp_tlv_packet_t* packet);
+extern uint8_t imp_ext_trans_service_process_reboot(imp_tlv_packet_t* packet);
+
 /* Private function(only *.c)  -----------------------------------------------*/
+static uint8_t _imp_ext_trans_service_decode_cb(imp_tlv_packet_t* packet)
+{
+    switch (packet->type) {
+        case EM_IMP_EXT_TRANS_TLV_TYPE_IDLE:
+            imp_ext_trans_service_process_idle(packet);
+            break;
+        case EM_IMP_EXT_TRANS_TLV_TYPE_SET_OPRT:
+            imp_ext_trans_service_process_set_oport(packet);
+            break;
+        case EM_IMP_EXT_TRANS_TLV_TYPE_HRTB:
+            break;
+        case EM_IMP_EXT_TRANS_TLV_TYPE_REBOOT:
+            imp_ext_trans_service_process_reboot(packet);
+            break;
+        default:
+            break;
+    }
+    return 0;
+}
 /* Exported functions --------------------------------------------------------*/
 
 uint8_t imp_ext_trans_service_task()
 {
-    int i = 0;
+    int      i             = 0;
+    uint16_t read_data_len = 0;
+
+    imp_util_tlv_tp_init(&tlv_encode_handle, EM_IMP_UTIL_TLV_ROLE_DEVICE, 1024,
+                         NULL);
+    imp_util_tlv_tp_init(&tlv_decode_handle, EM_IMP_UTIL_TLV_ROLE_DEVICE, 1024,
+                         _imp_ext_trans_service_decode_cb);
     msg_q_handle =
         imp_msg_queue_create_handle(IMP_TASK_ID_EXT_TRANS_SERVICE_TASK);
+    imp_ext_trans_service_process_pre_init(&tlv_encode_handle,
+                                           &tlv_decode_handle, frame_buf);
+
     imp_msg_item_t msg_item     = { 0 };
     uint8_t        msg_read_ret = 0;
+
     while (1) {
         msg_read_ret = imp_msg_queue_recv_msg(msg_q_handle, &msg_item, 0);
         if (!msg_read_ret) {
@@ -50,8 +98,26 @@ uint8_t imp_ext_trans_service_task()
                        msg_item.send_id, msg_item.recv_id, msg_item.msg_data);
         }
 
+        // recv out
+        read_data_len =
+            imp_comp_out_port_read(EM_IMP_OUT_PORT_TYPE_CONTROL, read_buf, 1);
+        while (read_data_len) {
+            // process recv
+            imp_util_tlv_tp_decode(&tlv_decode_handle, read_buf, read_data_len);
+            read_data_len = imp_comp_out_port_read(EM_IMP_OUT_PORT_TYPE_CONTROL,
+                                                   read_buf, 1);
+        }
 
-        vTaskDelay(10 / portTICK_PERIOD_MS);
+        if (i++ % 400 == 0) {
+            // imp_util_tlv_tp_encode(&tlv_encode_handle,
+            //                        EM_IMP_EXT_TRANS_TLV_TYPE_IDLE,
+            //                        strlen(string_hello), (uint8_t*)string_hello,
+            //                        frame_buf, &frame_encode_len);
+            // imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_CONTROL, frame_buf,
+            //                         frame_encode_len);
+        }
+
+        vTaskDelay(5 / portTICK_PERIOD_MS);
     }
     return 0;
 }

main/services/ext_trans_service/ext_trans_service.h

@@ -35,6 +35,14 @@ extern "C" {
 #include "main_common.h"
 /* define --------------------------------------------------------------------*/
 /* typedef -------------------------------------------------------------------*/
+
+typedef enum __imp_ext_trans_tlv_type_e__
+{
+    EM_IMP_EXT_TRANS_TLV_TYPE_IDLE = 0x00,
+    EM_IMP_EXT_TRANS_TLV_TYPE_SET_OPRT,
+    EM_IMP_EXT_TRANS_TLV_TYPE_HRTB,
+    EM_IMP_EXT_TRANS_TLV_TYPE_REBOOT,
+} imp_ext_trans_tlv_type_e;
 /* variables -----------------------------------------------------------------*/
 /* Private function(only *.c)  -----------------------------------------------*/
 /* Exported functions --------------------------------------------------------*/

main/services/ext_trans_service/ext_trans_service_process.c

@@ -0,0 +1,96 @@
+/**
+ * @file ext_trans_service_process.c
+ * @author Alvin Young (impressionyang@outlook.com)
+ * @brief 
+ * @version 0.1
+ * @date 2024-12-19
+ * 
+ *      _                            _                              
+ *     (_)_ _  ___  _______ ___ ___ (_)__  ___  __ _____ ____  ___ _
+ *    / /  ' \/ _ \/ __/ -_|_-<(_-</ / _ \/ _ \/ // / _ `/ _ \/ _ `/
+ *   /_/_/_/_/ .__/_/  \__/___/___/_/\___/_//_/\_, /\_,_/_//_/\_, / 
+ *          /_/                               /___/          /___/  
+ * @copyright Copyright (c) 2024 impressionyang
+ * 
+ * @par 修改日志:
+ * <table>
+ * <tr><th>Date           <th>Version  <th>Author         <th>Description
+ * <tr><td>2024-12-19     <td>v1.0     <td>Alvin Young     <td>首次创建
+ * </table>
+ * 
+ */
+/* Define to prevent recursive inclusion -------------------------------------*/
+/* Includes ------------------------------------------------------------------*/
+#include "ext_trans_service.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include "imp_util_tlv_tp.h"
+#include "imp_out_port.h"
+/* define --------------------------------------------------------------------*/
+/* typedef -------------------------------------------------------------------*/
+/* variables -----------------------------------------------------------------*/
+
+static imp_util_tlv_tp_t* tlv_encode_handle = NULL;
+static imp_util_tlv_tp_t* tlv_decode_handle = NULL;
+static uint8_t*           frame_buf         = NULL;
+static uint16_t           frame_encode_len  = 0;
+
+extern uint8_t imp_restart_esp();
+
+/* Private function(only *.c)  -----------------------------------------------*/
+/* Exported functions --------------------------------------------------------*/
+
+uint8_t imp_ext_trans_service_process_pre_init(imp_util_tlv_tp_t* enc,
+                                               imp_util_tlv_tp_t* dec,
+                                               uint8_t*           framebuf)
+{
+    tlv_encode_handle = enc;
+    tlv_decode_handle = dec;
+    frame_buf         = framebuf;
+    return 0;
+}
+
+uint8_t imp_ext_trans_service_process_idle(imp_tlv_packet_t* packet)
+{
+    uint8_t status = 0;
+    imp_util_tlv_tp_encode(&tlv_encode_handle, EM_IMP_EXT_TRANS_TLV_TYPE_IDLE,
+                           sizeof(status), &status, frame_buf,
+                           &frame_encode_len);
+    imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_CONTROL, frame_buf,
+                            frame_encode_len);
+    return 0;
+}
+
+uint8_t imp_ext_trans_service_process_set_oport(imp_tlv_packet_t* packet)
+{
+    uint8_t                  status = 0;
+    imp_ext_trans_tlv_type_e type   = packet->value_data_ptr[0];
+    imp_comp_out_port_ioctl(EM_IMP_OUT_PORT_CMD_SET_OUT_TYPE, &type, 1);
+    imp_util_tlv_tp_encode(&tlv_encode_handle,
+                           EM_IMP_EXT_TRANS_TLV_TYPE_SET_OPRT, sizeof(status),
+                           &status, frame_buf, &frame_encode_len);
+    imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_CONTROL, frame_buf,
+                            frame_encode_len);
+    return 0;
+}
+
+uint8_t imp_ext_trans_service_process_heartbit(imp_tlv_packet_t* packet)
+{
+    uint8_t status = 0;
+    imp_util_tlv_tp_encode(&tlv_encode_handle, EM_IMP_EXT_TRANS_TLV_TYPE_HRTB,
+                           sizeof(status), &status, frame_buf,
+                           &frame_encode_len);
+    imp_comp_out_port_write(EM_IMP_OUT_PORT_TYPE_CONTROL, frame_buf,
+                            frame_encode_len);
+    return 0;
+}
+
+uint8_t imp_ext_trans_service_process_reboot(imp_tlv_packet_t* packet)
+{
+    imp_restart_esp();
+    return 0;
+}
+
+/*
+ * EOF
+ */

main/utilities/imp_util_tlv_trans_protocol

@@ -1 +1 @@
-Subproject commit d40ed5d390976e00d35359b2b32f3db71a4dd63b
+Subproject commit 7886d7a8d1c1f260190b5c7d90e9dd73bd6fb1ca

main/utilities/letter_shell/port/esp-idf/shell_port.c

@@ -19,8 +19,8 @@
 Shell shell;
 char  shellBuffer[512];
 
-extern uint16_t cdc_usb_read_bytes(uint8_t* data, uint16_t len);
+// extern uint16_t cdc_usb_read_bytes(uint8_t* data, uint16_t len);
-extern uint16_t cdc_usb_writ_bytes(uint8_t* data, uint16_t len);
+// extern uint16_t cdc_usb_writ_bytes(uint8_t* data, uint16_t len);
 
 /**
  * @brief 用户shell写

main/utilities/usb_cherry/esp_setup/my_usb_setup.c

@@ -187,7 +187,7 @@ uint16_t cdc_usb_read_bytes(uint8_t* data, uint16_t len)
         imp_util_ring_queue_read(&ring_q_cdc_recv, (uint8_t*)data, len);
     } else {
         data[0] = 0;
-        ret     = 1;
+        ret     = 0;
     }
 
     return ret;

sdkconfig

@@ -1157,7 +1157,7 @@ CONFIG_FATFS_LINK_LOCK=y
 #
 # CONFIG_FREERTOS_SMP is not set
 CONFIG_FREERTOS_UNICORE=y
-CONFIG_FREERTOS_HZ=100
+CONFIG_FREERTOS_HZ=1000
 CONFIG_FREERTOS_OPTIMIZED_SCHEDULER=y
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set