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

components/airlink/src/task/luat_airlink_uart_task.c

@@ -34,6 +34,7 @@ static luat_rtos_task_handle g_uart_task;
 static luat_rtos_queue_t 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};
@@ -87,33 +88,357 @@ __USER_FUNC_IN_RAM__ static void on_link_data_notify(airlink_link_data_t* link)
     }
 }
 
-static void on_uart_data_in(uint8_t* buff, size_t len) {
+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);
+    // 收到数据后去除帧头帧尾和魔数，遇到0x7E/0x7D 要转义
+    uint8_t* parse_buff = buff;
+    size_t parse_len = len - 2;
+    memcpy(parse_buff, buff+1, parse_len);//去帧头帧尾
+    // //反转义
+    for(int i = 0; i < parse_len; i++)
+    {
+        if(parse_buff[i] == 0x7D && parse_buff[i + 1] == 0x02) {
+            parse_buff[i] = 0x7E;
+            parse_len--;
+        }
+        else if(parse_buff[i] == 0x7D && parse_buff[i + 1] == 0x01) {
+            parse_buff[i] = 0x7D;
+            parse_len--;
+        }
+    }
+    airlink_link_data_t *link = luat_airlink_data_unpack(parse_buff, parse_len);
+    if (link == NULL) 
+    {
+        LLOGE("luat_airlink_data_unpack failed len %d", parse_len);
+        return;
+    }
+    // LLOGD("luat_airlink data unpacked, len: %d, data: %p", link->len, link->data);
+    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;
-    size_t receive_len = len-2;
-    memcpy(receive_data, buff+1, receive_len);//去帧头帧尾
-    for(int i = 0; i < receive_len; i++)
+    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[i] == 0x7D && receive_data[i + 1] == 0x02) {
-            receive_data[i] = 0x7E;
-            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 if(receive_data[i] == 0x7D && receive_data[i + 1] == 0x01) {
-            receive_data[i] = 0x7D;
-            receive_len--;
+        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);
+    if (len < 2) {
+        LLOGE("unpack_data: data too short");
+        return; // 数据太短, 无法解析
+    }
+    // 存储最终数据到s_rxbuff
+    uint8_t* unpacked_data = s_rxbuff;
+    size_t unpacked_len = 0;
+    for (size_t i = 0; i < len; i++) {
+        if (buff[i] == 0x7D) {
+            // 转义字符, 下一个字节是转义码
+            if (i + 1 < len) {
+                if (buff[i + 1] == 0x02) {
+                    unpacked_data[unpacked_len++] = 0x7E; // 转义为0x7E
+                } else if (buff[i + 1] == 0x01) {
+                    unpacked_data[unpacked_len++] = 0x7D; // 转义为0x7D
+                }
+                i++; // 跳过下一个字节
+            }
+        } else {
+            unpacked_data[unpacked_len++] = buff[i]; // 普通数据直接复制
         }
     }
-    airlink_link_data_t *link = luat_airlink_data_unpack(receive_data, receive_len);
+    if (unpacked_len < sizeof(airlink_link_data_t)) {
+        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 len %d", receive_len);
-        return;
+        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);
     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) 
+{
+    int ret = 0;
+    size_t offset = 0;
+    size_t end_offset = 0;
+    // 首先, 输入的数据是否为0, 也可能是太长的数据
+    if (len == 0) {
+        return; // 不需要处理
+    }
+    if (rxbuf == NULL) {
+        // 分配内存
+        rxbuf = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, UNPACK_BUFF_SIZE);
+        if (rxbuf == NULL) {
+            LLOGE("无法分配内存给rxbuf");
+            return; // 内存分配失败
+        }
+    }
+    if (s_rxbuff == NULL) {
+        // 分配内存给s_rxbuff
+        s_rxbuff = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, UNPACK_BUFF_SIZE);
+        if (s_rxbuff == NULL) {
+            LLOGE("无法分配内存给s_rxbuff");
+            return; // 内存分配失败
+        }
+    }
+    // 按协议要求, 单个包的最大长度, 应该是 2 + 1600*2 + 2 = 3206 字节
+    // 所以, 8k完全可以放入2个包
+    memcpy(rxbuf + rxoffset, buff, len);
+    rxoffset += len;
+
+    // 首先, 检查首个字节是不是0x7E, 如果不是, 那么就需要查找包头, 直至找到0x7E
+    if (rxbuf[0] != 0x7E) {
+        offset = 1;
+        // 如果不是, 那么就需要查找包头, 直至找到0x7E
+        while (offset < rxoffset && rxbuf[offset] != 0x7E) {
+            offset++;
+        }
+        if (offset >= rxoffset) {
+            LLOGW("没有找到包头, 清空当前数据, 等待下次数据 %d", rxoffset);
+            rxoffset = 0;
+            return;
+        }
+        // 找到包头, 移动数据到前面
+        if (offset > 1) {
+            memmove(rxbuf, rxbuf + offset, rxoffset - offset);
+            rxoffset -= offset;
+        }
+    }
+
+    offset = 0;
+    while (rxoffset - offset >= 2) {
+        // 搜索包头
+        if (rxbuf[offset] == 0x7E) {
+            // 找到包头, 继续查找包尾
+            end_offset = offset + 1;
+            while (end_offset < rxoffset && rxbuf[end_offset] != 0x7E) {
+                end_offset++;
+            }
+            if (end_offset >= rxoffset) {
+                // 没有找到包尾, 等待下次数据
+                break;
+            }
+            // 找到包尾, 解析数据
+            size_t data_len = end_offset - offset - 1; // 包头和包尾不算在内
+            // 反转义数据
+            if (data_len > 1) {
+                unpack_data(rxbuf + offset + 1, data_len); // 包头和包尾不算在内
+            }
+            // 移动剩余数据到前面
+            memmove(rxbuf, rxbuf + end_offset + 1, rxoffset - end_offset - 1);
+            rxoffset -= (end_offset + 1 - offset);
+        } else {
+            // 没有找到包头, 移动一个字节
+            offset++;
+        }
+    }
+}
+
 __USER_FUNC_IN_RAM__ static void uart_task(void *param)
 {
     int ret;
@@ -133,15 +458,22 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
         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, TEST_BUFF_SIZE);
+            ret = luat_uart_read(uart_id, (char *)s_rxbuff, 1024);
             // LLOGD("uart_task:uart read buff len:%d", ret);
-            if (ret <= 0) {
+            if (ret <= 0) 
+            {
                 break;
             }
-            else {
-                // LLOGD("收到uart数据长度 %d", ret);
+            else 
+            {
+                LLOGD("收到uart数据长度 %d", ret);
+                // luat_airlink_print_buff("uart_task:uart read buff", s_rxbuff, ret);
                 // 推送数据, 并解析处理
-                on_uart_data_in(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;
@@ -152,7 +484,7 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
             // 有数据, 要处理了
             item.len = 0;
             luat_airlink_cmd_recv_simple(&item);//从（发送）队列里取出数据存在item中
-            //LLOGD("队列数据长度:%d, cmd:%p", item.len, item.cmd);
+            // LLOGD("队列数据长度:%d, cmd:%p", item.len, item.cmd);
             if (item.len > 0 && item.cmd != NULL)
             {
                 // 0x7E 开始, 0x7D 结束, 遇到 0x7E/0x7D 要转义
@@ -166,21 +498,12 @@ __USER_FUNC_IN_RAM__ static void uart_task(void *param)
                     if (ptr[i] == 0x7E) {
                         s_txbuff[offset++] = 0x7D;
                         s_txbuff[offset++] = 0x02;
-                        if(i < item.len + sizeof(airlink_link_data_t) - 1)  i++;
-                        else 
-                        {
-                            break;
-                        }
                     }
                     else if (ptr[i] == 0x7D) {
                         s_txbuff[offset++] = 0x7D;
                         s_txbuff[offset++] = 0x01;
-                        if(i < item.len + sizeof(airlink_link_data_t) - 1)  i++;
-                        else 
-                        {
-                            break;
-                        }
                     }
+                    else
                     {
                         s_txbuff[offset++] = ptr[i];
                     }
@@ -188,6 +511,12 @@ __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);
             }
             else {
                 break; // 没有数据了, 退出循环
@@ -208,6 +537,7 @@ void luat_airlink_start_uart(void)
 
     s_txbuff = luat_heap_opt_malloc(AIRLINK_MEM_TYPE, TEST_BUFF_SIZE);
     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) {

components/network/adapter/luat_lib_socket.c

@@ -48,7 +48,7 @@ end)
 static int l_socket_local_ip(lua_State *L)
 {
 	luat_ip_addr_t local_ip, net_mask, gate_way, ipv6;
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY)
 	{
 		return 0;
@@ -209,7 +209,7 @@ param3为消息对应的参数，目前只有0和-1，0表示成功或者可能
 */
 static int l_socket_create(lua_State *L)
 {
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY)
 	{
 		lua_pushnil(L);
@@ -1062,7 +1062,7 @@ static int l_socket_set_dns(lua_State *L)
 {
 #ifdef LUAT_USE_LWIP
 	char ip_buf[68];
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY)
 	{
 		lua_pushboolean(L, 0);
@@ -1088,7 +1088,7 @@ static int l_socket_set_dns(lua_State *L)
 	    ipaddr_aton(ip_buf, &ip_addr);
 	}
 #else
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY)
 	{
 		lua_pushboolean(L, 0);
@@ -1266,6 +1266,7 @@ NO_REMOTE_IP:
 @api socket.dft(id)
 @int 默认适配器编号,若不传,则打包获取
 @return int 默认适配器编号
+@return int 最后一个注册的适配器编号(2025.7.25新增)
 @usage
 -- 本函数于 2025.1.6 新增
 -- 获取当前默认适配器编号
@@ -1273,6 +1274,10 @@ local id = socket.dft()
 
 -- 设置默认适配器编号
 socket.dft(socket.LWIP_ETH)
+
+-- 获取当前默认适配器编号, 及最后一个注册的适配器编号
+local id, last_id = socket.dft()
+log.info("当前默认适配器编号", id, "最后一个注册的适配器编号", last_id)
 */
 static int l_socket_default(lua_State *L) {
 	uint8_t id = 0;
@@ -1282,8 +1287,9 @@ static int l_socket_default(lua_State *L) {
 			network_register_set_default(id);
 		}
 	}
-	lua_pushinteger(L, network_get_last_register_adapter());
-	return 1;
+	lua_pushinteger(L, network_register_get_default());
+	lua_pushinteger(L, network_get_last_register_adapter_real());
+	return 2;
 }
 
 #include "rotable2.h"

components/network/adapter/luat_network_adapter.c

@@ -1310,6 +1310,11 @@ int network_get_last_register_adapter(void)
 
 void network_register_set_default(uint8_t adapter_index)
 {
+	int dft = network_register_get_default();
+	if (dft != -1 && dft != adapter_index)
+	{
+		DBG_Printf("change from %d to %d", dft, adapter_index);
+	}
 	prv_network.default_adapter_index = adapter_index;
 }
 
@@ -2803,4 +2808,18 @@ void network_set_ip_ipv4(luat_ip_addr_t *ip, uint32_t ipv4)
 	ip->ipv4 = ipv4;
 #endif
 }
+
+
+int network_get_last_register_adapter_real(void)
+{
+	if (!prv_network.is_init) return -1;
+	return prv_network.last_adapter_index;
+}
+
+int network_register_get_default(void) {
+	if (!prv_network.is_init) return -1;
+	if (prv_network.default_adapter_index != -1) return prv_network.default_adapter_index;
+	return prv_network.last_adapter_index; 
+}
+
 #endif

components/network/adapter/luat_network_adapter.h

@@ -334,6 +334,12 @@ int network_register_adapter(uint8_t adapter_index, network_adapter_info *info,
  */
 void network_register_set_default(uint8_t adapter_index);
 
+/**
+ * 获取默认适配器
+ * @param adapter_index 网卡适配器序号 NW_ADAPTER_INDEX_XXX
+ */
+int network_register_get_default(void);
+
 /**
  * 设置某个网卡适配器的DNS服务器地址
  * @param adapter_index 网卡适配器序号 NW_ADAPTER_INDEX_XXX
@@ -802,5 +808,8 @@ uint8_t network_ip_is_vaild_ipv4(luat_ip_addr_t *ip);
 void network_set_ip_ipv4(luat_ip_addr_t *ip, uint32_t ipv4);
 
 network_adapter_info* network_adapter_fetch(int id, void** userdata);
+
+// 获取真正的最后一个注册的网卡适配器序号, network_get_last_register_adapter用的地方太多了,已经改不了
+int network_get_last_register_adapter_real(void);
 #endif
 // #endif

components/network/errdump/luat_lib_errdump.c

@@ -238,7 +238,7 @@ static int32_t l_errdump_callback(lua_State *L, void* ptr)
     switch(msg->arg1)
     {
     case LUAT_ERRDUMP_CONNECT:
-    	econf.netc = network_alloc_ctrl(network_get_last_register_adapter());
+    	econf.netc = network_alloc_ctrl(network_register_get_default());
     	if (!econf.netc)
     	{
     		LLOGE("no socket, errdump fail, after %d second retry", econf.upload_period);

components/network/httpsrv/src/luat_lib_httpsrv.c

@@ -70,7 +70,7 @@ static int l_httpsrv_start(lua_State *L) {
         LLOGW("httpsrv need callback function!!!");
         return 0;
     }
-    uint8_t adapter_index = luaL_optinteger(L, 3, network_get_last_register_adapter());
+    uint8_t adapter_index = luaL_optinteger(L, 3, network_register_get_default());
     luat_netdrv_t* drv = luat_netdrv_get(adapter_index);
     if (drv == NULL || drv->netif == NULL) {
         LLOGW("该网络还没准备好 %d", adapter_index);
@@ -125,7 +125,7 @@ static int l_httpsrv_start(lua_State *L) {
 */
 static int l_httpsrv_stop(lua_State *L) {
     int port = luaL_checkinteger(L, 1);
-    uint8_t adapter_index = luaL_optinteger(L, 3, network_get_last_register_adapter());
+    uint8_t adapter_index = luaL_optinteger(L, 3, network_register_get_default());
     for (size_t i = 0; i < LUAT_HTTPSRV_COUNT; i++)
     {
         if (srvs[i].port == port && srvs[i].adapter == adapter_index) {

components/network/libemqtt/luat_lib_mqtt.c

@@ -350,7 +350,7 @@ mqttc = mqtt.create(nil,"120.55.137.106", 8883, {
 */
 static int l_mqtt_create(lua_State *L) {
 	int ret = 0;
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY){
 		LLOGE("尚无已注册的网络适配器");
 		return 0;

components/network/libftp/luat_lib_ftp.c

@@ -64,7 +64,7 @@ static int l_ftp_login(lua_State *L) {
 	int result = 0;
 	size_t len = 0;
 	luat_ftp_tls_t* luat_ftp_tls = NULL;
-	uint8_t adapter = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	uint8_t adapter = luaL_optinteger(L, 1, network_register_get_default());
 	const char *ip_addr = luaL_checklstring(L, 2, &len);
 	uint16_t port = luaL_optinteger(L, 3, 21);
 	const char *username = luaL_optlstring(L, 4, "",&len);

components/network/libhttp/luat_http_client.c

@@ -829,7 +829,7 @@ luat_http_ctrl_t* luat_http_client_create(luat_http_cb cb, void *user_param, int
 	}
 	else
 	{
-		http_ctrl->netc = network_alloc_ctrl(network_get_last_register_adapter());
+		http_ctrl->netc = network_alloc_ctrl(network_register_get_default());
 	}
 	if (!http_ctrl->netc)
 	{

components/network/libhttp/luat_lib_http.c

@@ -145,9 +145,9 @@ static int l_http_request(lua_State *L) {
 	if (lua_istable(L, 5)){
 		lua_pushstring(L, "adapter");
 		if (LUA_TNUMBER == lua_gettable(L, 5)) {
-			adapter_index = luaL_optinteger(L, -1, network_get_last_register_adapter());
+			adapter_index = luaL_optinteger(L, -1, network_register_get_default());
 		}else{
-			adapter_index = network_get_last_register_adapter();
+			adapter_index = network_register_get_default();
 		}
 		lua_pop(L, 1);
 
@@ -217,7 +217,7 @@ static int l_http_request(lua_State *L) {
 			http_ctrl->http_cb_userdata = (void*)luaL_ref(L, LUA_REGISTRYINDEX);
 		}
 	}else{
-		adapter_index = network_get_last_register_adapter();
+		adapter_index = network_register_get_default();
 	}
 #ifdef LUAT_USE_FOTA
 	if (http_ctrl->isfota == 1 && http_ctrl->is_download == 1){

components/network/libsntp/luat_lib_sntp.c

@@ -129,7 +129,7 @@ int l_sntp_get(lua_State *L) {
         LLOGI("sntp is running");
         return 0;
     }
-    int adapter_index = luaL_optinteger(L, 2, network_get_last_register_adapter());
+    int adapter_index = luaL_optinteger(L, 2, network_register_get_default());
     int ret = ntp_get(adapter_index);
     if (ret) {
 #ifdef __LUATOS__

components/network/libsntp/luat_sntp.c

@@ -331,7 +331,7 @@ int32_t luat_sntp_callback(void *data, void *param) {
 
 int ntp_get(int adapter_index){
     if (-1 == adapter_index){
-        adapter_index = network_get_last_register_adapter();
+        adapter_index = network_register_get_default();
     }
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY){
 		return -1;

components/network/netdrv/src/luat_netdrv_napt.c

@@ -169,7 +169,7 @@ __USER_FUNC_IN_RAM__ int luat_netdrv_napt_pkg_input(int id, uint8_t* buff, size_
         ret = luat_napt_udp_handle(&ctx);
         break;
     default:
-        LLOGD("不是tcp/udp/icmp包, 不需要执行napt");
+        // LLOGD("不是tcp/udp/icmp包, 不需要执行napt");
         return 0;
     }
     // uint64_t tend = luat_mcu_tick64();

components/network/websocket/luat_lib_websocket.c

@@ -207,7 +207,7 @@ wsc = websocket.create(nil,"wss://air32.cn/abc")
 static int l_websocket_create(lua_State *L)
 {
 	int ret = 0;
-	int adapter_index = luaL_optinteger(L, 1, network_get_last_register_adapter());
+	int adapter_index = luaL_optinteger(L, 1, network_register_get_default());
 	if (adapter_index < 0 || adapter_index >= NW_ADAPTER_QTY)
 	{
 		return 0;

components/sms/binding/luat_lib_sms.c

@@ -20,12 +20,12 @@
 
 void luat_str_fromhex(char* str, size_t len, char* buff) ;
 
+#include "luat_sms.h"
+
 #ifndef bool
-#define bool uint8_t
+#define bool    uint8_t
 #endif
 
-#include "luat_sms.h"
-
 #define LUAT_LOG_TAG "sms"
 #include "luat_log.h"
 static int lua_sms_ref = 0;
@@ -39,118 +39,37 @@ typedef struct long_sms
     char buff[1];
 }long_sms_t;
 
-typedef struct 
-{
-    size_t phone_len;           // 电话号码长度
-    size_t payload_len;          // 待编码的数据长度
-    const char *phone;          // 电话号码
-    uint8_t pdu_buf[320];       // 组包后的PDU短信
-    uint8_t payload_buf[200];    // 编码后的短信数据
-    uint8_t auto_phone;         // 是否自动处理电话号码
-    uint8_t maxNum;             // 短信最大条数， 长短信用
-    uint8_t seqNum;             // 当前短信序号
-}luat_sms_pdu_packet_t;
-
-#define LONG_SMS_CMAX (128)
-static long_sms_t* lngbuffs[LONG_SMS_CMAX];
-// static char* longsms = NULL;
-// static int longsms_refNum = -1;
-
-enum{
-	SMS_EVENT_SEND_RET = 0,
-};
-luat_rtos_task_handle sms_send_task_handle = NULL;
 typedef struct long_sms_send
 {
     size_t payload_len;
-    size_t phone_len;
-    const char *phone;
     uint8_t *payload;
-    uint8_t auto_phone;
 }long_sms_send_t;
 
-static uint8_t idx = 254;
-
-static uint64_t long_sms_send_idp;
-
-
-static void ucs2char(char* source, size_t size, char* dst2, size_t* outlen) {
-    char buff[size + 2];
-    memset(buff, 0, size + 2);
-    luat_str_fromhex(source, size, buff);
-    //LLOGD("sms %s", source);
-    uint16_t* tmp = (uint16_t*)buff;
-    char* dst = dst2;
-    // size_t tmplen = origin_len / 2;
-    // size_t dstoff = 0;
-    uint16_t unicode = 0;
-    size_t dstlen = 0;
-    while (1) {
-        unicode = *tmp ++;
-        unicode = ((unicode >> 8) & 0xFF) + ((unicode & 0xFF) << 8);
-        //LLOGD("unicode %04X", unicode);
-        if (unicode == 0)
-            break; // 终止了
-        if (unicode <= 0x0000007F) {
-            dst[dstlen++] = (unicode & 0x7F);
-            continue;
-        }
-        if (unicode <= 0x000007FF) {
-            dst[dstlen++]	= ((unicode >> 6) & 0x1F) | 0xC0;
-		    dst[dstlen++] 	= (unicode & 0x3F) | 0x80;
-            continue;
-        }
-        if (unicode <= 0x0000FFFF) {
-            dst[dstlen++]	= ((unicode >> 12) & 0x0F) | 0xE0;
-		    dst[dstlen++]	= ((unicode >>  6) & 0x3F) | 0x80;
-		    dst[dstlen++]	= (unicode & 0x3F) | 0x80;
-            //LLOGD("why? %02X %02X %02X", ((unicode >> 12) & 0x0F) | 0xE0, ((unicode >>  6) & 0x3F) | 0x80, (unicode & 0x3F) | 0x80);
-            continue;
-        }
-        break;
-    }
-    *outlen = dstlen;
-    //LLOGD("ucs2char %d", dstlen);
-}
 
-static int utf82ucs2(char* source, size_t source_len, char* dst, size_t dstlen, size_t* outlen) {
-    uint16_t unicode = 0;
-    size_t tmplen = 0;
-    for (size_t i = 0; i < source_len; i++)
+
+#define LONG_SMS_CMAX (128)
+
+static long_sms_t* lngbuffs[LONG_SMS_CMAX];
+static luat_sms_pdu_packet_t g_s_sms_pdu_packet = {0};
+static long_sms_send_t g_s_sms_send = {0};
+static uint8_t ref_idx = 254;
+static uint64_t long_sms_send_idp = 0;
+
+
+
+static int32_t l_long_sms_send_callback(lua_State *L, void* ptr){
+    rtos_msg_t* msg = (rtos_msg_t*)lua_topointer(L, -1);
+    if (msg->arg1)
     {
-        if(tmplen >= dstlen) {
-            LLOGE("tmplen >= dstlen index: %d, tmplen: %d, dstlen: %d", i, tmplen, dstlen);
-            return -1;
-        }
-        // 首先是不是单字节
-        if (source[i] & 0x80) {
-            // 非ASCII编码
-            if (source[i] && 0xE0) { // 1110xxxx 10xxxxxx 10xxxxxx
-                unicode = ((source[i] & 0x0F) << 12) + ((source[i+1] & 0x3F) << 6) + (source[i+2] & 0x3F);
-                dst[tmplen++] = (unicode >> 8) & 0xFF;
-                dst[tmplen++] = unicode & 0xFF;
-                i+=2;
-                continue;
-            }
-            if (source[i] & 0xC0) { // 110xxxxx 10xxxxxx
-                unicode = ((source[i] & 0x1F) << 6) + (source[i+1] & 0x3F);
-                dst[tmplen++] = (unicode >> 8) & 0xFF;
-                dst[tmplen++] = unicode & 0xFF;
-                i++;
-                continue;
-            }
-            LLOGE("bat utf8 string");
-            return -1;
-        }
-        // 单个ASCII字符, 但需要扩展到2位
-        else {
-            // ASCII编码
-            dst[tmplen++] = 0x00;
-            dst[tmplen++] = source[i];
-            continue;
-        }
+        lua_pushboolean(L, 0);
+    }
+    else
+    {
+        lua_pushboolean(L, 1);
     }
-    *outlen = tmplen;
+    luat_cbcwait(L, long_sms_send_idp, 1);
+    long_sms_send_idp = 0;
+    g_s_sms_pdu_packet.maxNum = 0;             // 通过sms.sendLong发送的短信，需要在回调里确定发送结束
     return 0;
 }
 
@@ -344,14 +263,76 @@ void luat_sms_recv_cb(uint32_t event, void *param)
 
 void luat_sms_send_cb(int ret)
 {
-    if(long_sms_send_idp) {
-        LLOGE("send cb: %d", ret);
-        luat_rtos_event_send(sms_send_task_handle, SMS_EVENT_SEND_RET, ret, 0, 0, 0);
+    // 当前没有短信在发送，应该不会产生这个回调吧?
+    if (!g_s_sms_pdu_packet.maxNum) {
+        return;
+    }
+    rtos_msg_t msg = {
+        .handler = l_long_sms_send_callback,
+        .arg1 = 0,
+        .arg2 = 0
+    };
+    // 发送失败
+    if (ret) {
+        // 长短信发送失败
+        if (long_sms_send_idp) {
+            msg.arg1 = 1;
+            luat_msgbus_put(&msg, 0);
+        } else {
+            // 通过sms.send发送的短信，这里可以直接判断发送结束
+            g_s_sms_pdu_packet.maxNum = 0;
+        }
+        if (g_s_sms_send.payload != NULL) {
+            luat_heap_free(g_s_sms_send.payload);
+            g_s_sms_send.payload = NULL;
+        }
+        return;
+    }
+    LLOGE("long sms callback seqNum = %d", g_s_sms_pdu_packet.seqNum);
+    // 全部短信发送完成
+    if (g_s_sms_pdu_packet.seqNum == g_s_sms_pdu_packet.maxNum) {
+        if (long_sms_send_idp) {
+            msg.arg1 = 0;
+            luat_msgbus_put(&msg, 0);
+        } else {
+            g_s_sms_pdu_packet.maxNum = 0;
+        }
+
+        if (g_s_sms_send.payload != NULL) {
+            luat_heap_free(g_s_sms_send.payload);
+            g_s_sms_send.payload = NULL;
+        }
+        return;
+    }
+
+    // 长短信继续发送
+    g_s_sms_pdu_packet.seqNum++;
+
+    if (g_s_sms_send.payload_len - (g_s_sms_pdu_packet.seqNum - 1) * LUAT_SMS_LONG_MSG_PDU_SIZE <= LUAT_SMS_LONG_MSG_PDU_SIZE) {
+        memcpy(g_s_sms_pdu_packet.payload_buf, g_s_sms_send.payload + (g_s_sms_pdu_packet.seqNum - 1) * LUAT_SMS_LONG_MSG_PDU_SIZE, g_s_sms_send.payload_len - (g_s_sms_pdu_packet.seqNum - 1) * LUAT_SMS_LONG_MSG_PDU_SIZE);
+        g_s_sms_pdu_packet.payload_len = g_s_sms_send.payload_len - (g_s_sms_pdu_packet.seqNum - 1) * LUAT_SMS_LONG_MSG_PDU_SIZE ;
+    } else {
+        memcpy(g_s_sms_pdu_packet.payload_buf, g_s_sms_send.payload + (g_s_sms_pdu_packet.seqNum - 1) * LUAT_SMS_LONG_MSG_PDU_SIZE, LUAT_SMS_LONG_MSG_PDU_SIZE);
+        g_s_sms_pdu_packet.payload_len = LUAT_SMS_LONG_MSG_PDU_SIZE;
+    }
+    
+    int len = luat_sms_pdu_packet(&g_s_sms_pdu_packet);
+    ret = luat_sms_send_msg_v2(g_s_sms_pdu_packet.pdu_buf, len);
+    // 发送失败了
+    if (ret) {
+        // 长短信接口
+        if(long_sms_send_idp) {
+            msg.arg1 = 0;
+            luat_msgbus_put(&msg, 0);
+        } else {
+            g_s_sms_pdu_packet.maxNum = 0;
+        }
     }
+    return;
 }
 
 /*
-发送短信
+异步发送短信
 @api sms.send(phone, msg, auto_phone_fix)
 @string 电话号码,必填
 @string 短信内容,必填
@@ -375,8 +356,14 @@ static int l_sms_send(lua_State *L) {
     if (lua_isboolean(L, 3) && !lua_toboolean(L, 3)) {
         auto_phone = 0;
     }
+    
     int ret = 0;
-    char phone_buff[32] = {0};
+
+    // 当前有其他地方在发送短信
+    if (g_s_sms_pdu_packet.maxNum) {
+        LLOGE("sms is busy");
+        return 0;
+    }
 
     if (payload_len == 0) {
         LLOGE("sms is emtry");
@@ -397,228 +384,58 @@ static int l_sms_send(lua_State *L) {
         return 0;
     }
     memset(ucs2_buf, 0x00, payload_len * 3);
-    ret = utf82ucs2(payload, payload_len, ucs2_buf, payload_len * 3, &outlen);
-    if (ret != 0) {
-        LLOGE("utf82ucs2 encode fail");
-        luat_heap_free(ucs2_buf);
-        return 0;
-    }
 
-    if(outlen > 140)
-    {
-        LLOGE("sms is too long %d > 140", outlen);
-        luat_heap_free(ucs2_buf);
-        return 0;
-    }
-    luat_sms_pdu_packet_t pdu_packet = {0};
-    memcpy(pdu_packet.payload_buf, ucs2_buf, outlen);
-    luat_heap_free(ucs2_buf);
-    pdu_packet.auto_phone = auto_phone;
-    pdu_packet.payload_len = outlen;
-    pdu_packet.maxNum = 1;
-    pdu_packet.phone_len = phone_len;
-    pdu_packet.phone = phone;
-    int len = luat_sms_pdu_packet(&pdu_packet);
-    LLOGW("pdu len %d", len);
-    ret = luat_sms_send_msg_v2(pdu_packet.pdu_buf, len);
-    lua_pushboolean(L, ret == 0 ? 1 : 0);
-    LLOGD("sms ret %d", ret);
-    return 1;
-}
+    ret = utf82ucs2(payload, payload_len, ucs2_buf, payload_len * 3, &outlen);
 
-static int32_t l_long_sms_send_callback(lua_State *L, void* ptr){
-    rtos_msg_t* msg = (rtos_msg_t*)lua_topointer(L, -1);
-    if (msg->arg1)
-    {
-        lua_pushboolean(L, 0);
-    }
-    else
-    {
-        lua_pushboolean(L, 1);
+    if (ret) {
+        LLOGE("utf82ucs2 encode fail");
+        goto SMS_FAIL;
     }
-    luat_cbcwait(L, long_sms_send_idp, 1);
-    long_sms_send_idp = 0;
-    return 0;
-}
 
-static int hex2int(char c)
-{
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    return -1;
-}
-
-
-
-
-//buf PDU缓冲区, phone 电话号码, payload 信息内容, phone_len 电话号码长度, payload_len 信息内容长度, auto_phone 是否自动处理电话号码, is_long 是否长短信, maxNum 最大条数, seqNum 当前序号
-int luat_sms_pdu_packet(luat_sms_pdu_packet_t *packet)
-{
-    // 先处理一下电话号码
-    uint8_t gateway_mode = 0;	//短信网关特殊处理
-    uint8_t pos = 0;
-    size_t phone_len = packet->phone_len;
-    char phone_buff[32] = {0};
-    if ((packet->phone_len >= 15) && !memcmp(packet->phone, "10", 2)) {
-    	LLOGI("sms gateway mode");
-    	gateway_mode = 1;
-    	memcpy(phone_buff, packet->phone, phone_len);
-    }
-    else
-    {
-        if (packet->auto_phone) {
-            if (packet->phone[0] == '+') {
-                memcpy(phone_buff, packet->phone + 1, phone_len - 1);
-                phone_len -= 1;
-            }
-            // 13416121234
-            else if (packet->phone[0] != '8' && packet->phone[1] != '6') {
-                phone_buff[0] = '8';
-                phone_buff[1] = '6';
-                memcpy(phone_buff + 2, packet->phone, phone_len);
-                phone_len += 2;
-            }
-            else {
-                memcpy(phone_buff, packet->phone, phone_len);
-            }
-        }
-        else {
-            memcpy(phone_buff, packet->phone, phone_len);
-        }
-    }
+    memset(&g_s_sms_send, 0x00, sizeof(long_sms_send_t));
+    memset(&g_s_sms_pdu_packet, 0x00, sizeof(luat_sms_pdu_packet_t));
 
-    packet->pdu_buf[pos++] = 0x00;
-    if(packet->maxNum == 1)
-    {
-        packet->pdu_buf[pos++] = 0x01;
-    }
-    else
-    {
-        packet->pdu_buf[pos++] = 0x41;
-    }
-    packet->pdu_buf[pos++] = 0x00;
-    packet->pdu_buf[pos++] = phone_len;
-    packet->pdu_buf[pos++] = gateway_mode ? 0x81 : 0x91;
-    uint8_t one_char = 0;
-    for (size_t i = 0; i < phone_len; i+=2)
-    {
-        if (i == (phone_len - 1) && phone_len % 2 != 0) {
-            one_char = hex2int('F') << 4;
-            one_char |= (0x0F & hex2int(phone_buff[i]));
-            packet->pdu_buf[pos++] = one_char; 
-        }
-        else {
-            one_char = hex2int(phone_buff[i+1]) << 4;
-            one_char |= (0x0F & hex2int(phone_buff[i]));
-            packet->pdu_buf[pos++] = one_char;
-        }
+    // 短短信
+    if (outlen <= LUAT_SMS_SHORT_MSG_PDU_SIZE) {
+        g_s_sms_pdu_packet.maxNum = 1;
+        memcpy(g_s_sms_pdu_packet.payload_buf, ucs2_buf , outlen);
+        g_s_sms_pdu_packet.payload_len = outlen;
+    } else {
+        // 长短信
+        ref_idx = (ref_idx + 1) % 255;
+        g_s_sms_pdu_packet.maxNum = (outlen + LUAT_SMS_LONG_MSG_PDU_SIZE - 1) / LUAT_SMS_LONG_MSG_PDU_SIZE;
+        g_s_sms_pdu_packet.refNum = ref_idx;
+        memcpy(g_s_sms_pdu_packet.payload_buf, ucs2_buf , LUAT_SMS_LONG_MSG_PDU_SIZE);
+        g_s_sms_pdu_packet.payload_len = LUAT_SMS_LONG_MSG_PDU_SIZE;
     }
 
-    packet->pdu_buf[pos++] = 0x00;
-    packet->pdu_buf[pos++] = 0x08;
-    if(packet->maxNum == 1)
-    {
-        packet->pdu_buf[pos++] = packet->payload_len;
-        memcpy(packet->pdu_buf + pos, packet->payload_buf, packet->payload_len);
-        pos += packet->payload_len;
-        return pos;
-    }
-    packet->pdu_buf[pos++] = packet->payload_len + 6;
-
-    // 长短信
-    // UDHI
-    // 0: UDHL,    固定 0x05 
-    // 1: IEI,     固定 0X00
-    // 2: IEDL,    固定 
-    // 3: Reference NO 消息参考序号
-    // 4: Maximum   NO 消息总条数
-    // 5: Current   NO 当前短信序号
-    // uint8_t udhi[6] = {0x05, 0x00, 0x03, 0x00, 0x00, 0x00};
-    uint8_t udhi[6] = {0x05, 0x00, 0x03, idx, packet->maxNum, packet->seqNum};
-    memcpy(packet->pdu_buf + pos, udhi, 6);
-    pos += 6;
-    memcpy(packet->pdu_buf + pos, packet->payload_buf, packet->payload_len);
-    pos += packet->payload_len;
-    return pos;
-}
+    g_s_sms_pdu_packet.auto_phone = auto_phone;
+    g_s_sms_pdu_packet.phone_len = phone_len;
+    g_s_sms_pdu_packet.phone = phone;
+    g_s_sms_pdu_packet.seqNum = 1;
 
-void long_sms_send_task(void *params)
-{
-    long_sms_send_t *args = (long_sms_send_t*)params;
-    int ret = 0;
-    uint8_t is_done = 0; 
-    uint8_t is_error = 0;
-    rtos_msg_t msg = {
-        .handler = l_long_sms_send_callback,
-        .arg1 = 0,
-        .arg2 = 0
-    };
-    size_t outlen = args->payload_len;
-    uint16_t pducnt = (outlen + 133) / 134;
-    idx = (idx  + 1) % 255;
-    luat_event_t event = {0};
-    uint16_t i = 0;
-    uint16_t sn = 1;
-    char tmp[3] = {0};
-    luat_sms_pdu_packet_t pdu_packet = {0};
-    pdu_packet.auto_phone = args->auto_phone;
-    pdu_packet.maxNum = pducnt;
-    pdu_packet.phone_len = args->phone_len;
-    pdu_packet.phone = args->phone;
-    while(1)
-    {
-        if (outlen - i <= 134) {
-            memcpy(pdu_packet.payload_buf, args->payload + i, outlen - i);
-            pdu_packet.payload_len = (outlen - i);
-            is_done = 1;
-        } else {
-            memcpy(pdu_packet.payload_buf, args->payload + i, 134);
-            pdu_packet.payload_len = 134;
-            i += 134;
-        }
-        pdu_packet.seqNum = sn;
-        int pos = luat_sms_pdu_packet(&pdu_packet);
-        sn++;
-        ret = luat_sms_send_msg_v2(pdu_packet.pdu_buf, pos);
-        if (ret) {
-            LLOGE("long sms send fail:%d", ret);
-            is_error = 1;
-            break;
-        }
-        ret = luat_rtos_event_recv(sms_send_task_handle, 0, &event, NULL, 30000); // 30s没收到,则认为发送失败
-        if (ret || event.id != SMS_EVENT_SEND_RET || event.param1 != 0) {
-            // 异常
-            LLOGE("long sms except:%d, %d", ret, event.param1);
-            is_error = 1;
-            break;
-        }
-        if (is_done) {
-            break;
-        }
-    }
+    g_s_sms_send.payload = ucs2_buf;
+    g_s_sms_send.payload_len = outlen;
 
-LONG_SMS_DONE:
-    msg.arg1 = is_error;
-    luat_msgbus_put(&msg, 0);
-    if(args->payload != NULL)
-    {
-        luat_heap_free(args->payload);
-        args->payload = NULL;
+    int len = luat_sms_pdu_packet(&g_s_sms_pdu_packet);
+    LLOGW("pdu len %d", len);
+    ret = luat_sms_send_msg_v2(g_s_sms_pdu_packet.pdu_buf, len);
+    if (!ret) {
+        lua_pushboolean(L, ret == 0);
+        return 1;
     }
-    if (args != NULL)
-    {
-        luat_heap_free(args);
-        args = NULL;
+SMS_FAIL:
+    g_s_sms_pdu_packet.maxNum = 0;
+    g_s_sms_send.payload = NULL;
+    if(ucs2_buf != NULL) {
+        luat_heap_free(ucs2_buf);
     }
-    luat_rtos_task_delete(sms_send_task_handle);
+    lua_pushboolean(L, ret == 0);
+    return 1;
 }
 
 /*
-发送长短信(每段PDU发送超时时间30s)
+同步发送短信
 @api sms.sendLong(phone, msg, auto_phone_fix).wait()
 @string 电话号码,必填
 @string 短信内容,必填
@@ -635,15 +452,22 @@ end)
 static int l_long_sms_send(lua_State *L) {
     size_t phone_len = 0;
     size_t payload_len = 0;
-    uint8_t *ucs2buf = NULL;
-    long_sms_send_t *args = NULL;
+    uint8_t *ucs2_buf = NULL;
     const char* phone = luaL_checklstring(L, 1, &phone_len);
     const char* payload = luaL_checklstring(L, 2, &payload_len);
     int auto_phone = 1;
     if (lua_isboolean(L, 3) && !lua_toboolean(L, 3)) {
         auto_phone = 0;
     }
+    // 当前有其他地方在发送短信
+    if (g_s_sms_pdu_packet.maxNum) {
+        LLOGE("sms is busy");
+        lua_pushboolean(L, 0);
+        luat_pushcwait_error(L,1);
+        return 1;
+    }
 
+    // 当前有其他地方在用sms.sendLong发送短信
     if (long_sms_send_idp) {
         lua_pushboolean(L, 0);
         luat_pushcwait_error(L,1);
@@ -661,47 +485,72 @@ static int l_long_sms_send(lua_State *L) {
     }
 
     size_t outlen = 0;
-    ucs2buf = (uint8_t *)luat_heap_malloc(payload_len * 3);
-    if (ucs2buf == NULL)
+    ucs2_buf = (uint8_t *)luat_heap_malloc(payload_len * 3);
+    if (ucs2_buf == NULL)
     {
         LLOGE("out of memory");
         goto SMS_FAIL;
     }
 
-    memset(ucs2buf, 0x00, payload_len * 3);
+    memset(ucs2_buf, 0x00, payload_len * 3);
 
-    int ret = utf82ucs2(payload, payload_len, ucs2buf, payload_len * 3, &outlen);
+    int ret = utf82ucs2(payload, payload_len, ucs2_buf, payload_len * 3, &outlen);
 
-    if (ret || outlen <= 140)
-    {
-        LLOGE("utf8 to ucs2 fail ret: %d, or ucs2 len is too short len: %d", ret, outlen);
+    if (ret) {
+        LLOGE("utf8 to ucs2 fail ret");
         goto SMS_FAIL;
     }
 
-    args = luat_heap_malloc(sizeof(long_sms_send_t));
-    if (NULL == args) {
-        LLOGE("out of memory");
-        goto SMS_FAIL;
+    memset(&g_s_sms_send, 0x00, sizeof(long_sms_send_t));
+    memset(&g_s_sms_pdu_packet, 0x00, sizeof(luat_sms_pdu_packet_t));
+
+
+    // 短短信
+    if (outlen <= LUAT_SMS_SHORT_MSG_PDU_SIZE) {
+        g_s_sms_pdu_packet.maxNum = 1;
+        memcpy(g_s_sms_pdu_packet.payload_buf, ucs2_buf , outlen);
+        g_s_sms_pdu_packet.payload_len = outlen;
+    } else {
+        // 长短信
+        ref_idx = (ref_idx + 1) % 255;
+        g_s_sms_pdu_packet.maxNum = (outlen + LUAT_SMS_LONG_MSG_PDU_SIZE - 1) / LUAT_SMS_LONG_MSG_PDU_SIZE;
+        g_s_sms_pdu_packet.refNum = ref_idx;
+        memcpy(g_s_sms_pdu_packet.payload_buf, ucs2_buf , LUAT_SMS_LONG_MSG_PDU_SIZE);
+        g_s_sms_pdu_packet.payload_len = LUAT_SMS_LONG_MSG_PDU_SIZE;
     }
-    memset(args, 0x00, sizeof(long_sms_send_t));
-    args->payload = ucs2buf;
-    args->payload_len = outlen;
-    args->phone = phone;
-    args->phone_len = phone_len;
-    args->auto_phone = auto_phone;
+
     long_sms_send_idp = luat_pushcwait(L);
-    ret = luat_rtos_task_create(&sms_send_task_handle, 10 * 1024, 10, "sms_send_task", long_sms_send_task, (void*)args, 10);
+    
+    g_s_sms_pdu_packet.auto_phone = auto_phone;
+    g_s_sms_pdu_packet.phone_len = phone_len;
+    g_s_sms_pdu_packet.phone = phone;
+    g_s_sms_pdu_packet.seqNum = 1;
+
+    g_s_sms_send.payload = ucs2_buf;
+    g_s_sms_send.payload_len = outlen;
+
+    char buf[400] = {0};
+    char tmp[3] = {0};
+
+    int len = luat_sms_pdu_packet(&g_s_sms_pdu_packet);
+    LLOGE("pdu len %d", len);
+    for (int i = 0; i < len; i++)
+    {
+        sprintf(tmp, "%02X", g_s_sms_pdu_packet.pdu_buf[i]);
+        strcat(buf, tmp);
+    }
+    LLOGE("pdu buf %s", buf);
+    ret = luat_sms_send_msg_v2(g_s_sms_pdu_packet.pdu_buf, len);
     if (!ret) {
         return 1;
     }
     LLOGE("sms send task create failed");
 SMS_FAIL:
     long_sms_send_idp = 0;
-    if(ucs2buf != NULL) {
-        luat_heap_free(ucs2buf);
-    }
-    if (args != NULL) {
-        luat_heap_free(args);
+    g_s_sms_pdu_packet.maxNum = 0;
+    g_s_sms_send.payload = NULL;
+    if(ucs2_buf != NULL) {
+        luat_heap_free(ucs2_buf);
     }
     lua_pushboolean(L, 0);
     luat_pushcwait_error(L, 1);
@@ -783,7 +632,7 @@ static const rotable_Reg_t reg_sms[] =
     { "setNewSmsCb",    ROREG_FUNC(l_sms_cb)},
     { "autoLong",       ROREG_FUNC(l_sms_auto_long)},
     { "clearLong",      ROREG_FUNC(l_sms_clear_long)},
-    { "sendLong",      ROREG_FUNC(l_long_sms_send)},
+    { "sendLong",       ROREG_FUNC(l_long_sms_send)},
 	{ NULL,             ROREG_INT(0)}
 };
 

components/sms/include/luat_sms.h

@@ -23,6 +23,11 @@
 #define LUAT_SMS_H
 
 #include "luat_base.h"
+
+#ifndef bool
+#define bool    uint8_t
+#endif
+
 /**
  * @defgroup LUAT_SMS  SMS接口
  * @{
@@ -32,6 +37,11 @@
 #define LUAT_SMS_MAX_PDU_SIZE 180
 #define LUAT_SMS_MAX_LENGTH_OF_ADDRESS_VALUE 40
 #define LUAT_SMS_MAX_ADDR_STR_MAX_LEN ((LUAT_SMS_MAX_LENGTH_OF_ADDRESS_VALUE + 1) * 4)
+
+#define LUAT_SMS_SHORT_MSG_PDU_SIZE (140)
+#define LUAT_SMS_LONG_MSG_PDU_SIZE (134)
+
+
 typedef void (*LUAT_SMS_HANDLE_CB)(uint8_t event, void* param);
 typedef void (*LUAT_SMS_HANDLE_SEND_CB)(int ret);
 
@@ -110,6 +120,19 @@ typedef struct
 }LUAT_SMS_RECV_MSG_T;
 
 
+typedef struct 
+{
+    size_t phone_len;           // 电话号码长度
+    size_t payload_len;         // 待组包的短信数据长度
+    const char *phone;          // 电话号码
+    uint8_t pdu_buf[320];       // 组包后的PDU短信
+    uint8_t payload_buf[200];   // 待组包的短信数据
+    uint8_t auto_phone;         // 是否自动处理电话号码
+    uint8_t maxNum;             // 短信最大条数， 长短信用
+    uint8_t seqNum;             // 当前短信序号
+    uint8_t refNum;
+}luat_sms_pdu_packet_t;
+
 /**
  * @brief 初始化短信
  */
@@ -145,5 +168,11 @@ void luat_sms_recv_msg_register_handler(LUAT_SMS_HANDLE_CB callback_fun);
  * @param callback_fun    回调函数
  */
 void luat_sms_send_msg_register_handler(LUAT_SMS_HANDLE_SEND_CB callback_fun);
+
+/**
+ * @brief 打包pdu数据
+ * @param packet    
+ */
+int luat_sms_pdu_packet(luat_sms_pdu_packet_t *packet);
 /**@}*/
 #endif

components/sms/src/luat_sms.c

@@ -0,0 +1,175 @@
+#include "luat_sms.h"
+
+
+static int hex2int(char c)
+{
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+    return -1;
+}
+
+
+void ucs2char(char* source, size_t size, char* dst2, size_t* outlen) {
+    char buff[size + 2];
+    memset(buff, 0, size + 2);
+    luat_str_fromhex(source, size, buff);
+    uint16_t* tmp = (uint16_t*)buff;
+    char* dst = dst2;
+    uint16_t unicode = 0;
+    size_t dstlen = 0;
+    while (1) {
+        unicode = *tmp ++;
+        unicode = ((unicode >> 8) & 0xFF) + ((unicode & 0xFF) << 8);
+        if (unicode == 0)
+            break; // 终止了
+        if (unicode <= 0x0000007F) {
+            dst[dstlen++] = (unicode & 0x7F);
+            continue;
+        }
+        if (unicode <= 0x000007FF) {
+            dst[dstlen++]	= ((unicode >> 6) & 0x1F) | 0xC0;
+		    dst[dstlen++] 	= (unicode & 0x3F) | 0x80;
+            continue;
+        }
+        if (unicode <= 0x0000FFFF) {
+            dst[dstlen++]	= ((unicode >> 12) & 0x0F) | 0xE0;
+		    dst[dstlen++]	= ((unicode >>  6) & 0x3F) | 0x80;
+		    dst[dstlen++]	= (unicode & 0x3F) | 0x80;
+            continue;
+        }
+        break;
+    }
+    *outlen = dstlen;
+}
+
+int utf82ucs2(char* source, size_t source_len, char* dst, size_t dstlen, size_t* outlen) {
+    uint16_t unicode = 0;
+    size_t tmplen = 0;
+    for (size_t i = 0; i < source_len; i++)
+    {
+        if(tmplen >= dstlen) {
+            return -1;
+        }
+        // 首先是不是单字节
+        if (source[i] & 0x80) {
+            // 非ASCII编码
+            if (source[i] && 0xE0) { // 1110xxxx 10xxxxxx 10xxxxxx
+                unicode = ((source[i] & 0x0F) << 12) + ((source[i+1] & 0x3F) << 6) + (source[i+2] & 0x3F);
+                dst[tmplen++] = (unicode >> 8) & 0xFF;
+                dst[tmplen++] = unicode & 0xFF;
+                i+=2;
+                continue;
+            }
+            if (source[i] & 0xC0) { // 110xxxxx 10xxxxxx
+                unicode = ((source[i] & 0x1F) << 6) + (source[i+1] & 0x3F);
+                dst[tmplen++] = (unicode >> 8) & 0xFF;
+                dst[tmplen++] = unicode & 0xFF;
+                i++;
+                continue;
+            }
+            return -1;
+        }
+        // 单个ASCII字符, 但需要扩展到2位
+        else {
+            // ASCII编码
+            dst[tmplen++] = 0x00;
+            dst[tmplen++] = source[i];
+            continue;
+        }
+    }
+    *outlen = tmplen;
+    return 0;
+}
+
+int luat_sms_pdu_packet(luat_sms_pdu_packet_t *packet)
+{
+    // 先处理一下电话号码
+    uint8_t gateway_mode = 0;	//短信网关特殊处理
+    uint8_t pos = 0;
+    size_t phone_len = packet->phone_len;
+    char phone_buff[32] = {0};
+    if ((packet->phone_len >= 15) && !memcmp(packet->phone, "10", 2)) {
+    	gateway_mode = 1;
+    	memcpy(phone_buff, packet->phone, phone_len);
+    }
+    else
+    {
+        if (packet->auto_phone) {
+            if (packet->phone[0] == '+') {
+                memcpy(phone_buff, packet->phone + 1, phone_len - 1);
+                phone_len -= 1;
+            }
+            // 13416121234
+            else if (packet->phone[0] != '8' && packet->phone[1] != '6') {
+                phone_buff[0] = '8';
+                phone_buff[1] = '6';
+                memcpy(phone_buff + 2, packet->phone, phone_len);
+                phone_len += 2;
+            }
+            else {
+                memcpy(phone_buff, packet->phone, phone_len);
+            }
+        }
+        else {
+            memcpy(phone_buff, packet->phone, phone_len);
+        }
+    }
+
+    packet->pdu_buf[pos++] = 0x00;
+    if(packet->maxNum == 1)
+    {
+        packet->pdu_buf[pos++] = 0x01;
+    }
+    else
+    {
+        packet->pdu_buf[pos++] = 0x41;
+    }
+    packet->pdu_buf[pos++] = 0x00;
+    packet->pdu_buf[pos++] = phone_len;
+    packet->pdu_buf[pos++] = gateway_mode ? 0x81 : 0x91;
+    uint8_t one_char = 0;
+    for (size_t i = 0; i < phone_len; i+=2)
+    {
+        if (i == (phone_len - 1) && phone_len % 2 != 0) {
+            one_char = hex2int('F') << 4;
+            one_char |= (0x0F & hex2int(phone_buff[i]));
+            packet->pdu_buf[pos++] = one_char; 
+        }
+        else {
+            one_char = hex2int(phone_buff[i+1]) << 4;
+            one_char |= (0x0F & hex2int(phone_buff[i]));
+            packet->pdu_buf[pos++] = one_char;
+        }
+    }
+
+    packet->pdu_buf[pos++] = 0x00;
+    packet->pdu_buf[pos++] = 0x08;
+    if(packet->maxNum == 1)
+    {
+        packet->pdu_buf[pos++] = packet->payload_len;
+        memcpy(packet->pdu_buf + pos, packet->payload_buf, packet->payload_len);
+        pos += packet->payload_len;
+        return pos;
+    }
+    packet->pdu_buf[pos++] = packet->payload_len + 6;
+
+    // 长短信
+    // UDHI
+    // 0: UDHL,    固定 0x05 
+    // 1: IEI,     固定 0X00
+    // 2: IEDL,    固定 
+    // 3: Reference NO 消息参考序号
+    // 4: Maximum   NO 消息总条数
+    // 5: Current   NO 当前短信序号
+    // uint8_t udhi[6] = {0x05, 0x00, 0x03, 0x00, 0x00, 0x00};
+    uint8_t udhi[6] = {0x05, 0x00, 0x03, packet->refNum, packet->maxNum, packet->seqNum};
+    memcpy(packet->pdu_buf + pos, udhi, 6);
+    pos += 6;
+    memcpy(packet->pdu_buf + pos, packet->payload_buf, packet->payload_len);
+    pos += packet->payload_len;
+    return pos;
+}

luat/demo/airlink/uart_http/main.lua

@@ -3,9 +3,12 @@
 PROJECT = "airlink_uart"
 VERSION = "1.0.1"
 
+dnsproxy = require("dnsproxy")
+
 is_gw = false -- 是否是网关模式
 
 sys.taskInit(function()
+    sys.wait(500)
     log.info("airlink", "Starting airlink with UART task")
     -- 首先, 初始化uart1, 115200波特率 8N1
     uart.setup(1, 115200)
@@ -22,14 +25,28 @@ sys.taskInit(function()
     else
         netdrv.ipv4(socket.LWIP_USER0, "192.168.111.2", "255.255.255.0", "192.168.111.1")
     end
+    -- netdrv.debug(0, true)
+
 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")
     sys.wait(3000)
     if is_gw then
         log.info("airlink", "Gateway mode")
-        while netdrv.ready(socket.LWIP_USER0) == false do
+        -- while netdrv.ready(socket.LWIP_USER0) == false do
+        while netdrv.ready(socket.LWIP_GP) == false do
             sys.wait(100)
         end
         netdrv.napt(socket.LWIP_GP)
@@ -46,6 +63,11 @@ sys.taskInit(function()
     end
 end)
 
+sys.subscribe("AIRLINK_SDATA", function(data)
+    log.info("client 收到AIRLINK_SDATA!!", data)
+end)
+
+
 -- 用户代码已结束---------------------------------------------
 -- 结尾总是这一句
 sys.run()

luat/demo/airlink/uart_sdata/main.lua

@@ -3,27 +3,73 @@
 PROJECT = "airlink_uart"
 VERSION = "1.0.1"
 
+dnsproxy = require("dnsproxy")
+
+is_gw = true
+
 sys.taskInit(function()
+    sys.wait(500)
     log.info("airlink", "Starting airlink with UART task")
     -- 首先, 初始化uart1, 115200波特率 8N1
     uart.setup(1, 115200)
     -- 初始化airlink
     airlink.init()
+    netdrv.setup(socket.LWIP_USER0, netdrv.WHALE) -- 初始化netdrv
     -- 启动airlink uart任务
     airlink.start(2)
+    if is_gw then
+        netdrv.ipv4(socket.LWIP_USER0, "192.168.111.1", "255.255.255.0", "192.168.111.2")
+    else
+        netdrv.ipv4(socket.LWIP_USER0, "192.168.111.2", "255.255.255.0", "192.168.111.1")
+    end
+    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
+end)
 
-    while 1 do
-        -- 发送给对端设备
-        local data = rtos.bsp() .. " " .. os.date() .. " " .. (mobile and mobile.imei() or "")
-        log.info("发送数据给对端设备", data, "当前airlink状态", airlink.ready())
-        airlink.sdata(data)
-        -- airlink.test(1000) -- 要测试高速连续发送的情况
-        sys.wait(1000)
+sys.taskInit(function()
+    -- sys.waitUntil("IP_READY")
+    sys.wait(3000)
+    if is_gw then
+        log.info("airlink", "Gateway mode")
+        while netdrv.ready(socket.LWIP_GP) == false do
+            sys.wait(100)
+            log.info("airlink", "Waiting for netdrv_READY")
+        end
+        log.info("airlink", "netdrv_READY")
+        netdrv.napt(socket.LWIP_GP)
+        dnsproxy.setup(socket.LWIP_USER0,socket.LWIP_GP)
+        return
+    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事件，打印收到的信息
+sys.subscribe("IP_READY", function(id,ip)
+    log.info("收到IP_READY!!", id,ip)
 end)
 
 sys.subscribe("AIRLINK_SDATA", function(data)
-    log.info("收到AIRLINK_SDATA!!", data)
+    log.info("sever 收到AIRLINK_SDATA!!", data)
 end)
 
 -- 用户代码已结束---------------------------------------------

luat/demo/spi/air8000/spi_tf_wan/main.lua

@@ -20,10 +20,9 @@ sysplus = require("sysplus")
 
 local rtos_bsp = rtos.bsp()
 
+local USE_CH390 = true  -- 使用ch390时，设置为true，否则为false
 local SPI_SPEED = 25600000
 
-
-
 -- spi_id,pin_cs
 local function fatfs_spi_pin()     
     return 1, 20    -- Air8000整机开发板上的pin_cs为gpio20
@@ -31,7 +30,11 @@ end
 
 -- TF卡和WAN口初始化函数
 local function tf_wan_init()
-    gpio.setup(140, 1, gpio.PULLUP)  -- 打开ch390供电， Air8000 的ch390 和 tf卡共用SPI ，ch390 如果不打开的话会让SPI 无法正常工作，从而导致TF卡无法使用
+
+    if USE_CH390 then
+        gpio.setup(140, 1, gpio.PULLUP)  -- 打开ch390供电
+    end
+
     sys.wait(1000)                   -- 延迟1秒让ch390 稳定后再挂载TF卡
     
     -- #################################################
@@ -44,7 +47,7 @@ local function tf_wan_init()
     local spi_id, pin_cs,tp = fatfs_spi_pin() 
     -- 仅SPI方式需要自行初始化spi, sdio不需要
     -- 使用较低的统一速度以兼容TF卡和CH390
-    spi.setup(spi_id, nil, 0, 0, pin_cs, SPI_SPEED)
+    spi.setup(spi_id, pin_cs, 0, 0, 8, SPI_SPEED)
     gpio.setup(pin_cs, 1)
     fatfs.mount(fatfs.SPI, "/sd", spi_id, pin_cs, SPI_SPEED)