diff --git a/APP_Framework/Framework/connection/lora/adapter_lora.c b/APP_Framework/Framework/connection/lora/adapter_lora.c
index 397e89e26..2cf9e25fe 100644
--- a/APP_Framework/Framework/connection/lora/adapter_lora.c
+++ b/APP_Framework/Framework/connection/lora/adapter_lora.c
@@ -30,7 +30,7 @@ extern AdapterProductInfoType E220Attach(struct Adapter *adapter);
 
 #define ADAPTER_LORA_CLIENT_NUM 255
 #define ADAPTER_LORA_DATA_LENGTH 256
-#define ADAPTER_LORA_RECV_DATA_LENGTH ADAPTER_LORA_DATA_LENGTH + 16
+#define ADAPTER_LORA_TRANSFER_DATA_LENGTH ADAPTER_LORA_DATA_LENGTH + 16
 
 #define ADAPTER_LORA_DATA_HEAD            0x3C
 #define ADAPTER_LORA_NET_PANID            0x0102
@@ -40,6 +40,7 @@ extern AdapterProductInfoType E220Attach(struct Adapter *adapter);
 #define ADAPTER_LORA_DATA_TYPE_QUIT_REPLY 0x0D
 #define ADAPTER_LORA_DATA_TYPE_USERDATA   0x0E
 #define ADAPTER_LORA_DATA_TYPE_CMD        0x0F
+#define ADAPTER_LORA_DATA_END             0x5A
 
 //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
@@ -66,28 +67,28 @@ enum LoraGatewayState {
     LORA_RECV_DATA,
 };
 
-static uint8 LoraGatewayState = LORA_STATE_IDLE;
+static uint8_t LoraGatewayState = LORA_STATE_IDLE;
 
 struct LoraGatewayParam 
 {
-    uint8 gateway_id;
-    uint16 panid;
-    uint8 client_id[ADAPTER_LORA_CLIENT_NUM];
+    uint8_t gateway_id;
+    uint16_t panid;
+    uint8_t client_id[ADAPTER_LORA_CLIENT_NUM];
     int client_num;
     int receive_data_sem;
 };
 
 struct LoraClientParam 
 {
-    uint8 client_id;
-    uint16 panid;
+    uint8_t client_id;
+    uint16_t panid;
     enum ClientState client_state;
 
-    uint8 gateway_id;
+    uint8_t gateway_id;
 };
 
 /*LoraDataFormat:
-**flame_head : 0x3C
+**flame_head : 0x3C3C
 **length     : sizeof(struct LoraDataFormat)
 **panid      : 0x0102
 **client_id  : 0x01、0x02、0x03...
@@ -95,21 +96,21 @@ struct LoraClientParam
 **data_type  : 0x0A(join net, client->gateway)、0x0B(join net reply, gateway->client)、
                0x0C(user data, client->gateway)、0x0D(user data cmd, gateway->client)
 **data       : user data
-**crc16      : CRC 16 check data
+**flame_end  : 0x5A5A
 */
 struct LoraDataFormat
 {
-    uint8 flame_head;
-    uint8 reserved[3];
-    uint32 length;
-    uint16 panid;
-    uint8 client_id;
-    uint8 gateway_id;
+    uint16_t flame_head;
+    uint16_t flame_index;
+    uint32_t length;
+    uint16_t panid;
+    uint8_t client_id;
+    uint8_t gateway_id;
 
-    uint16 data_type;
-    uint8 data[ADAPTER_LORA_DATA_LENGTH];
+    uint16_t data_type;
+    uint8_t data[ADAPTER_LORA_DATA_LENGTH];
 
-    uint16 crc16;
+    uint16_t flame_end;
 };
 
 /*******************LORA MESH FUNCTION***********************/
@@ -119,10 +120,10 @@ struct LoraDataFormat
  * @param data input data buffer
  * @param length input data buffer minus check code
  */
-static uint16 LoraCrc16(uint8 *data, uint16 length)
+static uint16_t LoraCrc16(uint8_t *data, uint16_t length)
 {
     int j;
-    uint16 crc_data = 0xFFFF;
+    uint16_t crc_data = 0xFFFF;
     
     while (length--) {
         crc_data ^= *data++;
@@ -142,10 +143,10 @@ static uint16 LoraCrc16(uint8 *data, uint16 length)
  * @param data input data buffer
  * @param length input data buffer minus check code
  */
-static int LoraCrc16Check(uint8 *data, uint16 length)
+static int LoraCrc16Check(uint8_t *data, uint16_t length)
 {
-    uint16 crc_data;
-    uint16 input_data = (((uint16)data[length - 1] << 8) & 0xFF00) | ((uint16)data[length - 2] & 0x00FF);
+    uint16_t crc_data;
+    uint16_t input_data = (((uint16_t)data[length - 1] << 8) & 0xFF00) | ((uint16_t)data[length - 2] & 0x00FF);
 
     crc_data = LoraCrc16(data, length - 2);
 
@@ -157,22 +158,29 @@ static int LoraCrc16Check(uint8 *data, uint16 length)
 
 /**
  * @description: Lora receive data check
- * @param data receive data buffer
+ * @param recv_data receive data buffer
  * @param length receive data length
- * @param recv_data LoraDataFormat data
+ * @param lora_data_format LoraDataFormat data
  */
-static int LoraReceiveDataCheck(uint8 *data, uint16 length, struct LoraDataFormat *recv_data)
+static int LoraReceiveDataCheck(uint8_t *recv_data, uint16_t length, struct LoraDataFormat *lora_data_format)
 {
-    int i;
-    uint32 recv_data_length = 0;
-    for ( i = 0; i < length; i ++) {
-        if (ADAPTER_LORA_DATA_HEAD == data[i]) {
-            recv_data_length = (data[i + 4] & 0xFF) | ((data[i + 5] & 0xFF) << 8) | ((data[i + 6] & 0xFF) << 16) | ((data[i + 7] & 0xFF) << 24);
-            if (sizeof(struct LoraDataFormat) == recv_data_length) {
-                memcpy(recv_data, (uint8 *)(data + i), sizeof(struct LoraDataFormat));
-                return 0;
-            }
-        }
+    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;
@@ -187,10 +195,13 @@ static int LoraGatewayReply(struct Adapter *adapter, struct LoraDataFormat *gate
 {
     int i;
     int client_join_flag = 0;
+    uint16_t gateway_data_type;
+    uint32_t gateway_reply_length = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
     struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)adapter->adapter_param;
-    struct LoraDataFormat gateway_reply_data;
 
-    memset(&gateway_reply_data, 0, sizeof(struct LoraDataFormat));
+    uint8_t gateway_reply_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
+
+    memset(gateway_reply_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
 
     if (ADAPTER_LORA_DATA_TYPE_JOIN == gateway_recv_data->data_type) {
         
@@ -211,15 +222,27 @@ static int LoraGatewayReply(struct Adapter *adapter, struct LoraDataFormat *gate
             gateway->client_num ++;
         }
 
-        gateway_reply_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-        gateway_reply_data.length = sizeof(struct LoraDataFormat);
-        gateway_reply_data.panid = gateway->panid;
-        gateway_reply_data.data_type = ADAPTER_LORA_DATA_TYPE_JOIN_REPLY;
-        gateway_reply_data.client_id = gateway_recv_data->client_id;
-        gateway_reply_data.gateway_id = gateway->gateway_id;
-        gateway_reply_data.crc16 = LoraCrc16((uint8 *)&gateway_reply_data, sizeof(struct LoraDataFormat) - 2);
-        
-        if (AdapterDeviceSend(adapter, (uint8 *)&gateway_reply_data, gateway_reply_data.length) < 0) {
+        gateway_data_type = ADAPTER_LORA_DATA_TYPE_JOIN_REPLY;
+
+        gateway_reply_data[0] = ADAPTER_LORA_DATA_HEAD;
+        gateway_reply_data[1] = ADAPTER_LORA_DATA_HEAD;
+        gateway_reply_data[2] = 0;
+        gateway_reply_data[3] = 0;
+        gateway_reply_data[4] = (gateway_reply_length >> 24) & 0xFF;
+        gateway_reply_data[5] = (gateway_reply_length >> 16) & 0xFF;
+        gateway_reply_data[6] = (gateway_reply_length >> 8) & 0xFF;
+        gateway_reply_data[7] = gateway_reply_length & 0xFF;
+        gateway_reply_data[8] = (gateway->panid >> 8) & 0xFF;
+        gateway_reply_data[9] = gateway->panid & 0xFF;
+        gateway_reply_data[10] = gateway_recv_data->client_id;
+        gateway_reply_data[11] = gateway->gateway_id;
+        gateway_reply_data[12] = (gateway_data_type >> 8) & 0xFF;
+        gateway_reply_data[13] = gateway_data_type & 0xFF;
+
+        gateway_reply_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+        gateway_reply_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
+
+        if (AdapterDeviceSend(adapter, gateway_reply_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH) < 0) {
             return -1;
         }
 
@@ -233,15 +256,27 @@ static int LoraGatewayReply(struct Adapter *adapter, struct LoraDataFormat *gate
             }
         }
 
-        gateway_reply_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-        gateway_reply_data.length = sizeof(struct LoraDataFormat);
-        gateway_reply_data.panid = gateway->panid;
-        gateway_reply_data.data_type = ADAPTER_LORA_DATA_TYPE_QUIT_REPLY;
-        gateway_reply_data.client_id = gateway_recv_data->client_id;
-        gateway_reply_data.gateway_id = gateway->gateway_id;
-        gateway_reply_data.crc16 = LoraCrc16((uint8 *)&gateway_reply_data, sizeof(struct LoraDataFormat) - 2);
-        
-        if (AdapterDeviceSend(adapter, (uint8 *)&gateway_reply_data, gateway_reply_data.length) < 0) {
+        gateway_data_type = ADAPTER_LORA_DATA_TYPE_QUIT_REPLY;
+
+        gateway_reply_data[0] = ADAPTER_LORA_DATA_HEAD;
+        gateway_reply_data[1] = ADAPTER_LORA_DATA_HEAD;
+        gateway_reply_data[2] = 0;
+        gateway_reply_data[3] = 0;
+        gateway_reply_data[4] = (gateway_reply_length >> 24) & 0xFF;
+        gateway_reply_data[5] = (gateway_reply_length >> 16) & 0xFF;
+        gateway_reply_data[6] = (gateway_reply_length >> 8) & 0xFF;
+        gateway_reply_data[7] = gateway_reply_length & 0xFF;
+        gateway_reply_data[8] = (gateway->panid >> 8) & 0xFF;
+        gateway_reply_data[9] = gateway->panid & 0xFF;
+        gateway_reply_data[10] = gateway_recv_data->client_id;
+        gateway_reply_data[11] = gateway->gateway_id;
+        gateway_reply_data[12] = (gateway_data_type >> 8) & 0xFF;
+        gateway_reply_data[13] = gateway_data_type & 0xFF;
+
+        gateway_reply_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+        gateway_reply_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
+
+        if (AdapterDeviceSend(adapter, gateway_reply_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH) < 0) {
             return -1;
         }
 
@@ -257,22 +292,36 @@ static int LoraGatewayReply(struct Adapter *adapter, struct LoraDataFormat *gate
  * @param client_id Lora Client id
  * @param cmd Lora cmd
  */
-static int LoraGatewaySendCmd(struct Adapter *adapter, unsigned char client_id, int cmd)
+static int LoraGatewaySendCmd(struct Adapter *adapter, uint8_t client_id, uint16_t cmd)
 {
     struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)adapter->adapter_param;
-    struct LoraDataFormat gateway_cmd_data;
+    uint16_t gateway_cmd_type;
+    uint32_t gateway_cmd_length = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    uint8_t gateway_cmd_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
 
-    memset(&gateway_cmd_data, 0, sizeof(struct LoraDataFormat));
+    memset(gateway_cmd_data, 0, sizeof(struct LoraDataFormat));
 
-    gateway_cmd_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-    gateway_cmd_data.length = sizeof(struct LoraDataFormat);
-    gateway_cmd_data.panid = gateway->panid;
-    gateway_cmd_data.data_type = cmd;
-    gateway_cmd_data.client_id = client_id;
-    gateway_cmd_data.gateway_id = gateway->gateway_id;
-    gateway_cmd_data.crc16 = LoraCrc16((uint8 *)&gateway_cmd_data, sizeof(struct LoraDataFormat) - 2);
+    gateway_cmd_type = cmd;
+
+    gateway_cmd_data[0] = ADAPTER_LORA_DATA_HEAD;
+    gateway_cmd_data[1] = ADAPTER_LORA_DATA_HEAD;
+    gateway_cmd_data[2] = 0;
+    gateway_cmd_data[3] = 0;
+    gateway_cmd_data[4] = (gateway_cmd_length >> 24) & 0xFF;
+    gateway_cmd_data[5] = (gateway_cmd_length >> 16) & 0xFF;
+    gateway_cmd_data[6] = (gateway_cmd_length >> 8) & 0xFF;
+    gateway_cmd_data[7] = gateway_cmd_length & 0xFF;
+    gateway_cmd_data[8] = (gateway->panid >> 8) & 0xFF;
+    gateway_cmd_data[9] = gateway->panid & 0xFF;
+    gateway_cmd_data[10] = client_id;
+    gateway_cmd_data[11] = gateway->gateway_id;
+    gateway_cmd_data[12] = (gateway_cmd_type >> 8) & 0xFF;
+    gateway_cmd_data[13] = gateway_cmd_type & 0xFF;
+
+    gateway_cmd_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+    gateway_cmd_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
     
-    if (AdapterDeviceSend(adapter, (uint8 *)&gateway_cmd_data, gateway_cmd_data.length) < 0) {
+    if (AdapterDeviceSend(adapter, gateway_cmd_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH) < 0) {
         return -1;
     }
 
@@ -321,8 +370,9 @@ static int LoraClientUpdate(struct Adapter *adapter, struct LoraDataFormat *clie
  * @param adapter Lora adapter pointer
  * @param send_buf Lora Client send user data buf
  * @param length user data length (max size is ADAPTER_LORA_DATA_LENGTH)
+ * @param send_index user data index, max size ADAPTER_LORA_DATA_LENGTH single index
  */
-static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int length)
+static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int length, uint16_t send_index)
 {
     struct LoraClientParam *client = (struct LoraClientParam *)adapter->adapter_param;
 
@@ -336,22 +386,35 @@ static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int lengt
         return 0;
     }
 
-    struct LoraDataFormat client_user_data;
+    uint16_t client_user_type;
+    uint32_t client_user_length = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    uint8_t client_user_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
 
-    memset(&client_user_data, 0, sizeof(struct LoraDataFormat));
+    memset(client_user_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
 
-    client_user_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-    client_user_data.length = sizeof(struct LoraDataFormat);
-    client_user_data.panid = client->panid;
-    client_user_data.data_type = ADAPTER_LORA_DATA_TYPE_USERDATA;
-    client_user_data.client_id = client->client_id;
-    client_user_data.gateway_id = client->gateway_id;
+    client_user_type = ADAPTER_LORA_DATA_TYPE_USERDATA;
 
-    memcpy(client_user_data.data, (uint8 *)send_buf, length);
+    client_user_data[0] = ADAPTER_LORA_DATA_HEAD;
+    client_user_data[1] = ADAPTER_LORA_DATA_HEAD;
+    client_user_data[2] = (send_index >> 8) & 0xFF;
+    client_user_data[3] = send_index & 0xFF;
+    client_user_data[4] = (client_user_length >> 24) & 0xFF;
+    client_user_data[5] = (client_user_length >> 16) & 0xFF;
+    client_user_data[6] = (client_user_length >> 8) & 0xFF;
+    client_user_data[7] = client_user_length & 0xFF;
+    client_user_data[8] = (client->panid >> 8) & 0xFF;
+    client_user_data[9] = client->panid & 0xFF;
+    client_user_data[10] = client->client_id;
+    client_user_data[11] = client->gateway_id;
+    client_user_data[12] = (client_user_type >> 8) & 0xFF;
+    client_user_data[13] = client_user_type & 0xFF;
 
-    client_user_data.crc16 = LoraCrc16((uint8 *)&client_user_data, sizeof(struct LoraDataFormat) - 2);
+    memcpy((uint8_t *)(client_user_data + 14), (uint8_t *)send_buf, length);
+
+    client_user_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+    client_user_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
     
-    if (AdapterDeviceSend(adapter, (uint8 *)&client_user_data, client_user_data.length) < 0) {
+    if (AdapterDeviceSend(adapter, client_user_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH) < 0) {
         return -1;
     }
 
@@ -366,18 +429,12 @@ static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int lengt
 static int LoraGateWayDataAnalyze(struct Adapter *adapter, struct LoraDataFormat *gateway_recv_data)
 {
     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 crc 0x%x\n",
+    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->crc16);
+        gateway_recv_data->client_id, gateway_recv_data->gateway_id, gateway_recv_data->flame_end);
 
-    if (LoraCrc16Check((uint8 *)gateway_recv_data, sizeof(struct LoraDataFormat)) < 0) {
-        printf("LoraGateWayDataAnalyze CRC check error\n");
-        return -1;
-    }
-
-    if ((ADAPTER_LORA_DATA_HEAD == gateway_recv_data->flame_head) && 
-        (ADAPTER_LORA_NET_PANID == gateway_recv_data->panid)) {
+    if (ADAPTER_LORA_NET_PANID == gateway_recv_data->panid) {
         switch (gateway_recv_data->data_type)
         {
         case ADAPTER_LORA_DATA_TYPE_JOIN : 
@@ -400,38 +457,38 @@ static int LoraGateWayDataAnalyze(struct Adapter *adapter, struct LoraDataFormat
  * @param adapter Lora adapter pointer
  * @param send_buf Lora Client send user data buf
  * @param length user data length (max size is ADAPTER_LORA_DATA_LENGTH)
+ * @param index user data index, max size ADAPTER_LORA_DATA_LENGTH single index
  */
-static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int length)
+static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int length, uint16_t index)
 {
     int ret = 0;
-    uint8 lora_recv_data[ADAPTER_LORA_RECV_DATA_LENGTH] = {0};
+    uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
     
     struct LoraDataFormat *client_recv_data = PrivMalloc(sizeof(struct LoraDataFormat));
 
+    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_RECV_DATA_LENGTH);
+    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;
     }
 
-    LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_RECV_DATA_LENGTH, client_recv_data);
+    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 crc 0x%x\n",
+    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->crc16);
-
-    if ((ADAPTER_LORA_DATA_HEAD == client_recv_data->flame_head) && 
-        (ADAPTER_LORA_NET_PANID == client_recv_data->panid)) {
-        if (LoraCrc16Check((uint8 *)client_recv_data, sizeof(struct LoraDataFormat)) < 0) {
-            printf("LoraClientDataAnalyze CRC check error\n");
-            PrivFree(client_recv_data);
-            return -1;
-        }
+        client_recv_data->client_id, client_recv_data->gateway_id, client_recv_data->flame_end);
 
+    if (ADAPTER_LORA_NET_PANID == client_recv_data->panid) {
         //only handle this client_id information from gateway
         if (client_recv_data->client_id == adapter->net_role_id) {
             switch (client_recv_data->data_type)
@@ -442,7 +499,7 @@ static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int le
                 break;
             case ADAPTER_LORA_DATA_TYPE_CMD :
                 if (send_buf) {
-                    ret = LoraClientSendData(adapter, send_buf, length);
+                    ret = LoraClientSendData(adapter, send_buf, length, index);
                 }
                 break;
             default:
@@ -462,30 +519,43 @@ static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int le
  */
 static int LoraClientJoinNet(struct Adapter *adapter, unsigned short panid)
 {
-    struct LoraDataFormat client_join_data;
     struct AdapterData priv_lora_net;
 
-    memset(&client_join_data, 0, sizeof(struct LoraDataFormat));
+    uint16_t client_join_type;
+    uint32_t client_join_length = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    uint8_t client_join_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
 
-    client_join_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-    client_join_data.length = sizeof(struct LoraDataFormat);
-    client_join_data.panid = panid;
-    client_join_data.data_type = ADAPTER_LORA_DATA_TYPE_JOIN;
-    client_join_data.client_id = adapter->net_role_id;
-    client_join_data.crc16 = LoraCrc16((uint8 *)&client_join_data, sizeof(struct LoraDataFormat) - 2);
+    memset(client_join_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
 
-    printf("%s:client_join_data\n", __func__);
-    printf("head 0x%x length %d panid 0x%x data_type 0x%x client_id 0x%x gateway_id 0x%x crc 0x%x\n",
-        client_join_data.flame_head, client_join_data.length, client_join_data.panid, client_join_data.data_type,
-        client_join_data.client_id, client_join_data.gateway_id, client_join_data.crc16);
-    
-    priv_lora_net.len = sizeof(struct LoraDataFormat);
-    priv_lora_net.buffer = (uint8 *)&client_join_data;
+    client_join_type = ADAPTER_LORA_DATA_TYPE_JOIN;
 
-    if (AdapterDeviceJoin(adapter, (uint8 *)&priv_lora_net) < 0) {
+    client_join_data[0] = ADAPTER_LORA_DATA_HEAD;
+    client_join_data[1] = ADAPTER_LORA_DATA_HEAD;
+    client_join_data[2] = 0;
+    client_join_data[3] = 0;
+    client_join_data[4] = (client_join_length >> 24) & 0xFF;
+    client_join_data[5] = (client_join_length >> 16) & 0xFF;
+    client_join_data[6] = (client_join_length >> 8) & 0xFF;
+    client_join_data[7] = client_join_length & 0xFF;
+    client_join_data[8] = (panid >> 8) & 0xFF;
+    client_join_data[9] = panid & 0xFF;
+    client_join_data[10] = adapter->net_role_id & 0xFF;
+    client_join_data[11] = 0;
+    client_join_data[12] = (client_join_type >> 8) & 0xFF;
+    client_join_data[13] = client_join_type & 0xFF;
+
+    client_join_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+    client_join_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
+
+    priv_lora_net.len = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    priv_lora_net.buffer = client_join_data;
+
+    if (AdapterDeviceJoin(adapter, (uint8_t *)&priv_lora_net) < 0) {
         return -1;
     }
 
+    printf("%s:client_join_data panid 0x%x client_id 0x%x\n", __func__, panid, adapter->net_role_id);
+
     return 0;
 }
 
@@ -496,25 +566,43 @@ static int LoraClientJoinNet(struct Adapter *adapter, unsigned short panid)
  */
 static int LoraClientQuitNet(struct Adapter *adapter, unsigned short panid)
 {
-    struct LoraDataFormat client_quit_data;
     struct AdapterData priv_lora_net;
 
-    memset(&client_quit_data, 0, sizeof(struct LoraDataFormat));
+    uint16_t client_quit_type;
+    uint32_t client_quit_length = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    uint8_t client_quit_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
 
-    client_quit_data.flame_head = ADAPTER_LORA_DATA_HEAD;
-    client_quit_data.length = sizeof(struct LoraDataFormat);
-    client_quit_data.panid = panid;
-    client_quit_data.data_type = ADAPTER_LORA_DATA_TYPE_QUIT;
-    client_quit_data.client_id = adapter->net_role_id;
-    client_quit_data.crc16 = LoraCrc16((uint8 *)&client_quit_data, sizeof(struct LoraDataFormat) - 2);
-    
-    priv_lora_net.len = sizeof(struct LoraDataFormat);
-    priv_lora_net.buffer = (uint8 *)&client_quit_data;
+    memset(client_quit_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
 
-    if (AdapterDeviceDisconnect(adapter, (uint8 *)&priv_lora_net) < 0) {
+    client_quit_type = ADAPTER_LORA_DATA_TYPE_QUIT;
+
+    client_quit_data[0] = ADAPTER_LORA_DATA_HEAD;
+    client_quit_data[1] = ADAPTER_LORA_DATA_HEAD;
+    client_quit_data[2] = 0;
+    client_quit_data[3] = 0;
+    client_quit_data[4] = (client_quit_length >> 24) & 0xFF;
+    client_quit_data[5] = (client_quit_length >> 16) & 0xFF;
+    client_quit_data[6] = (client_quit_length >> 8) & 0xFF;
+    client_quit_data[7] = client_quit_length & 0xFF;
+    client_quit_data[8] = (panid >> 8) & 0xFF;
+    client_quit_data[9] = panid & 0xFF;
+    client_quit_data[10] = adapter->net_role_id & 0xFF;
+    client_quit_data[11] = 0;
+    client_quit_data[12] = (client_quit_type >> 8) & 0xFF;
+    client_quit_data[13] = client_quit_type & 0xFF;
+
+    client_quit_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 2] = ADAPTER_LORA_DATA_END;
+    client_quit_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH - 1] = ADAPTER_LORA_DATA_END;
+
+    priv_lora_net.len = ADAPTER_LORA_TRANSFER_DATA_LENGTH;
+    priv_lora_net.buffer = client_quit_data;
+
+    if (AdapterDeviceDisconnect(adapter, (uint8_t *)&priv_lora_net) < 0) {
         return -1;
     }
 
+    printf("%s:client_quit_data panid 0x%x client_id 0x%x\n", __func__, panid, adapter->net_role_id);
+
     return 0;
 }
 
@@ -527,19 +615,25 @@ static int LoraClientQuitNet(struct Adapter *adapter, unsigned short panid)
 int LoraGatewayProcess(struct Adapter *lora_adapter, struct LoraGatewayParam *gateway, struct LoraDataFormat *gateway_recv_data)
 {
     int i, ret = 0;
-    uint8 lora_recv_data[ADAPTER_LORA_RECV_DATA_LENGTH];
+    uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH];
     switch (LoraGatewayState)
     {
     case LORA_STATE_IDLE:
-        memset(lora_recv_data, 0, ADAPTER_LORA_RECV_DATA_LENGTH);
+        memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
 
-        ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_RECV_DATA_LENGTH);
+        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;
         }
 
-        LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_RECV_DATA_LENGTH, gateway_recv_data);
+        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;
@@ -569,14 +663,18 @@ int LoraGatewayProcess(struct Adapter *lora_adapter, struct LoraGatewayParam *ga
                     continue;
                 }
 
-                memset(lora_recv_data, 0, ADAPTER_LORA_RECV_DATA_LENGTH);
-                ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_RECV_DATA_LENGTH);
+                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;
                 }
 
-                LoraReceiveDataCheck(lora_recv_data, ADAPTER_LORA_RECV_DATA_LENGTH, gateway_recv_data);
+                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;
@@ -629,7 +727,7 @@ static void *LoraClientDataTask(void *parameter)
     struct LoraClientParam *client = (struct LoraClientParam *)lora_adapter->adapter_param;
 
     //set lora_send_buf for test
-    uint8 lora_send_buf[ADAPTER_LORA_DATA_LENGTH];
+    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);
 
@@ -643,7 +741,7 @@ static void *LoraClientDataTask(void *parameter)
                 printf("LoraClientJoinNet error panid 0x%x\n", client->panid);
             }
 
-            ret = LoraClientDataAnalyze(lora_adapter, NULL, 0);
+            ret = LoraClientDataAnalyze(lora_adapter, NULL, 0, 0);
             if (ret < 0) {
                 printf("LoraClientDataAnalyze error, reconnect to gateway\n");
                 PrivTaskDelay(500);
@@ -652,12 +750,16 @@ static void *LoraClientDataTask(void *parameter)
         }
 
         if (CLIENT_CONNECT == client->client_state) {
-            ret = LoraClientDataAnalyze(lora_adapter, (void *)lora_send_buf, strlen(lora_send_buf));
+            //Condition 1: Gateway send user_data cmd, client send user_data after receiving user_data cmd
+            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;
             }
+
+            //Condition 2: client send user_data automatically
+            //to do
         }
     }
 
@@ -684,7 +786,7 @@ static void *LoraClientQuitTask(void *parameter)
                 continue;
             }
 
-            ret = LoraClientDataAnalyze(lora_adapter, NULL, 0);
+            ret = LoraClientDataAnalyze(lora_adapter, NULL, 0, 0);
             if (ret < 0) {
                 printf("LoraClientQuitTask LoraClientDataAnalyze error\n");
                 PrivTaskDelay(500);
diff --git a/APP_Framework/Framework/connection/lora/e220/e220.c b/APP_Framework/Framework/connection/lora/e220/e220.c
index 4b4c93caf..349900064 100644
--- a/APP_Framework/Framework/connection/lora/e220/e220.c
+++ b/APP_Framework/Framework/connection/lora/e220/e220.c
@@ -395,7 +395,7 @@ static int E220Recv(struct Adapter *adapter, void *buf, size_t 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);
+                printf("recv_len_continue %u\n", recv_len_continue);
                 recv_len += recv_len_continue;
                 printf("recv_len done %u\n", recv_len);
             } else {