diff --git a/APP_Framework/Framework/connection/adapter.h b/APP_Framework/Framework/connection/adapter.h
index aefb0df1f..09c15a0f0 100644
--- a/APP_Framework/Framework/connection/adapter.h
+++ b/APP_Framework/Framework/connection/adapter.h
@@ -190,6 +190,9 @@ struct Adapter
     void *done;
     void *adapter_param;
 
+    sem_t sem;
+    pthread_mutex_t lock;
+ 
     struct DoublelistNode link;
 };
 
diff --git a/APP_Framework/Framework/connection/lora/adapter_lora.c b/APP_Framework/Framework/connection/lora/adapter_lora.c
index deab08bc4..e4b6cd4cf 100644
--- a/APP_Framework/Framework/connection/lora/adapter_lora.c
+++ b/APP_Framework/Framework/connection/lora/adapter_lora.c
@@ -28,9 +28,11 @@ extern AdapterProductInfoType Sx1278Attach(struct Adapter *adapter);
 extern AdapterProductInfoType E220Attach(struct Adapter *adapter);
 #endif
 
-#define CLIENT_UPDATE_MODE
+//#define CLIENT_UPDATE_MODE
+#define GATEWAY_CMD_MODE
 
-#define ADAPTER_LORA_CLIENT_NUM 255
+//Client num index 1-ADAPTER_LORA_CLIENT_NUM
+#define ADAPTER_LORA_CLIENT_NUM 20
 
 //LORA single transfer data max size 128 bytes: data format 16 bytes and user data 112 bytes
 #define ADAPTER_LORA_DATA_LENGTH 112
@@ -46,6 +48,8 @@ extern AdapterProductInfoType E220Attach(struct Adapter *adapter);
 #define ADAPTER_LORA_DATA_TYPE_CMD        0x0F
 #define ADAPTER_LORA_DATA_END             0x5A
 
+#define ADAPTER_LORA_RECEIVE_ERROR_CNT    1
+
 //need to change status if the lora client wants to quit the net when timeout or a certain event
 //eg.can also use sem to trigger quit function
 static int g_adapter_lora_quit_flag = 0;
@@ -71,8 +75,6 @@ enum LoraGatewayState {
     LORA_RECV_DATA,
 };
 
-static uint8_t LoraGatewayState = LORA_STATE_IDLE;
-
 struct LoraGatewayParam 
 {
     uint8_t gateway_id;
@@ -117,6 +119,14 @@ struct LoraDataFormat
     uint16_t flame_end;
 };
 
+uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
+struct LoraDataFormat client_recv_data_format[ADAPTER_LORA_CLIENT_NUM];
+
+static sem_t gateway_recv_data_sem;
+struct LoraDataFormat gateway_recv_data_format;
+
+static int recv_error_cnt = 0;
+
 /*******************LORA MESH FUNCTION***********************/
 
 /**
@@ -160,36 +170,6 @@ static int LoraCrc16Check(uint8_t *data, uint16_t length)
         return -1;
 }
 
-/**
- * @description: Lora receive data check
- * @param recv_data receive data buffer
- * @param length receive data length
- * @param lora_data_format LoraDataFormat data
- */
-static int LoraReceiveDataCheck(uint8_t *recv_data, uint16_t length, struct LoraDataFormat *lora_data_format)
-{
-    if ((ADAPTER_LORA_DATA_HEAD == recv_data[0]) && (ADAPTER_LORA_DATA_HEAD == recv_data[1]) &&
-        (ADAPTER_LORA_DATA_END == recv_data[length - 1]) && (ADAPTER_LORA_DATA_END == recv_data[length - 2])) {
-
-        lora_data_format->flame_head = ((recv_data[0] << 8) & 0xFF00) | recv_data[1];
-        lora_data_format->flame_index = ((recv_data[2] << 8) & 0xFF00) | recv_data[3];
-        lora_data_format->length = ((recv_data[4] << 24) & 0xFF000000) | ((recv_data[5] << 16) & 0xFF0000) |
-                                    ((recv_data[6] << 8) & 0xFF00) | (recv_data[7] & 0xFF);
-        lora_data_format->panid = ((recv_data[8] << 8) & 0xFF00) | recv_data[9];
-        lora_data_format->client_id = recv_data[10];
-        lora_data_format->gateway_id = recv_data[11];
-        lora_data_format->data_type = ((recv_data[12] << 8) & 0xFF00) | recv_data[13];
-
-        lora_data_format->flame_end = ((recv_data[length - 2] << 8) & 0xFF00) | recv_data[length - 1];
-
-        memcpy(lora_data_format->data, (uint8_t *)(recv_data + 14), ADAPTER_LORA_DATA_LENGTH);
-
-        return 0;
-    }
-
-    return -1;
-}
-
 /**
  * @description: Lora Gateway reply connect request to Client
  * @param adapter Lora adapter pointer
@@ -342,6 +322,8 @@ static int LoraGatewayHandleData(struct Adapter *adapter, struct LoraDataFormat
     /*User needs to handle client data depends on the requirement*/
     printf("Lora Gateway receive Client %d data:\n", gateway_recv_data->client_id);
     printf("%s\n", gateway_recv_data->data);
+
+    PrivSemaphoreAbandon(&gateway_recv_data_sem);
     return 0;
 }
 
@@ -428,29 +410,32 @@ static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int lengt
 /**
  * @description: Lora Gateway receive data analyzing
  * @param adapter Lora adapter pointer
- * @param gateway_recv_data Lora gateway receive data pointer
  */
-static int LoraGateWayDataAnalyze(struct Adapter *adapter, struct LoraDataFormat *gateway_recv_data)
+static int LoraGateWayDataAnalyze(struct Adapter *adapter)
 {
     int ret = 0;
-    printf("%s:gateway_recv_data\n", __func__);
-    printf("head 0x%x length %d panid 0x%x data_type 0x%x client_id 0x%x gateway_id 0x%x end 0x%x\n",
-        gateway_recv_data->flame_head, gateway_recv_data->length, gateway_recv_data->panid, gateway_recv_data->data_type,
-        gateway_recv_data->client_id, gateway_recv_data->gateway_id, gateway_recv_data->flame_end);
 
-    if (ADAPTER_LORA_NET_PANID == gateway_recv_data->panid) {
-        switch (gateway_recv_data->data_type)
+    if (ADAPTER_LORA_NET_PANID == gateway_recv_data_format.panid) {
+
+        printf("%s: gateway_recv_data\n", __func__);
+        printf("head 0x%x length %d panid 0x%x data_type 0x%x client_id 0x%x gateway_id 0x%x end 0x%x\n",
+            gateway_recv_data_format.flame_head, gateway_recv_data_format.length, gateway_recv_data_format.panid, gateway_recv_data_format.data_type,
+            gateway_recv_data_format.client_id, gateway_recv_data_format.gateway_id, gateway_recv_data_format.flame_end);
+
+        switch (gateway_recv_data_format.data_type)
         {
         case ADAPTER_LORA_DATA_TYPE_JOIN : 
         case ADAPTER_LORA_DATA_TYPE_QUIT :
-            ret = LoraGatewayReply(adapter, gateway_recv_data);
+            ret = LoraGatewayReply(adapter, &gateway_recv_data_format);
             break;
         case ADAPTER_LORA_DATA_TYPE_USERDATA :
-            ret = LoraGatewayHandleData(adapter, gateway_recv_data);
+            ret = LoraGatewayHandleData(adapter, &gateway_recv_data_format);
             break;
         default:
             break;
         }
+    } else {
+        ret = -1;
     }
 
     return ret;
@@ -466,40 +451,24 @@ static int LoraGateWayDataAnalyze(struct Adapter *adapter, struct LoraDataFormat
 static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int length, uint16_t index)
 {
     int ret = 0;
-    uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
-    
-    struct LoraDataFormat *client_recv_data = PrivMalloc(sizeof(struct LoraDataFormat));
+    uint8_t client_id = adapter->net_role_id;
 
-    memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
-    memset(client_recv_data, 0, sizeof(struct LoraDataFormat));
-    
-    ret = AdapterDeviceRecv(adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
-    if (ret <= 0) {
-        printf("LoraClientDataAnalyze recv error.Just return\n");
-        PrivFree(client_recv_data);
-        return -1;
-    }
-
-    ret = LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH, client_recv_data);
-    if (ret < 0) {
-        printf("LoraReceiveDataCheck recv error.Just return\n");
-        PrivFree(client_recv_data);
-        return -1;
-    }
-
-    printf("%s:client_recv_data\n", __func__);
-    printf("head 0x%x length %d panid 0x%x data_type 0x%x client_id 0x%x gateway_id 0x%x end 0x%x\n",
-        client_recv_data->flame_head, client_recv_data->length, client_recv_data->panid, client_recv_data->data_type,
-        client_recv_data->client_id, client_recv_data->gateway_id, client_recv_data->flame_end);
-
-    if (ADAPTER_LORA_NET_PANID == client_recv_data->panid) {
+    ret = PrivSemaphoreObtainWait(&adapter->sem, NULL);
+    if (0 == ret) {
         //only handle this client_id information from gateway
-        if (client_recv_data->client_id == adapter->net_role_id) {
-            switch (client_recv_data->data_type)
+        if ((client_recv_data_format[client_id - 1].client_id == adapter->net_role_id) && 
+            (ADAPTER_LORA_NET_PANID == client_recv_data_format[client_id - 1].panid)) {
+
+            printf("%s: 0x%x client_recv_data\n", __func__, client_recv_data_format[client_id - 1].client_id);
+            printf("head 0x%x length %d panid 0x%x data_type 0x%x client_id 0x%x gateway_id 0x%x end 0x%x\n",
+                client_recv_data_format[client_id - 1].flame_head, client_recv_data_format[client_id - 1].length, client_recv_data_format[client_id - 1].panid, client_recv_data_format[client_id - 1].data_type,
+                client_recv_data_format[client_id - 1].client_id, client_recv_data_format[client_id - 1].gateway_id, client_recv_data_format[client_id - 1].flame_end);
+
+            switch (client_recv_data_format[client_id - 1].data_type)
             {
             case ADAPTER_LORA_DATA_TYPE_JOIN_REPLY : 
             case ADAPTER_LORA_DATA_TYPE_QUIT_REPLY :
-                ret = LoraClientUpdate(adapter, client_recv_data);
+                ret = LoraClientUpdate(adapter, &client_recv_data_format[client_id - 1]);
                 break;
             case ADAPTER_LORA_DATA_TYPE_CMD :
                 if (send_buf) {
@@ -509,10 +478,12 @@ static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int le
             default:
                 break;
             }
+
+            //Client operation done
+            memset(&client_recv_data_format[client_id - 1], 0 , sizeof(struct LoraDataFormat));
         }
     }
 
-    PrivFree(client_recv_data);
     return ret;
 }
 
@@ -611,125 +582,171 @@ static int LoraClientQuitNet(struct Adapter *adapter, unsigned short panid)
 }
 
 /**
- * @description: Lora Gateway Process function
- * @param lora_adapter Lora adapter pointer
- * @param gateway Lora gateway pointer
- * @param gateway_recv_data Lora gateway receive data pointer
+ * @description: Lora receive data check
+ * @param adapter Lora adapter pointer
+ * @param recv_data receive data buffer
+ * @param length receive data length
  */
-int LoraGatewayProcess(struct Adapter *lora_adapter, struct LoraGatewayParam *gateway, struct LoraDataFormat *gateway_recv_data)
+static int LoraReceiveDataCheck(struct Adapter *adapter, uint8_t *recv_data, uint16_t length)
+{
+    int ret;
+    uint8_t client_id;
+
+    printf("gateway client_id 0x%x head 0x%x%x end 0x%x%x\n", 
+        recv_data[10], recv_data[0], recv_data[1], recv_data[length - 2], recv_data[length - 1]);
+
+    if ((ADAPTER_LORA_DATA_HEAD == recv_data[0]) && (ADAPTER_LORA_DATA_HEAD == recv_data[1]) &&
+        (ADAPTER_LORA_DATA_END == recv_data[length - 1]) && (ADAPTER_LORA_DATA_END == recv_data[length - 2])) {
+
+#ifdef AS_LORA_GATEWAY_ROLE
+        gateway_recv_data_format.flame_head = ((recv_data[0] << 8) & 0xFF00) | recv_data[1];
+        gateway_recv_data_format.flame_index = ((recv_data[2] << 8) & 0xFF00) | recv_data[3];
+        gateway_recv_data_format.length = ((recv_data[4] << 24) & 0xFF000000) | ((recv_data[5] << 16) & 0xFF0000) |
+                                    ((recv_data[6] << 8) & 0xFF00) | (recv_data[7] & 0xFF);
+        gateway_recv_data_format.panid = ((recv_data[8] << 8) & 0xFF00) | recv_data[9];
+        gateway_recv_data_format.client_id = recv_data[10];
+        gateway_recv_data_format.gateway_id = recv_data[11];
+        gateway_recv_data_format.data_type = ((recv_data[12] << 8) & 0xFF00) | recv_data[13];
+
+        gateway_recv_data_format.flame_end = ((recv_data[length - 2] << 8) & 0xFF00) | recv_data[length - 1];
+
+        memcpy(gateway_recv_data_format.data, (uint8_t *)(recv_data + 14), ADAPTER_LORA_DATA_LENGTH);
+
+        ret = LoraGateWayDataAnalyze(adapter);
+
+        return ret;
+#else
+        client_id = recv_data[10];
+        printf("client_id 0x%x\n", client_id);
+
+        if (client_id == adapter->net_role_id) {
+            client_recv_data_format[client_id - 1].flame_head = ((recv_data[0] << 8) & 0xFF00) | recv_data[1];
+            client_recv_data_format[client_id - 1].flame_index = ((recv_data[2] << 8) & 0xFF00) | recv_data[3];
+            client_recv_data_format[client_id - 1].length = ((recv_data[4] << 24) & 0xFF000000) | ((recv_data[5] << 16) & 0xFF0000) |
+                                        ((recv_data[6] << 8) & 0xFF00) | (recv_data[7] & 0xFF);
+            client_recv_data_format[client_id - 1].panid = ((recv_data[8] << 8) & 0xFF00) | recv_data[9];
+            client_recv_data_format[client_id - 1].client_id = recv_data[10];
+            client_recv_data_format[client_id - 1].gateway_id = recv_data[11];
+            client_recv_data_format[client_id - 1].data_type = ((recv_data[12] << 8) & 0xFF00) | recv_data[13];
+
+            client_recv_data_format[client_id - 1].flame_end = ((recv_data[length - 2] << 8) & 0xFF00) | recv_data[length - 1];
+
+            memcpy(client_recv_data_format[client_id - 1].data, (uint8_t *)(recv_data + 14), ADAPTER_LORA_DATA_LENGTH);
+            return 0;
+        }
+#endif
+    }
+
+    return -1;
+}
+
+/**
+ * @description: Lora gateway re-send cmd
+ * @param adapter Lora adapter pointer
+ */
+static void LoraGatewayReSendCmd(struct Adapter *adapter)
 {
     int i, ret = 0;
-    uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
-    switch (LoraGatewayState)
-    {
-    case LORA_STATE_IDLE:
-        memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
+    struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)adapter->adapter_param;
 
-        ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
-        if (ret <= 0)  {
-            printf("LoraGatewayProcess IDLE recv error.Just return\n");
-            LoraGatewayState = LORA_STATE_IDLE;
-            break;
-        }
-
-        ret = LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH, gateway_recv_data);
-        if (ret < 0) {
-            printf("LoraReceiveDataCheck IDLE recv error.Just return\n");
-            LoraGatewayState = LORA_STATE_IDLE;
-            break;
-        }
-
-        if (ADAPTER_LORA_DATA_TYPE_JOIN == gateway_recv_data->data_type) {
-            LoraGatewayState = LORA_JOIN_NET;
-        } else if (ADAPTER_LORA_DATA_TYPE_QUIT == gateway_recv_data->data_type) {
-            LoraGatewayState = LORA_QUIT_NET;
-        } else {
-            LoraGatewayState = LORA_STATE_IDLE;
-        }
-        break;
-    case LORA_JOIN_NET:
-    case LORA_QUIT_NET:
-        ret = LoraGateWayDataAnalyze(lora_adapter, gateway_recv_data);
-        if (ret < 0) {
-            printf("LoraGateWayDataAnalyze state %d error, re-send data cmd to client\n", LoraGatewayState);
-            PrivTaskDelay(500);
-        }
-        LoraGatewayState = LORA_RECV_DATA;
-        break;
-    case LORA_RECV_DATA:
 #ifdef GATEWAY_CMD_MODE
-        for (i = 0; i < gateway->client_num; i ++) {
-            if (gateway->client_id[i]) {
-                printf("LoraGatewayProcess send to client %d for data\n", gateway->client_id[i]);
-                ret = LoraGatewaySendCmd(lora_adapter, gateway->client_id[i], ADAPTER_LORA_DATA_TYPE_CMD);
-                if (ret < 0) {
-                    printf("LoraGatewaySendCmd client ID %d error\n", gateway->client_id[i]);
-                    PrivTaskDelay(500);
-                    continue;
-                }
-
-                memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
-                ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
-                if (ret <= 0) {
-                    printf("LoraGatewayProcess recv error.Just return\n");
-                    continue;
-                }
-
-                ret = LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH, gateway_recv_data);
-                if (ret < 0) {
-                    printf("LoraReceiveDataCheck recv error.Just return\n");
-                    continue;
-                }
-
-                if (ADAPTER_LORA_DATA_TYPE_JOIN == gateway_recv_data->data_type) {
-                    LoraGatewayState = LORA_JOIN_NET;
-                } else if (ADAPTER_LORA_DATA_TYPE_QUIT == gateway_recv_data->data_type) {
-                    LoraGatewayState = LORA_QUIT_NET;
-                } else {
-                    ret = LoraGateWayDataAnalyze(lora_adapter, gateway_recv_data);
-                    if (ret < 0) {
-                        printf("LoraGateWayDataAnalyze error, re-send data cmd to client\n");
-                        PrivTaskDelay(500);
-                    }
-                }
+    for (i = 0; i < gateway->client_num; i ++) {
+        if (gateway->client_id[i]) {
+            printf("LoraGatewayProcess send to client %d for data\n", gateway->client_id[i]);
+            ret = LoraGatewaySendCmd(adapter, gateway->client_id[i], ADAPTER_LORA_DATA_TYPE_CMD);
+            if (ret < 0) {
+                printf("LoraGatewaySendCmd client ID %d error\n", gateway->client_id[i]);
+                continue;
             }
         }
+    }
 #endif
+}
 
-#ifdef CLIENT_UPDATE_MODE
+/**
+ * @description: Lora client re-send data
+ * @param adapter Lora adapter pointer
+ */
+static void LoraClientReSendData(struct Adapter *adapter)
+{
+    //set lora_send_buf for re-connect
+    uint8_t client_re_send_buf[ADAPTER_LORA_DATA_LENGTH];
+    memset(client_re_send_buf, 0, ADAPTER_LORA_DATA_LENGTH);
+    LoraClientSendData(adapter, client_re_send_buf, ADAPTER_LORA_DATA_LENGTH, 0);
+    printf("LoraClientReSendData client 0x%x\n", adapter->net_role_id);
+}
+
+/**
+ * @description: Lora data receive task
+ * @param parameter - Lora adapter pointer
+ */
+static void *LoraReceiveTask(void *parameter)
+{
+    int ret = 0;
+    struct Adapter *lora_adapter = (struct Adapter *)parameter;
+
+    while (1) {
         memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
+        
         ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
         if (ret <= 0) {
-            printf("LoraGatewayProcess recv error.Just return\n");
-            break;
+            printf("AdapterDeviceRecv error.Just return\n");
+            recv_error_cnt++;
+            if (recv_error_cnt > ADAPTER_LORA_RECEIVE_ERROR_CNT) {
+                recv_error_cnt = 0;
+#ifdef AS_LORA_GATEWAY_ROLE
+                //LoraGatewayReSendCmd(lora_adapter);
+#endif
+
+#ifdef AS_LORA_CLIENT_ROLE
+                LoraClientReSendData(lora_adapter);
+#endif
+            }
+            continue;
         }
 
-        ret = LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH, gateway_recv_data);
+        ret = LoraReceiveDataCheck(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
         if (ret < 0) {
             printf("LoraReceiveDataCheck recv error.Just return\n");
-            break;
+            continue;
         }
 
-        if (ADAPTER_LORA_DATA_TYPE_JOIN == gateway_recv_data->data_type) {
-            LoraGatewayState = LORA_JOIN_NET;
-        } else if (ADAPTER_LORA_DATA_TYPE_QUIT == gateway_recv_data->data_type) {
-            LoraGatewayState = LORA_QUIT_NET;
-        } else {
-            ret = LoraGateWayDataAnalyze(lora_adapter, gateway_recv_data);
-            if (ret < 0) {
-                printf("LoraGateWayDataAnalyze error, re-send data cmd to client\n");
-                PrivTaskDelay(500);
-            }
-        }
-#endif
-        break;
-    default:
-        break;
+        PrivSemaphoreAbandon(&lora_adapter->sem);
     }
 
     return 0;
 }
 
+/**
+ * @description: Lora Gateway Process function
+ * @param lora_adapter Lora adapter pointer
+ * @param gateway Lora gateway pointer
+ */
+void LoraGatewayProcess(struct Adapter *lora_adapter, struct LoraGatewayParam *gateway)
+{
+    int i, ret = 0;
+
+#ifdef GATEWAY_CMD_MODE
+    for (i = 0; i < gateway->client_num; i ++) {
+        if (gateway->client_id[i]) {
+            printf("LoraGatewayProcess send to client %d for data\n", gateway->client_id[i]);
+            ret = LoraGatewaySendCmd(lora_adapter, gateway->client_id[i], ADAPTER_LORA_DATA_TYPE_CMD);
+            if (ret < 0) {
+                printf("LoraGatewaySendCmd client ID %d error\n", gateway->client_id[i]);
+                continue;
+            }
+
+            ret = PrivSemaphoreObtainWait(&gateway_recv_data_sem, NULL);
+            if (0 == ret) {
+                printf("LoraGatewayProcess receive client %d data done\n", gateway->client_id[i]);
+            }
+        }
+    }
+#endif
+
+    return;
+}
+
 /**
  * @description: Lora Gateway task
  * @param parameter - Lora adapter pointer
@@ -740,10 +757,11 @@ static void *LoraGatewayTask(void *parameter)
     int ret = 0;
     struct Adapter *lora_adapter = (struct Adapter *)parameter;
     struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)lora_adapter->adapter_param;
-    struct LoraDataFormat gateway_recv_data;
+
+    memset(&gateway_recv_data_format, 0, sizeof(struct LoraDataFormat));
     
     while (1) {
-        LoraGatewayProcess(lora_adapter, gateway, &gateway_recv_data);
+        LoraGatewayProcess(lora_adapter, gateway);
     }
 
     return 0;
@@ -759,47 +777,56 @@ static void *LoraClientDataTask(void *parameter)
     struct Adapter *lora_adapter = (struct Adapter *)parameter;
     struct LoraClientParam *client = (struct LoraClientParam *)lora_adapter->adapter_param;
 
+    for (i = 0; i < ADAPTER_LORA_CLIENT_NUM; i ++) {
+        memset(&client_recv_data_format[i], 0, sizeof(struct LoraDataFormat));
+    }
+
     //set lora_send_buf for test
     uint8_t lora_send_buf[ADAPTER_LORA_DATA_LENGTH];
     memset(lora_send_buf, 0, ADAPTER_LORA_DATA_LENGTH);
     sprintf(lora_send_buf, "Lora client %d adapter test\n", client->client_id);
 
     while (1) {
+        //Condition 1: Gateway send user_data cmd, client send user_data after receiving user_data cmd
+#ifdef GATEWAY_CMD_MODE
+        ret = LoraClientDataAnalyze(lora_adapter, (void *)lora_send_buf, strlen(lora_send_buf), 0);
+        if (ret < 0) {
+            printf("LoraClientDataAnalyze error, wait for next data cmd\n");
+            continue;
+        }
+        PrivTaskDelay(2000);
+#endif
+        //Condition 2: client send user_data automatically
+#ifdef CLIENT_UPDATE_MODE
+        if (lora_send_buf) {
+            PrivTaskDelay(2000);
+            printf("LoraClientSendData\n");
+            LoraClientSendData(lora_adapter, (void *)lora_send_buf, strlen(lora_send_buf), 0);
+        }
+#endif
+    }
 
-        PrivTaskDelay(100);
+    return 0;
+}
+
+/**
+ * @description: Lora Client join task
+ * @param parameter - Lora adapter pointer
+ */
+static void *LoraClientJoinTask(void *parameter)
+{
+    int ret = 0;
+    struct Adapter *lora_adapter = (struct Adapter *)parameter;
+    struct LoraClientParam *client = (struct LoraClientParam *)lora_adapter->adapter_param;
+
+    while (1) {
+        PrivTaskDelay(5000);
 
         if ((CLIENT_DISCONNECT == client->client_state) && (!g_adapter_lora_quit_flag)) {
             ret = LoraClientJoinNet(lora_adapter, client->panid);
             if (ret < 0) {
                 printf("LoraClientJoinNet error panid 0x%x\n", client->panid);
             }
-
-            ret = LoraClientDataAnalyze(lora_adapter, NULL, 0, 0);
-            if (ret < 0) {
-                printf("LoraClientDataAnalyze error, reconnect to gateway\n");
-                PrivTaskDelay(500);
-                continue;
-            }
-        }
-
-        if (CLIENT_CONNECT == client->client_state) {
-            //Condition 1: Gateway send user_data cmd, client send user_data after receiving user_data cmd
-#ifdef GATEWAY_CMD_MODE
-            ret = LoraClientDataAnalyze(lora_adapter, (void *)lora_send_buf, strlen(lora_send_buf), 0);
-            if (ret < 0) {
-                printf("LoraClientDataAnalyze error, wait for next data cmd\n");
-                PrivTaskDelay(500);
-                continue;
-            }
-#endif
-            //Condition 2: client send user_data automatically
-#ifdef CLIENT_UPDATE_MODE
-            if (lora_send_buf) {
-                PrivTaskDelay(2000);
-                printf("LoraClientSendData\n");
-                LoraClientSendData(lora_adapter, (void *)lora_send_buf, strlen(lora_send_buf), 0);
-            }
-#endif
         }
     }
 
@@ -829,7 +856,6 @@ static void *LoraClientQuitTask(void *parameter)
             ret = LoraClientDataAnalyze(lora_adapter, NULL, 0, 0);
             if (ret < 0) {
                 printf("LoraClientQuitTask LoraClientDataAnalyze error\n");
-                PrivTaskDelay(500);
                 continue;
             }
         }
@@ -945,14 +971,23 @@ int AdapterLoraInit(void)
     adapter->done = product_info->model_done;
 #endif
 
+    PrivSemaphoreCreate(&adapter->sem, 0, 0);
+
+    PrivSemaphoreCreate(&gateway_recv_data_sem, 0, 0);
+
+    PrivMutexCreate(&adapter->lock, 0);
+
     return ret;
 }
 
 /******************Lora TEST*********************/
+static pthread_t lora_recv_data_task;
+
 #ifdef AS_LORA_GATEWAY_ROLE
 static pthread_t lora_gateway_task;
 #else //AS_LORA_CLIENT_ROLE
 static pthread_t lora_client_data_task;
+static pthread_t lora_client_join_task;
 static pthread_t lora_client_quit_task;
 #endif
 
@@ -974,6 +1009,15 @@ int AdapterLoraTest(void)
     lora_gateway_attr.stacksize = 2048;
 #endif
 
+    PrivTaskCreate(&lora_recv_data_task, &lora_gateway_attr, &LoraReceiveTask, (void *)adapter);
+    PrivTaskStartup(&lora_recv_data_task);
+
+#ifdef ADD_NUTTX_FETURES
+    lora_gateway_attr.priority = 19;
+#else   
+    lora_gateway_attr.schedparam.sched_priority = 19;
+#endif
+
     PrivTaskCreate(&lora_gateway_task, &lora_gateway_attr, &LoraGatewayTask, (void *)adapter);
     PrivTaskStartup(&lora_gateway_task);
 
@@ -987,12 +1031,24 @@ int AdapterLoraTest(void)
     lora_client_attr.schedparam.sched_priority = 20;
     lora_client_attr.stacksize = 2048;
 #endif
+    PrivTaskCreate(&lora_recv_data_task, &lora_client_attr, &LoraReceiveTask, (void *)adapter);
+    PrivTaskStartup(&lora_recv_data_task);
+
+#ifdef ADD_NUTTX_FETURES
+    lora_client_attr.priority = 19;
+#else   
+    lora_client_attr.schedparam.sched_priority = 19;
+#endif
+
     //create lora client task
     PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)adapter);
     PrivTaskStartup(&lora_client_data_task);
 
     lora_client_attr.stacksize = 1024;
 
+    PrivTaskCreate(&lora_client_join_task, &lora_client_attr, &LoraClientJoinTask, (void *)adapter);
+    PrivTaskStartup(&lora_client_join_task);
+
     PrivTaskCreate(&lora_client_quit_task, &lora_client_attr, &LoraClientQuitTask, (void *)adapter);
     PrivTaskStartup(&lora_client_quit_task);
 #endif
diff --git a/APP_Framework/Framework/connection/lora/e220/e220.c b/APP_Framework/Framework/connection/lora/e220/e220.c
index 1322a9816..cbc738a61 100644
--- a/APP_Framework/Framework/connection/lora/e220/e220.c
+++ b/APP_Framework/Framework/connection/lora/e220/e220.c
@@ -290,7 +290,7 @@ static int E220Open(struct Adapter *adapter)
 #endif
 
     //serial receive timeout 100s
-    cfg.serial_timeout = 100000;
+    cfg.serial_timeout = 10000;
 
     struct PrivIoctlCfg ioctl_cfg;
     ioctl_cfg.ioctl_driver_type = SERIAL_TYPE;
@@ -397,12 +397,9 @@ static int E220Recv(struct Adapter *adapter, void *buf, size_t len)
     recv_len = PrivRead(adapter->fd, recv_buf, len);
     if (recv_len) {
         while (recv_len < len) {
-            printf("recv_len %u len %u\n", recv_len, len);
             recv_len_continue = PrivRead(adapter->fd, recv_buf + recv_len, len - recv_len);
             if (recv_len_continue) {
-                printf("recv_len_continue %u\n", recv_len_continue);
                 recv_len += recv_len_continue;
-                printf("recv_len done %u\n", recv_len);
             } else {
                 recv_len = 0;
                 break;