developer
/
xiuos
forked from xuos/xiuos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

optimize adapter lora send-receive and add recv-data-error solution

This commit is contained in:
Liu_Weichao 2022-04-28 17:57:20 +08:00
parent 32bce719f6
commit a58e744c45
3 changed files with 261 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
APP_Framework/Framework/connection/adapter.h
View File

@ -190,6 +190,9 @@ struct Adapter
void *done; void *done;
void *adapter_param; void *adapter_param;
sem_t sem;
pthread_mutex_t lock;
struct DoublelistNode link; struct DoublelistNode link;
}; };

458
APP_Framework/Framework/connection/lora/adapter_lora.c
View File

@ -28,9 +28,11 @@ extern AdapterProductInfoType Sx1278Attach(struct Adapter *adapter);
extern AdapterProductInfoType E220Attach(struct Adapter *adapter); extern AdapterProductInfoType E220Attach(struct Adapter *adapter);
#endif #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 //LORA single transfer data max size 128 bytes: data format 16 bytes and user data 112 bytes
#define ADAPTER_LORA_DATA_LENGTH 112 #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_TYPE_CMD 0x0F
#define ADAPTER_LORA_DATA_END 0x5A #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 //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 //eg.can also use sem to trigger quit function
static int g_adapter_lora_quit_flag = 0; static int g_adapter_lora_quit_flag = 0;
@ -71,8 +75,6 @@ enum LoraGatewayState {
LORA_RECV_DATA, LORA_RECV_DATA,
}; };
static uint8_t LoraGatewayState = LORA_STATE_IDLE;
struct LoraGatewayParam struct LoraGatewayParam
{ {
uint8_t gateway_id; uint8_t gateway_id;
@ -117,6 +119,14 @@ struct LoraDataFormat
uint16_t flame_end; 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***********************/ /*******************LORA MESH FUNCTION***********************/
/** /**
@ -160,36 +170,6 @@ static int LoraCrc16Check(uint8_t *data, uint16_t length)
return -1; 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 * @description: Lora Gateway reply connect request to Client
* @param adapter Lora adapter pointer * @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*/ /*User needs to handle client data depends on the requirement*/
printf("Lora Gateway receive Client %d data:\n", gateway_recv_data->client_id); printf("Lora Gateway receive Client %d data:\n", gateway_recv_data->client_id);
printf("%s\n", gateway_recv_data->data); printf("%s\n", gateway_recv_data->data);
PrivSemaphoreAbandon(&gateway_recv_data_sem);
return 0; return 0;
} }
@ -428,29 +410,32 @@ static int LoraClientSendData(struct Adapter *adapter, void *send_buf, int lengt
/** /**
* @description: Lora Gateway receive data analyzing * @description: Lora Gateway receive data analyzing
* @param adapter Lora adapter pointer * @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; 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) { if (ADAPTER_LORA_NET_PANID == gateway_recv_data_format.panid) {
switch (gateway_recv_data->data_type)
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_JOIN :
case ADAPTER_LORA_DATA_TYPE_QUIT : case ADAPTER_LORA_DATA_TYPE_QUIT :
ret = LoraGatewayReply(adapter, gateway_recv_data); ret = LoraGatewayReply(adapter, &gateway_recv_data_format);
break; break;
case ADAPTER_LORA_DATA_TYPE_USERDATA : case ADAPTER_LORA_DATA_TYPE_USERDATA :
ret = LoraGatewayHandleData(adapter, gateway_recv_data); ret = LoraGatewayHandleData(adapter, &gateway_recv_data_format);
break; break;
default: default:
break; break;
} }
} else {
ret = -1;
} }
return ret; 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) static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int length, uint16_t index)
{ {
int ret = 0; int ret = 0;
uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH]; uint8_t client_id = adapter->net_role_id;
struct LoraDataFormat *client_recv_data = PrivMalloc(sizeof(struct LoraDataFormat));
memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH); ret = PrivSemaphoreObtainWait(&adapter->sem, NULL);
memset(client_recv_data, 0, sizeof(struct LoraDataFormat)); if (0 == ret) {
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) {
//only handle this client_id information from gateway //only handle this client_id information from gateway
if (client_recv_data->client_id == adapter->net_role_id) { if ((client_recv_data_format[client_id - 1].client_id == adapter->net_role_id) &&
switch (client_recv_data->data_type) (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_JOIN_REPLY :
case ADAPTER_LORA_DATA_TYPE_QUIT_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; break;
case ADAPTER_LORA_DATA_TYPE_CMD : case ADAPTER_LORA_DATA_TYPE_CMD :
if (send_buf) { if (send_buf) {
@ -509,10 +478,12 @@ static int LoraClientDataAnalyze(struct Adapter *adapter, void *send_buf, int le
default: default:
break; break;
} }
//Client operation done
memset(&client_recv_data_format[client_id - 1], 0 , sizeof(struct LoraDataFormat));
} }
} }
PrivFree(client_recv_data);
return ret; return ret;
} }
@ -611,125 +582,171 @@ static int LoraClientQuitNet(struct Adapter *adapter, unsigned short panid)
} }
/** /**
* @description: Lora Gateway Process function * @description: Lora receive data check
* @param lora_adapter Lora adapter pointer * @param adapter Lora adapter pointer
* @param gateway Lora gateway pointer * @param recv_data receive data buffer
* @param gateway_recv_data Lora gateway receive data pointer * @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; int i, ret = 0;
uint8_t lora_recv_data[ADAPTER_LORA_TRANSFER_DATA_LENGTH]; struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)adapter->adapter_param;
switch (LoraGatewayState)
{
case LORA_STATE_IDLE:
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 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 #ifdef GATEWAY_CMD_MODE
for (i = 0; i < gateway->client_num; i ++) { for (i = 0; i < gateway->client_num; i ++) {
if (gateway->client_id[i]) { if (gateway->client_id[i]) {
printf("LoraGatewayProcess send to client %d for data\n", 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); ret = LoraGatewaySendCmd(adapter, gateway->client_id[i], ADAPTER_LORA_DATA_TYPE_CMD);
if (ret < 0) { if (ret < 0) {
printf("LoraGatewaySendCmd client ID %d error\n", gateway->client_id[i]); printf("LoraGatewaySendCmd client ID %d error\n", gateway->client_id[i]);
PrivTaskDelay(500); continue;
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);
}
}
} }
} }
}
#endif #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); memset(lora_recv_data, 0, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH); ret = AdapterDeviceRecv(lora_adapter, lora_recv_data, ADAPTER_LORA_TRANSFER_DATA_LENGTH);
if (ret <= 0) { if (ret <= 0) {
printf("LoraGatewayProcess recv error.Just return\n"); printf("AdapterDeviceRecv error.Just return\n");
break; 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) { if (ret < 0) {
printf("LoraReceiveDataCheck recv error.Just return\n"); printf("LoraReceiveDataCheck recv error.Just return\n");
break; continue;
} }
if (ADAPTER_LORA_DATA_TYPE_JOIN == gateway_recv_data->data_type) { PrivSemaphoreAbandon(&lora_adapter->sem);
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;
} }
return 0; 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 * @description: Lora Gateway task
* @param parameter - Lora adapter pointer * @param parameter - Lora adapter pointer
@ -740,10 +757,11 @@ static void *LoraGatewayTask(void *parameter)
int ret = 0; int ret = 0;
struct Adapter *lora_adapter = (struct Adapter *)parameter; struct Adapter *lora_adapter = (struct Adapter *)parameter;
struct LoraGatewayParam *gateway = (struct LoraGatewayParam *)lora_adapter->adapter_param; 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) { while (1) {
LoraGatewayProcess(lora_adapter, gateway, &gateway_recv_data); LoraGatewayProcess(lora_adapter, gateway);
} }
return 0; return 0;
@ -759,47 +777,56 @@ static void *LoraClientDataTask(void *parameter)
struct Adapter *lora_adapter = (struct Adapter *)parameter; struct Adapter *lora_adapter = (struct Adapter *)parameter;
struct LoraClientParam *client = (struct LoraClientParam *)lora_adapter->adapter_param; 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 //set lora_send_buf for test
uint8_t 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); memset(lora_send_buf, 0, ADAPTER_LORA_DATA_LENGTH);
sprintf(lora_send_buf, "Lora client %d adapter test\n", client->client_id); sprintf(lora_send_buf, "Lora client %d adapter test\n", client->client_id);
while (1) { 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)) { if ((CLIENT_DISCONNECT == client->client_state) && (!g_adapter_lora_quit_flag)) {
ret = LoraClientJoinNet(lora_adapter, client->panid); ret = LoraClientJoinNet(lora_adapter, client->panid);
if (ret < 0) { if (ret < 0) {
printf("LoraClientJoinNet error panid 0x%x\n", client->panid); 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); ret = LoraClientDataAnalyze(lora_adapter, NULL, 0, 0);
if (ret < 0) { if (ret < 0) {
printf("LoraClientQuitTask LoraClientDataAnalyze error\n"); printf("LoraClientQuitTask LoraClientDataAnalyze error\n");
PrivTaskDelay(500);
continue; continue;
} }
} }
@ -945,14 +971,23 @@ int AdapterLoraInit(void)
adapter->done = product_info->model_done; adapter->done = product_info->model_done;
#endif #endif
PrivSemaphoreCreate(&adapter->sem, 0, 0);
PrivSemaphoreCreate(&gateway_recv_data_sem, 0, 0);
PrivMutexCreate(&adapter->lock, 0);
return ret; return ret;
} }
/******************Lora TEST*********************/ /******************Lora TEST*********************/
static pthread_t lora_recv_data_task;
#ifdef AS_LORA_GATEWAY_ROLE #ifdef AS_LORA_GATEWAY_ROLE
static pthread_t lora_gateway_task; static pthread_t lora_gateway_task;
#else //AS_LORA_CLIENT_ROLE #else //AS_LORA_CLIENT_ROLE
static pthread_t lora_client_data_task; static pthread_t lora_client_data_task;
static pthread_t lora_client_join_task;
static pthread_t lora_client_quit_task; static pthread_t lora_client_quit_task;
#endif #endif
@ -974,6 +1009,15 @@ int AdapterLoraTest(void)
lora_gateway_attr.stacksize = 2048; lora_gateway_attr.stacksize = 2048;
#endif #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); PrivTaskCreate(&lora_gateway_task, &lora_gateway_attr, &LoraGatewayTask, (void *)adapter);
PrivTaskStartup(&lora_gateway_task); PrivTaskStartup(&lora_gateway_task);
@ -987,12 +1031,24 @@ int AdapterLoraTest(void)
lora_client_attr.schedparam.sched_priority = 20; lora_client_attr.schedparam.sched_priority = 20;
lora_client_attr.stacksize = 2048; lora_client_attr.stacksize = 2048;
#endif #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 //create lora client task
PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)adapter); PrivTaskCreate(&lora_client_data_task, &lora_client_attr, &LoraClientDataTask, (void *)adapter);
PrivTaskStartup(&lora_client_data_task); PrivTaskStartup(&lora_client_data_task);
lora_client_attr.stacksize = 1024; 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); PrivTaskCreate(&lora_client_quit_task, &lora_client_attr, &LoraClientQuitTask, (void *)adapter);
PrivTaskStartup(&lora_client_quit_task); PrivTaskStartup(&lora_client_quit_task);
#endif #endif

5
APP_Framework/Framework/connection/lora/e220/e220.c
View File

@ -290,7 +290,7 @@ static int E220Open(struct Adapter *adapter)
#endif #endif
//serial receive timeout 100s //serial receive timeout 100s
cfg.serial_timeout = 100000; cfg.serial_timeout = 10000;
struct PrivIoctlCfg ioctl_cfg; struct PrivIoctlCfg ioctl_cfg;
ioctl_cfg.ioctl_driver_type = SERIAL_TYPE; 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); recv_len = PrivRead(adapter->fd, recv_buf, len);
if (recv_len) { if (recv_len) {
while (recv_len < 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); recv_len_continue = PrivRead(adapter->fd, recv_buf + recv_len, len - recv_len);
if (recv_len_continue) { if (recv_len_continue) {
printf("recv_len_continue %u\n", recv_len_continue);
recv_len += recv_len_continue; recv_len += recv_len_continue;
printf("recv_len done %u\n", recv_len);
} else { } else {
recv_len = 0; recv_len = 0;
break; break;