Merge branch 'master' of https://gitee.com/openLuat/LuatOS

components/airlink/src/task/luat_airlink_uart_task.c

@@ -31,19 +31,23 @@ extern airlink_statistic_t g_airlink_statistic;
 extern uint32_t g_airlink_pause;
 
 static luat_rtos_task_handle g_uart_task;
+static luat_rtos_task_handle g_uart_transfer_task;
+static luat_rtos_task_handle g_uart_receive_task;
 static luat_rtos_queue_t evt_queue;
+static luat_rtos_queue_t tx_evt_queue;// 
+static luat_rtos_queue_t rx_evt_queue;
 extern luat_airlink_irq_ctx_t g_airlink_irq_ctx;
 
 
 __USER_FUNC_IN_RAM__ static void on_newdata_notify(void)
 {
     luat_event_t evt = {.id = 3};
-    luat_rtos_queue_send(evt_queue, &evt, sizeof(evt), 0);
+    luat_rtos_queue_send(tx_evt_queue, &evt, sizeof(evt), 0);
 }
 
 static void uart_cb(int uart_id, uint32_t data_len) {
     luat_event_t evt = {.id = 2};
-    luat_rtos_queue_send(evt_queue, &evt, sizeof(evt), 0);
+    luat_rtos_queue_send(rx_evt_queue, &evt, sizeof(evt), 0);
 }
 
 static void uart_gpio_setup(void)
@@ -88,15 +92,6 @@ __USER_FUNC_IN_RAM__ static void on_link_data_notify(airlink_link_data_t* link)
     }
 }
 
-size_t get_real_len(uint8_t hex_low,uint8_t hex_high)
-{
-    size_t len = 0;
-    len = (hex_high << 8) + hex_low;
-    // LLOGD("len = %d",len);
-    return len;
-
-}
-
 static void parse_data(uint8_t* buff, size_t len)
 {
     luat_airlink_print_buff("反转义前的数据", buff,  len);
@@ -117,7 +112,7 @@ static void parse_data(uint8_t* buff, size_t len)
         }
     }
     airlink_link_data_t *link = luat_airlink_data_unpack(parse_buff, parse_len);
-    if (link == NULL) 
+    if (link == NULL)
     {
         LLOGE("luat_airlink_data_unpack failed len %d", parse_len);
         return;
@@ -126,202 +121,9 @@ static void parse_data(uint8_t* buff, size_t len)
     luat_airlink_on_data_recv(link->data, link->len);
 }
 
-#if 0
-static void on_uart_data_in(uint8_t* buff, size_t len) 
-{
-    // TODO 要处理分包, 连包的情况
-    // TODO 不能假设开头和结尾就一定是0x7E, 要查找, 要缓存
-    // 收到数据后去除帧头帧尾和魔数，遇到0x7E/0x7D 要转义
-    uint8_t* receive_data = buff;
-    uint32_t pos = 0;
-    uint32_t frame_start = 0;
-    uint32_t frame_end = 0,temp_frame_end = 0;
-    size_t receive_len = len;// - 2;
-    size_t data_len = 0;
-    static size_t half_data_len = 0;
-    static size_t temp_half_data_len = 0;
-    static uint8_t parse_state = 0;
-    uint8_t count = 0;
-    uint8_t parse_data_buff[TEST_BUFF_SIZE];
-    // LLOGD("receive_len:%d,len=%d",receive_len,len);
-    // for(uint8_t i = 0; i < receive_len; i++)
-    // {
-    //     LLOGD("receive_data[%d]: %02x", i, receive_data[i]);
-    // }
-    //先查找完整的一组数据包，然后再解析
-    //7E A1 B1 CA 66 0C 00 6B 62 00 00 00 00 00 00 00 00 20 00 08 00 7B 69 68 64 6C 6B 73 7D 7E
-    while(pos < receive_len)
-    {
-        if(receive_data[pos] == 0x7E && receive_data[pos + 1] == 0xA1 && receive_data[pos + 2] == 0xB1 && receive_data[pos + 3] == 0xCA && receive_data[pos + 4] == 0x66) 
-        {
-            frame_start = pos;//找到帧头
-            parse_state = 1;//
-            // LLOGD("状态机parse_state = %d", parse_state);
-            // LLOGD("找到帧头，frame_start = %d", frame_start);
-            data_len = get_real_len(receive_data[frame_start + 5],receive_data[frame_start + 6]);//根据帧中数据获取长度,7E,7D
-            // LLOGD("接收到的长度转换为十进制：%d", data_len);
-            for(uint32_t i = pos + 17; i < receive_len ; i++) //帧头+魔数+数据长度+crc+id+flag（1+4+2+2+4+4=17）在剩余数据中查找帧尾
-            {
-                // LLOGD("正在寻找帧尾0x7E...");
-                // LLOGD("receive_data[%d]: %02x", i, receive_data[i]);
-                if(receive_data[i] == 0x7E) 
-                {
-                    uint32_t count = 0;
-                    for(uint32_t i = frame_start; i < data_len + 18; i++)//遍历寻找转义次数
-                    {
-                        if(receive_data[i] == 0x7D && receive_data[i + 1] == 0x02) {
-                            count++;
-                        }
-                        else if(receive_data[i] == 0x7D && receive_data[i + 1] == 0x01) {
-                            count++;
-                        }
-                    }
-                    temp_frame_end = i;//找到帧尾                    
-                    // LLOGD("parse_state = 2,count = %d",count);
-                    // LLOGD("找到帧头，frame_start = %d", frame_start);
-                    // LLOGD("临时帧尾 = %d", temp_frame_end);
-                    // LLOGD("接收到的长度转换为十进制：%d", data_len);
-                    for(uint32_t j = 0; j < (data_len + count + 18 + 1); j++)
-                        parse_data_buff[j] = receive_data[j + frame_start];
-                    parse_data(parse_data_buff, (data_len + count + 18));
-                    if((temp_frame_end - frame_start + 1 - count - 18) == data_len) //帧长度正确29-0+1-17=12
-                    {
-                        frame_end = temp_frame_end;
-                        LLOGD("完整数据包");
-                        LLOGD("count=%d",count);
-                        pos = frame_end + 1;
-                        break;  
-                    }
-                    else
-                    {
-                        parse_state = 6;//有帧头帧尾，长度不对，舍弃
-                        // LLOGD("找到帧头,frame_start = %d", frame_start);
-                        // LLOGD("count=%d", count);
-                        // LLOGD("临时帧尾 = %d", temp_frame_end);
-                        // LLOGD("接收到的长度转换为：%d", data_len);
-                        LLOGD("有帧头帧尾，长度不对，舍弃");
-                        pos = temp_frame_end + count + 1;//重新判断帧头
-                        break;
-                    }
-                }
-                else//找到帧头，但是没有帧尾，数据不完整，先缓存
-                {
-                    if(i == receive_len - 1)//直到最后一个字节都没有找到帧尾，数据不完整，先缓存
-                    {
-                        uint32_t count = 0;
-                        for(uint32_t j = frame_start; j < receive_len; j++)//遍历寻找转义次数
-                        {
-                            if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x02) {
-                                count++;
-                            }
-                            else if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x01) {
-                                count++;
-                            }
-                        }
-                        parse_state = 5;//帧残缺
-                        half_data_len = data_len + 17 + 1;//缓存了半帧，记录应有总长度
-                        temp_half_data_len = receive_len - frame_start - count;//缓存了半帧，记录现有长度
-                        for(uint32_t j = 0; j < temp_half_data_len + count; j++)
-                            parse_data_buff[j] = receive_data[j + frame_start];//[0,receive_len-1]
-                        LLOGD("parse_state = 5,前半帧count = %d",count);
-                        LLOGD("半帧数据应有长度=%d", half_data_len);
-                        LLOGD("半帧数据现有长度=%d", temp_half_data_len);
-                        LLOGD("有帧头没有帧尾，数据不完整，先缓存");
-                        pos = receive_len;
-                        // LLOGD("状态机parse_state = %d", parse_state);
-                        break;
-                    }
-                }
-            }//for
-        }
-        else//pos未找到帧头，继续查找
-        {
-            if(parse_state == 5)
-            {
-                //缓存了半帧
-                // LLOGD("状态机parse_state = %d", parse_state);
-                for(uint32_t i = 0; i < receive_len; i++) //帧头+魔数+数据长度+crc+id+flag（1+4+2+2+4+4=17）
-                {
-                    if(receive_data[i] == 0x7E) 
-                    {
-                        temp_frame_end = i;//找到帧尾
-                        uint8_t count = 0;
-                        for(uint32_t j = 0; j < temp_frame_end + 1; j++)
-                        {
-                            if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x02) {
-                                count++;
-                            }
-                            else if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x01) {
-                                count++;
-                            }
-                        }
-                        LLOGD("parse_state = 5,后半帧count = %d",count);
-                        LLOGD("后半帧数据,找到0x7e,位置 = %d", temp_frame_end);
-                        LLOGD("前半帧长度 = %d", temp_half_data_len);
-                        LLOGD("组合后的帧长度 = %d", half_data_len);
-                        if((temp_frame_end + 1 + temp_half_data_len - count) == half_data_len) //帧长度正确，减掉转义多出来的数据长度
-                        {
-                            frame_end = temp_frame_end;
-                            LLOGD("半包数据整合成功");
-                            pos = temp_frame_end + count + 1;
-                            for(uint32_t j = 0; j < frame_end + 1; j++)
-                                parse_data_buff[j + temp_half_data_len] = receive_data[j];
-                            parse_data(parse_data_buff, (half_data_len));
-                        }
-                        else
-                        {
-                            LLOGD("半包数据整合失败");
-                            for(uint32_t j = 0; j < (temp_half_data_len + receive_len); j++)
-                                parse_data_buff[j] = 0;
-                            pos = receive_len;
-                        }
-                        parse_state = 0;
-                        half_data_len = 0;
-                        temp_half_data_len = 0;
-                        break;//无论整合成功与失败都要跳出for循环，因为已经找到帧尾
-                    }
-                    else//parse_state=5且既没有帧头又没有帧尾
-                    {
-                        parse_state = 5;//帧依旧残缺
-                        pos = receive_len;
-                        uint8_t count = 0;
-                        for(uint32_t j = 0; j < receive_len; j++)
-                        {
-                            if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x02) {
-                                count++;
-                            }
-                            else if(receive_data[j] == 0x7D && receive_data[j + 1] == 0x01) {
-                                count++;
-                            }
-                        }
-                        for(uint32_t j = 0; j < receive_len; j++)
-                            parse_data_buff[temp_half_data_len + j] = receive_data[j];
-                        temp_half_data_len = temp_half_data_len - count + receive_len;//实际长度要减去转义多出来的数据长度
-                    }
-                }
-            }
-            else
-            {
-                if(pos < receive_len - 1) pos++;
-                else
-                {
-                    LLOGD("未找到帧头");
-                    pos++;
-                    // break;
-                }
-            }
-        }//pos未找到帧头，继续查找
-        // LLOGD("状态机parse_state = %d", parse_state);
-        // LLOGD("pos = %d", pos);
-        // luat_heap_free(pbuff);
-    }//while
-
-}
-#endif
-
 static void unpack_data(uint8_t* buff, size_t len)
 {
-    LLOGD("unpack_data: src len = %d", len);
+    // LLOGD("unpack_data: src len = %d", len);
     if (len < 2) {
         LLOGE("unpack_data: data too short");
         return; // 数据太短, 无法解析
@@ -345,23 +147,23 @@ static void unpack_data(uint8_t* buff, size_t len)
         }
     }
     if (unpacked_len < sizeof(airlink_link_data_t)) {
-        LLOGE("unpack_data: unpacked data too short, len %d", unpacked_len);
+        // LLOGE("unpack_data: unpacked data too short, len %d", unpacked_len);
         return; // 解包后的数据太短, 无法解析
     }
     airlink_link_data_t *link = NULL;
     link = luat_airlink_data_unpack(unpacked_data, unpacked_len);
     if (link == NULL) {
-        LLOGE("luat_airlink_data_unpack failed, unpacked_len %d", unpacked_len);
+        // LLOGE("luat_airlink_data_unpack failed, unpacked_len %d", unpacked_len);
         return; // 解析失败
     }
-    LLOGD("luat_airlink data unpacked, len: %d, data: %p", link->len, link->data);
+    // LLOGD("luat_airlink data unpacked, len: %d, data: %p", link->len, link->data);
     luat_airlink_on_data_recv(link->data, link->len);
 }
 
 #define UNPACK_BUFF_SIZE (8*1024)
 static uint8_t* rxbuf;
 static uint32_t rxoffset = 0;
-void on_airlink_uart_data_in(uint8_t* buff, size_t len) 
+void on_airlink_uart_data_in(uint8_t* buff, size_t len)
 {
     int ret = 0;
     size_t offset = 0;
@@ -418,6 +220,11 @@ void on_airlink_uart_data_in(uint8_t* buff, size_t len)
             end_offset = offset + 1;
             while (end_offset < rxoffset && rxbuf[end_offset] != 0x7E) {
                 end_offset++;
+                if(end_offset > 4096){
+                    rxoffset = 0;
+                    LLOGD("缓存数据超4k，仍未找到包尾，丢弃数据");
+                    break;
+                }
             }
             if (end_offset >= rxoffset) {
                 // 没有找到包尾, 等待下次数据
@@ -439,7 +246,7 @@ void on_airlink_uart_data_in(uint8_t* buff, size_t len)
     }
 }
 
-__USER_FUNC_IN_RAM__ static void uart_task(void *param)
+__USER_FUNC_IN_RAM__ static void uart_transfer_task(void *param)
 {
     int ret;
     luat_event_t event = {0};
@@ -447,40 +254,17 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
     uint8_t* ptr = NULL;
     size_t offset = 0;
     int uart_id;
-    luat_rtos_task_sleep(5); // 等5ms
-    uart_gpio_setup();
-    g_airlink_newdata_notify_cb = on_newdata_notify;
-    g_airlink_link_data_cb = on_link_data_notify;
     // 单个link data的长度最大是1600字节,极端情况下所有数据都要转义,那就是3200字节,所以这里预留4K
     uint8_t *pbuff = luat_heap_malloc(4*1024);
-    while (1)
+    event.id = 0;
+
+    while(1)
     {
-        uart_id = g_airlink_spi_conf.uart_id;
-        // LLOGD("uart_task:uart_id:%d", uart_id);
-        while (1) {
-            ret = luat_uart_read(uart_id, (char *)s_rxbuff, 1024);
-            // LLOGD("uart_task:uart read buff len:%d", ret);
-            if (ret <= 0) 
-            {
-                break;
-            }
-            else 
-            {
-                LLOGD("收到uart数据长度 %d", ret);
-                // luat_airlink_print_buff("uart_task:uart read buff", s_rxbuff, ret);
-                // 推送数据, 并解析处理
-                on_airlink_uart_data_in(s_rxbuff, ret);
-                // for(uint8_t j = 0; j < ret; j++)
-                // {
-                //     LLOGD("收到数据:%02x", s_rxbuff[j]);
-                // }
-            }
-        }
-        event.id = 0;
-        ret = luat_rtos_queue_recv(evt_queue, &event, sizeof(luat_event_t), 15*1000);//在evt_queue队列中复制数据到指定缓冲区event，阻塞等待60s
+        ret = luat_rtos_queue_recv(tx_evt_queue, &event, sizeof(luat_event_t), 15*1000);//在evt_queue队列中复制数据到指定缓冲区event，阻塞等待60s
         //LLOGD("收到airlink数据事件 ret:%d, id:%d", ret, event.id);
         record_statistic(event);
         while (1) {
+            uart_id = g_airlink_spi_conf.uart_id;
             // 有数据, 要处理了
             item.len = 0;
             luat_airlink_cmd_recv_simple(&item);//从（发送）队列里取出数据存在item中
@@ -509,14 +293,8 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
                     }
                 }
                 s_txbuff[offset++] = 0x7E;
-                //LLOGD("发送数据长度:%d, cmd:%p", offset, item.cmd);
                 luat_uart_write(uart_id, (const char *)s_txbuff, offset);
-                LLOGD ("发送数据长度:%d", offset);
-                // for(uint8_t i = 0; i < offset; i++)
-                // {
-                //     LLOGD("发送数据:%02x", s_txbuff[i]);
-                // }
-                // luat_airlink_print_buff("uart_task:uart transfer buff", s_txbuff, offset);
+                // LLOGD ("发送数据长度:%d", offset);
             }
             else {
                 break; // 没有数据了, 退出循环
@@ -524,27 +302,83 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
         }
     }
 }
-
+__USER_FUNC_IN_RAM__ static void uart_receive_task(void *param)
+{
+    int ret;
+    luat_event_t event = {0};
+    int uart_id;
+    event.id = 0;
+    while (1)
+    {
+        ret = luat_rtos_queue_recv(rx_evt_queue, &event, sizeof(luat_event_t), 15*1000);//在evt_queue队列中复制数据到指定缓冲区event，阻塞等待60s
+        //LLOGD("收到airlink数据事件 ret:%d, id:%d", ret, event.id);
+        record_statistic(event);
+        while (1) { 
+            uart_id = g_airlink_spi_conf.uart_id;
+            ret = luat_uart_read(uart_id, (char *)s_rxbuff, 1024);
+            // LLOGD("uart_task:uart read buff len:%d", ret);
+            if (ret <= 0)
+            {
+                break;
+            }
+            else
+            {
+                // LLOGD("收到uart数据长度 %d", ret);
+                // 推送数据, 并解析处理
+                on_airlink_uart_data_in(s_rxbuff, ret);
+            }
+        }
+    }
+}
 void luat_airlink_start_uart(void)
 {
     int ret = 0;
-    if (g_uart_task != NULL)
+    
+    ret = luat_rtos_queue_create(&tx_evt_queue, 4 * 1024, sizeof(luat_event_t));
+    if (ret) {
+        LLOGW("创建tx_evt_queue ret:%d", ret);
+    }
+    ret = luat_rtos_queue_create(&rx_evt_queue, 4 * 1024, sizeof(luat_event_t));
+    if (ret) {
+        LLOGW("创建rx_evt_queue ret:%d", ret);
+    }
+    luat_rtos_task_sleep(5);
+    uart_gpio_setup();
+    g_airlink_newdata_notify_cb = on_newdata_notify;
+    g_airlink_link_data_cb = on_link_data_notify;
+
+    luat_airlink_uart_transfer_task();
+    luat_airlink_uart_receive_task();
+}
+
+void luat_airlink_uart_transfer_task(void)
+{
+    int ret = 0;
+    if (g_uart_transfer_task != NULL)
     {
-        // TODO 支持多个UART?
-        LLOGE("UART任务已经启动过了!!! uart %d", g_airlink_spi_conf.uart_id);
+        LLOGE("UART TX任务已经启动过了!!! uart %d", g_airlink_spi_conf.uart_id);
         return;
     }
-
     s_txbuff = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, TEST_BUFF_SIZE);
+    ret = luat_rtos_task_create(&g_uart_transfer_task, 8 * 1024, 50, "uart_transfer", uart_transfer_task, NULL, 0);
+    if (ret) {
+        LLOGW("创建uart_transfer_task ret:%d", ret);
+    }
+}
+
+void luat_airlink_uart_receive_task(void)
+{
+    int ret = 0;
+    if (g_uart_receive_task != NULL)
+    {
+        LLOGE("UART RX任务已经启动过了!!! uart %d", g_airlink_spi_conf.uart_id);
+        return;
+    }
     s_rxbuff = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, TEST_BUFF_SIZE);
     rxbuf = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, UNPACK_BUFF_SIZE);
 
-    ret = luat_rtos_queue_create(&evt_queue, 4 * 1024, sizeof(luat_event_t));
-    if (ret) {
-        LLOGW("创建evt_queue ret:%d", ret);
-    }
-    ret = luat_rtos_task_create(&g_uart_task, 8 * 1024, 50, "uart", uart_task, NULL, 0);
+    ret = luat_rtos_task_create(&g_uart_receive_task, 8 * 1024, 52, "uart_receive", uart_receive_task, NULL, 0);
     if (ret) {
-        LLOGW("创建uart_task ret:%d", ret);
+        LLOGW("创建uart_receive_task ret:%d", ret);
     }
 }

luat/demo/airlink/uart_http/main.lua

@@ -29,16 +29,16 @@ sys.taskInit(function()
 
 end)
 
--- sys.taskInit(function()
---     while 1 do
---         -- 发送给对端设备
---         local data = rtos.bsp() .. " " .. os.date() .. " " .. (mobile and mobile.imei() or "")
---         log.info("client 发送数据给sever设备", data, "当前airlink状态", airlink.ready())
---         airlink.sdata(data)
---         airlink.test(1000) -- 要测试高速连续发送的情况
---         sys.wait(1000)
---     end
--- end)
+sys.taskInit(function()
+    while 1 do
+        -- 发送给对端设备
+        local data = rtos.bsp() .. " " .. os.date() .. " " .. (mobile and mobile.imei() or "")
+        log.info("client 发送数据给sever设备", data, "当前airlink状态", airlink.ready())
+        airlink.sdata(data)
+        -- airlink.test(1000) -- 要测试高速连续发送的情况
+        sys.wait(1000)
+    end
+end)
 
 sys.taskInit(function()
     -- sys.waitUntil("IP_READY")
@@ -63,10 +63,6 @@ sys.taskInit(function()
     end
 end)
 
-sys.subscribe("AIRLINK_SDATA", function(data)
-    log.info("client 收到AIRLINK_SDATA!!", data)
-end)
-
 
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句

luat/demo/airlink/uart_sdata/main.lua

@@ -25,17 +25,14 @@ sys.taskInit(function()
     sys.wait(100)
     --等待IP_READY事件
     sys.waitUntil("IP_READY", 1000)
-    -- netdrv.napt(socket.LWIP_GP)
-    -- netdrv.debug(0, true)
-    -- dnsproxy.setup(socket.LWIP_USER0,socket.LWIP_GP)
-    -- while 1 do
-    --     -- 发送给对端设备
-    --     local data = rtos.bsp() .. " " .. os.date() .. " " .. (mobile and mobile.imei() or "")
-    --     log.info("sever 发送数据给client设备", data, "当前airlink状态", airlink.ready())
-    --     airlink.sdata(data)
-    --     airlink.test(1000) -- 要测试高速连续发送的情况
-    --     sys.wait(1000)
-    -- end
+    while 1 do
+        -- 发送给对端设备
+        local data = rtos.bsp() .. " " .. os.date() .. " " .. (mobile and mobile.imei() or "")
+        log.info("sever 发送数据给client设备", data, "当前airlink状态", airlink.ready())
+        airlink.sdata(data)
+        -- airlink.test(1000) -- 要测试高速连续发送的情况
+        sys.wait(1000)
+    end
 end)
 
 sys.taskInit(function()
@@ -54,13 +51,6 @@ sys.taskInit(function()
     else
         log.info("airlink", "Client mode")
     end
-    -- while 1 do
-    --     sys.wait(500)
-    --     local code, headers, body = http.request("GET", "https://httpbin.air32.cn/bytes/2048", nil, nil, {adapter=socket.LWIP_USER0,timeout=3000}).wait()
-    --     log.info("http", code, body and #body)
-    --     -- log.info("lua", rtos.meminfo())
-    --     -- log.info("sys", rtos.meminfo("sys"))
-    -- end
 end)
 
 --订阅IP_READY事件，打印收到的信息
@@ -68,10 +58,6 @@ sys.subscribe("IP_READY", function(id,ip)
     log.info("收到IP_READY!!", id,ip)
 end)
 
-sys.subscribe("AIRLINK_SDATA", function(data)
-    log.info("sever 收到AIRLINK_SDATA!!", data)
-end)
-
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()