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

add mutex protection for adapter agent

This commit is contained in:
Wang_Weigen 2021-11-22 17:50:27 +08:00
parent 5a8b6d79aa
commit 9d970e7832
5 changed files with 183 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
APP_Framework/Applications/ota/ota.c
View File

@ -240,6 +240,7 @@ static void *OtaKTaskEntry(void *parameter)
while(1) while(1)
{ {
int connect_times = 5;
ret = AdapterDeviceOpen(adapter); ret = AdapterDeviceOpen(adapter);
if(ret < 0) if(ret < 0)
{ {
@ -248,12 +249,18 @@ static void *OtaKTaskEntry(void *parameter)
} }
connect_again: connect_again:
connect_times--;
ret = AdapterDeviceConnect(adapter, 1, "115.238.53.61","9898",1); ret = AdapterDeviceConnect(adapter, 1, "115.238.53.61","9898",1);
if(ret < 0) if(ret < 0)
{ {
// AdapterDeviceClose(adapter); if(connect_times > 0){
// continue; goto connect_again;
goto connect_again; }
else
{
AdapterDeviceClose(adapter);
continue;
}
} }
break; break;
} }
@ -270,7 +277,7 @@ connect_again:
{ {
memset(reply, 0, 16); memset(reply, 0, 16);
memcpy(reply, "ready", strlen("ready")); memcpy(reply, "ready", strlen("ready"));
PrivTaskDelay(3000); // PrivTaskDelay(3000);
printf("receive start signal,send [ready] signal to server\n"); printf("receive start signal,send [ready] signal to server\n");
send_ready_again: send_ready_again:
ret = AdapterDeviceSend(adapter, reply, strlen(reply)); ret = AdapterDeviceSend(adapter, reply, strlen(reply));
@ -278,7 +285,7 @@ send_ready_again:
{ {
goto send_ready_again; goto send_ready_again;
} }
PrivTaskDelay(3000);
printf("start receive ota file.\n"); printf("start receive ota file.\n");
/* step2: start receive source bin file of application*/ /* step2: start receive source bin file of application*/
ret = OtaDataRecv(adapter); ret = OtaDataRecv(adapter);
@ -299,9 +306,10 @@ send_ready_again:
{ {
memset(reply, 0, 16); memset(reply, 0, 16);
memcpy(reply, "notready", strlen("notready")); memcpy(reply, "notready", strlen("notready"));
printf("ota status:not ready\n");
ret = AdapterDeviceSend(adapter, reply, strlen(reply)); ret = AdapterDeviceSend(adapter, reply, strlen(reply));
} }
PrivTaskDelay(3000); /* check ota signal every 3s */ PrivTaskDelay(5000); /* check ota signal every 5s */
} }
AdapterDeviceClose(adapter); AdapterDeviceClose(adapter);
@ -310,8 +318,8 @@ send_ready_again:
void ApplicationOtaTaskInit(void) void ApplicationOtaTaskInit(void)
{ {
pthread_attr_t attr; pthread_attr_t attr;
attr.schedparam.sched_priority = 10; attr.schedparam.sched_priority = 20;
attr.stacksize = 2048; attr.stacksize = 4096;
PrivTaskCreate(&ota_task, &attr, OtaKTaskEntry, NULL); PrivTaskCreate(&ota_task, &attr, OtaKTaskEntry, NULL);

2
APP_Framework/Applications/ota/ota_server.c
View File

@ -212,7 +212,7 @@ void* server_thread(void* p)
int ret = 0; int ret = 0;
printf("pthread = %d\n",fd); printf("pthread = %d\n",fd);
sleep(10); // sleep(5);
while(1) while(1)
{ {
memset(&data, 0 , sizeof(struct ota_data)); memset(&data, 0 , sizeof(struct ota_data));

71
APP_Framework/Framework/connection/adapter_agent.c
View File

@ -135,6 +135,7 @@ int ATOrderSend(ATAgentType agent, uint32 timeout_s, ATReplyType reply, const ch
abstime.tv_sec = timeout_s; abstime.tv_sec = timeout_s;
PrivMutexObtain(&agent->lock);
agent->receive_mode = AT_MODE; agent->receive_mode = AT_MODE;
memset(agent->maintain_buffer, 0x00, agent->maintain_max); memset(agent->maintain_buffer, 0x00, agent->maintain_max);
@ -147,10 +148,10 @@ int ATOrderSend(ATAgentType agent, uint32 timeout_s, ATReplyType reply, const ch
uint32 cmd_size = 0; uint32 cmd_size = 0;
uint32 result = EOK; uint32 result = EOK;
const char *cmd = NULL; const char *cmd = NULL;
PrivMutexObtain(&agent->lock);
agent->reply = reply; agent->reply = reply;
PrivMutexAbandon(&agent->lock);
if(agent->reply != NULL) { if(agent->reply != NULL) {
reply->reply_len = 0; reply->reply_len = 0;
va_start(params, cmd_expr); va_start(params, cmd_expr);
@ -169,8 +170,6 @@ int ATOrderSend(ATAgentType agent, uint32 timeout_s, ATReplyType reply, const ch
__out: __out:
// agent->reply = NULL; // agent->reply = NULL;
PrivMutexAbandon(&agent->lock);
return result; return result;
} }
@ -188,7 +187,12 @@ int AtCmdConfigAndCheck(ATAgentType agent, char *cmd, char *check)
ret = -1; ret = -1;
goto __exit; goto __exit;
} }
ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd); ret = ATOrderSend(agent, REPLY_TIME_OUT, reply, cmd);
if(ret < 0){
printf("%s %d ATOrderSend failed.\n",__func__,__LINE__);
ret = -1;
goto __exit;
}
// PrivTaskDelay(3000); // PrivTaskDelay(3000);
result = GetReplyText(reply); result = GetReplyText(reply);
@ -302,24 +306,31 @@ static int GetCompleteATReply(ATAgentType agent)
char ch = 0, last_ch = 0; char ch = 0, last_ch = 0;
bool is_full = false; bool is_full = false;
PrivMutexObtain(&agent->lock);
memset(agent->maintain_buffer, 0x00, agent->maintain_max); memset(agent->maintain_buffer, 0x00, agent->maintain_max);
agent->maintain_len = 0; agent->maintain_len = 0;
while (1) { PrivMutexAbandon(&agent->lock);
while (1)
{
PrivRead(agent->fd, &ch, 1); PrivRead(agent->fd, &ch, 1);
#ifdef CONNECTION_FRAMEWORK_DEBUG #ifdef CONNECTION_FRAMEWORK_DEBUG
printf("data[%d] %c (0x%x)\n",agent->maintain_len, ch, ch); // printf(" %c (0x%x)\n", ch, ch);
#endif #endif
if (agent->receive_mode == ENTM_MODE){
if (agent->entm_recv_len < ENTM_RECV_MAX) {
PrivMutexObtain(&agent->lock);
PrivMutexObtain(&agent->lock);
if (agent->receive_mode == ENTM_MODE)
{
if (agent->entm_recv_len < ENTM_RECV_MAX)
{
agent->entm_recv_buf[agent->entm_recv_len] = ch; agent->entm_recv_buf[agent->entm_recv_len] = ch;
agent->entm_recv_len++; agent->entm_recv_len++;
PrivMutexAbandon(&agent->lock); if (last_ch == '!' && ch == '@')
{
if (last_ch == '!' && ch == '@'){ agent->receive_mode = DEFAULT_MODE;
PrivSemaphoreAbandon(&agent->entm_rx_notice); PrivSemaphoreAbandon(&agent->entm_rx_notice);
} }
@ -327,8 +338,11 @@ static int GetCompleteATReply(ATAgentType agent)
} else { } else {
printf("entm_recv_buf is_full ...\n"); printf("entm_recv_buf is_full ...\n");
} }
} else if (agent->receive_mode == AT_MODE) { }
if (read_len < agent->maintain_max){ else if (agent->receive_mode == AT_MODE)
{
if (read_len < agent->maintain_max)
{
agent->maintain_buffer[read_len] = ch; agent->maintain_buffer[read_len] = ch;
read_len++; read_len++;
agent->maintain_len = read_len; agent->maintain_len = read_len;
@ -345,13 +359,18 @@ static int GetCompleteATReply(ATAgentType agent)
printf("read line failed. The line data length is out of buffer size(%d)!", agent->maintain_max); printf("read line failed. The line data length is out of buffer size(%d)!", agent->maintain_max);
memset(agent->maintain_buffer, 0x00, agent->maintain_max); memset(agent->maintain_buffer, 0x00, agent->maintain_max);
agent->maintain_len = 0; agent->maintain_len = 0;
PrivMutexAbandon(&agent->lock);
return -ERROR; return -ERROR;
} }
printf("GetCompleteATReply done\n"); printf("GetCompleteATReply done\n");
PrivMutexAbandon(&agent->lock);
agent->receive_mode = DEFAULT_MODE;
break; break;
} }
last_ch = ch; last_ch = ch;
} }
PrivMutexAbandon(&agent->lock);
} }
return read_len; return read_len;
@ -373,21 +392,27 @@ ATAgentType GetATAgent(const char *agent_name)
int DeleteATAgent(ATAgentType agent) int DeleteATAgent(ATAgentType agent)
{ {
printf("delete agent->at_handler = %d\n",agent->at_handler); printf("delete agent->at_handler = %d\n",agent->at_handler);
PrivTaskDelete(agent->at_handler, 0); if(agent->at_handler > 0){
PrivTaskDelete(agent->at_handler, 0);
}
if (agent->fd > 0) { if (agent->fd > 0) {
printf("close agent fd = %d\n",agent->fd);
PrivClose(agent->fd); PrivClose(agent->fd);
} }
if (agent->lock) { if (agent->lock) {
printf("delete agent lock = %d\n",agent->lock);
PrivMutexDelete(&agent->lock); PrivMutexDelete(&agent->lock);
} }
if (agent->entm_rx_notice) { if (agent->entm_rx_notice) {
printf("delete agent entm_rx_notice = %d\n",agent->entm_rx_notice);
PrivSemaphoreDelete(&agent->entm_rx_notice); PrivSemaphoreDelete(&agent->entm_rx_notice);
} }
if (agent->rsp_sem) { if (agent->rsp_sem) {
printf("delete agent rsp_sem = %d\n",agent->rsp_sem);
PrivSemaphoreDelete(&agent->rsp_sem); PrivSemaphoreDelete(&agent->rsp_sem);
} }
@ -396,6 +421,7 @@ int DeleteATAgent(ATAgentType agent)
} }
memset(agent, 0x00, sizeof(struct ATAgent)); memset(agent, 0x00, sizeof(struct ATAgent));
printf("delete ATagent\n");
} }
static void *ATAgentReceiveProcess(void *param) static void *ATAgentReceiveProcess(void *param)
@ -404,8 +430,10 @@ static void *ATAgentReceiveProcess(void *param)
const struct at_urc *urc; const struct at_urc *urc;
while (1) { while (1) {
if (GetCompleteATReply(agent) > 0) { if (GetCompleteATReply(agent) > 0)
{
if (agent->reply != NULL){ if (agent->reply != NULL){
PrivMutexObtain(&agent->lock);
ATReplyType reply = agent->reply; ATReplyType reply = agent->reply;
agent->maintain_buffer[agent->maintain_len] = '\0'; agent->maintain_buffer[agent->maintain_len] = '\0';
@ -418,7 +446,7 @@ static void *ATAgentReceiveProcess(void *param)
} }
// agent->reply = NULL; // agent->reply = NULL;
agent->receive_mode = DEFAULT_MODE; PrivMutexAbandon(&agent->lock);
PrivSemaphoreAbandon(&agent->rsp_sem); PrivSemaphoreAbandon(&agent->rsp_sem);
} }
} }
@ -457,11 +485,11 @@ static int ATAgentInit(ATAgentType agent)
goto __out; goto __out;
} }
agent->receive_mode = ENTM_MODE; agent->receive_mode = DEFAULT_MODE;
pthread_attr_t attr; pthread_attr_t attr;
attr.schedparam.sched_priority = 18; attr.schedparam.sched_priority = 18;
attr.stacksize = 2048; attr.stacksize = 4096;
PrivTaskCreate(&agent->at_handler, &attr, ATAgentReceiveProcess, agent); PrivTaskCreate(&agent->at_handler, &attr, ATAgentReceiveProcess, agent);
printf("create agent->at_handler = %d\n",agent->at_handler); printf("create agent->at_handler = %d\n",agent->at_handler);
@ -520,6 +548,7 @@ ATReplyType CreateATReply(uint32 reply_max_len)
printf("no more memory\n"); printf("no more memory\n");
return NULL; return NULL;
} }
memset(reply, 0, sizeof(struct ATReply));
reply->reply_max_len = reply_max_len; reply->reply_max_len = reply_max_len;

180
APP_Framework/Framework/connection/nbiot/bc28/bc28.c
View File

@ -30,7 +30,7 @@
#define NET_TYPE_AF_INET6 (1) #define NET_TYPE_AF_INET6 (1)
#define SOCKET_INVALID_ID (-1) #define SOCKET_INVALID_ID (-1)
static int nbiot_lock;
static int BC28UartOpen(struct Adapter *adapter) static int BC28UartOpen(struct Adapter *adapter)
{ {
@ -113,7 +113,14 @@ int NBIoTStatusCheck(struct Adapter *adapter )
char at_cmd[64] = {0}; char at_cmd[64] = {0};
AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B); /* set receive end flag as 'OK'*/ AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B); /* set receive end flag as 'OK'*/
memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+NCONFIG=AUTOCONNECT,TRUE", 27);
strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd);
ATOrderSend(adapter->agent, 0, NULL, at_cmd);
PrivTaskDelay(10000);
// memset(at_cmd, 0 ,64); // memset(at_cmd, 0 ,64);
// memcpy(at_cmd, "AT+NRB", 6); // memcpy(at_cmd, "AT+NRB", 6);
// strcat(at_cmd, "\n"); // strcat(at_cmd, "\n");
@ -139,19 +146,8 @@ int NBIoTStatusCheck(struct Adapter *adapter )
// } // }
memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+CFUN=1", 10);
strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
if(result < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1;
goto out;
}
// memset(at_cmd, 0 ,64); // memset(at_cmd, 0 ,64);
// memcpy(at_cmd, "AT+CFUN?", 8); // memcpy(at_cmd, "AT+CFUN=1", 10);
// strcat(at_cmd, "\n"); // strcat(at_cmd, "\n");
// printf("cmd : %s\n", at_cmd); // printf("cmd : %s\n", at_cmd);
// result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK"); // result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
@ -161,6 +157,18 @@ int NBIoTStatusCheck(struct Adapter *adapter )
// goto out; // goto out;
// } // }
AtSetReplyEndChar(adapter->agent, 0x4F, 0x4B); /* set receive end flag as 'OK'*/
memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+CFUN?", 8);
strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
if(result < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1;
goto out;
}
memset(at_cmd, 0 ,64); memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+CIMI", 7); memcpy(at_cmd, "AT+CIMI", 7);
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
@ -173,10 +181,10 @@ int NBIoTStatusCheck(struct Adapter *adapter )
} }
memset(at_cmd, 0 ,64); memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+CGATT=1", 10); memcpy(at_cmd, "AT+CEREG?", 9);
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd); printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK"); result = AtCmdConfigAndCheck(adapter->agent, at_cmd, ",1");
if(result < 0) { if(result < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd); printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1; result = -1;
@ -184,18 +192,7 @@ int NBIoTStatusCheck(struct Adapter *adapter )
} }
// memset(at_cmd, 0 ,64); // memset(at_cmd, 0 ,64);
// memcpy(at_cmd, "AT+CGATT?", 9); // memcpy(at_cmd, "AT+CGATT=1", 10);
// strcat(at_cmd, "\n");
// printf("cmd : %s\n", at_cmd);
// result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
// if(result < 0) {
// printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
// result = -1;
// goto out;
// }
// memset(at_cmd, 0 ,64);
// memcpy(at_cmd, "AT+CEREG?", 9);
// strcat(at_cmd, "\n"); // strcat(at_cmd, "\n");
// printf("cmd : %s\n", at_cmd); // printf("cmd : %s\n", at_cmd);
// result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK"); // result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
@ -206,7 +203,7 @@ int NBIoTStatusCheck(struct Adapter *adapter )
// } // }
memset(at_cmd, 0 ,64); memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+QREGSWT=2", 12); memcpy(at_cmd, "AT+CGATT?", 9);
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd); printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK"); result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
@ -221,12 +218,12 @@ int NBIoTStatusCheck(struct Adapter *adapter )
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd); printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK"); result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
// if(result < 0) { if(result < 0) {
// printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd); printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
// result = -1; result = -1;
// goto out; goto out;
// } }
memset(at_cmd, 0 ,64); memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+CGPADDR", 10); memcpy(at_cmd, "AT+CGPADDR", 10);
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
@ -236,6 +233,18 @@ int NBIoTStatusCheck(struct Adapter *adapter )
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd); printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1; result = -1;
} }
memset(at_cmd, 0 ,64);
memcpy(at_cmd, "AT+QREGSWT=2", 12);
strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd);
result = AtCmdConfigAndCheck(adapter->agent, at_cmd, "OK");
if(result < 0) {
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1;
goto out;
}
out: out:
return result; return result;
} }
@ -464,44 +473,56 @@ static int BC28Open(struct Adapter *adapter)
if (NULL == adapter) { if (NULL == adapter) {
return -1; return -1;
} }
if(PrivMutexCreate(&nbiot_lock, 0) < 0) {
printf("nbiot_lock mutex create failed.\n");
return -1;
}
/*step1: open BC8 serial port*/ /*step1: open BC8 serial port*/
ret = BC28UartOpen(adapter); ret = BC28UartOpen(adapter);
if (ret < 0) { if (ret < 0) {
printf("bc18 setup failed.\n"); printf("bc18 setup failed.\n");
PrivMutexDelete(&nbiot_lock);
return -1; return -1;
} }
/*step2: init AT agent*/ /*step2: init AT agent*/
if (!adapter->agent) { if (!adapter->agent) {
char *agent_name = "niot_device"; char *agent_name = "niot_device";
if (EOK != InitATAgent(agent_name, adapter->fd, 512)) { if (EOK != InitATAgent(agent_name, adapter->fd, 512)) {
PrivClose(adapter->fd); PrivClose(adapter->fd);
PrivMutexDelete(&nbiot_lock);
printf("at agent init failed !\n"); printf("at agent init failed !\n");
return -1; return -1;
} }
ATAgentType at_agent = GetATAgent(agent_name); ATAgentType at_agent = GetATAgent(agent_name);
adapter->agent = at_agent; adapter->agent = at_agent;
} }
// BC28PowerSet(); /* reset bc28 module by set reset pin */
PrivTaskDelay(6000);
ret = NBIoTStatusCheck(adapter); /* ask module status*/
if(ret < 0){
DeleteATAgent(adapter->agent);
adapter->agent = NULL;
PrivMutexDelete(&nbiot_lock);
printf("NBIot status check failed.\n");
return -1;
}
create_socket.type = SOCKET_TYPE_STREAM; create_socket.type = SOCKET_TYPE_STREAM;
create_socket.listen_port = 0; create_socket.listen_port = 0;
create_socket.socket_id = 1; create_socket.socket_id = 1;
create_socket.af_type = NET_TYPE_AF_INET; create_socket.af_type = NET_TYPE_AF_INET;
BC28PowerSet(); /* reset bc28 module by set reset pin */
PrivTaskDelay(6000);
ret = NBIoTStatusCheck(adapter); /* ask module status*/
// if(ret < 0){
// PrivClose(adapter->fd);
// printf("NBIot status check failed.\n");
// return -1;
// }
/*step3: create a tcp socket default */ /*step3: create a tcp socket default */
ret = NBIoTSocketCreate(adapter, &create_socket); ret = NBIoTSocketCreate(adapter, &create_socket);
if(ret < 0){ if(ret < 0) {
DeleteATAgent(adapter->agent); DeleteATAgent(adapter->agent);
// adapter->agent = NULL; adapter->agent = NULL;
PrivClose(adapter->fd); PrivMutexDelete(&nbiot_lock);
printf("NBIot create tcp socket failed.\n"); printf("NBIot create tcp socket failed.\n");
return -1; return -1;
} }
@ -512,16 +533,25 @@ static int BC28Open(struct Adapter *adapter)
static int BC28Close(struct Adapter *adapter) static int BC28Close(struct Adapter *adapter)
{ {
NBIoTSocketDelete(adapter);
DeleteATAgent(adapter->agent); if(&adapter->socket){
adapter->agent = NULL; NBIoTSocketDelete(adapter);
PrivClose(adapter->fd); }
if(adapter->agent)
{
DeleteATAgent(adapter->agent);
adapter->agent = NULL;
}
PrivMutexDelete(&nbiot_lock);
return 0; return 0;
} }
static int BC28Ioctl(struct Adapter *adapter, int cmd, void *args) static int BC28Ioctl(struct Adapter *adapter, int cmd, void *args)
{ {
int ret = 0; int ret = 0;
PrivMutexObtain(&nbiot_lock);
switch (cmd) switch (cmd)
{ {
case CONFIG_NBIOT_RESET: /* reset nbiot */ case CONFIG_NBIOT_RESET: /* reset nbiot */
@ -541,7 +571,7 @@ static int BC28Ioctl(struct Adapter *adapter, int cmd, void *args)
ret = -1; ret = -1;
break; break;
} }
PrivMutexAbandon(&nbiot_lock);
return ret; return ret;
} }
@ -564,6 +594,7 @@ static int BC28Connect(struct Adapter *adapter, enum NetRoleType net_role, const
char at_cmd[64] = {0}; char at_cmd[64] = {0};
char str_fd[2] = {0}; char str_fd[2] = {0};
PrivMutexObtain(&nbiot_lock);
itoa(adapter->socket.socket_id, str_fd, 10); itoa(adapter->socket.socket_id, str_fd, 10);
memset(at_cmd, 0 ,64); memset(at_cmd, 0 ,64);
@ -582,7 +613,7 @@ static int BC28Connect(struct Adapter *adapter, enum NetRoleType net_role, const
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd); printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1; result = -1;
} }
PrivMutexAbandon(&nbiot_lock);
__exit: __exit:
return result; return result;
} }
@ -593,11 +624,14 @@ static int BC28Send(struct Adapter *adapter, const void *buf, size_t len)
char at_cmd[64] = {0}; char at_cmd[64] = {0};
char str_fd[2] = {0}; char str_fd[2] = {0};
char assic_str[2] = {0}; char assic_str[2] = {0};
char *nbdata = PrivMalloc(2 * len);
int assic_val = 0; int assic_val = 0;
int length = 0; int length = 0;
PrivMutexObtain(&nbiot_lock);
char *nbdata = PrivMalloc(2 * len);
memset(nbdata, 0 ,2 * len);
for(int i = 0; i < len; i++) for(int i = 0; i < len; i++)
{ {
assic_val = 0; assic_val = 0;
@ -656,7 +690,7 @@ static int BC28Send(struct Adapter *adapter, const void *buf, size_t len)
printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd); printf("%s %d cmd[%s] config failed!\n",__func__,__LINE__,at_cmd);
result = -1; result = -1;
} }
PrivMutexAbandon(&nbiot_lock);
return result; return result;
} }
@ -669,10 +703,12 @@ static int BC28Recv(struct Adapter *adapter, void *buf, size_t len)
int ret = 0; int ret = 0;
char *result = NULL; char *result = NULL;
PrivMutexObtain(&nbiot_lock);
ATReplyType reply = CreateATReply(256); ATReplyType reply = CreateATReply(512);
if (NULL == reply) { if (NULL == reply) {
printf("at create failed ! \n"); printf("at create failed ! \n");
PrivMutexAbandon(&nbiot_lock);
return -1; return -1;
} }
@ -687,18 +723,30 @@ static int BC28Recv(struct Adapter *adapter, void *buf, size_t len)
strcat(at_cmd, "\n"); strcat(at_cmd, "\n");
printf("cmd : %s\n", at_cmd); printf("cmd : %s\n", at_cmd);
ATOrderSend(adapter->agent, REPLY_TIME_OUT, reply, at_cmd); ret = ATOrderSend(adapter->agent, REPLY_TIME_OUT, reply, at_cmd);
PrivTaskDelay(300); if(ret < 0)
{
ret = BC28ParseData(buf, reply); printf("NBiot receive timeout\n");
if (ret < 0){ DeleteATReply(reply);
return ret; return -1;
} }
if (reply) { if(reply)
{
ret = BC28ParseData(buf, reply);
if (ret < 0)
{
PrivMutexAbandon(&nbiot_lock);
if (reply)
{
DeleteATReply(reply);
}
return ret;
}
DeleteATReply(reply); DeleteATReply(reply);
} }
PrivMutexAbandon(&nbiot_lock);
return ret; return ret;
} }

2
APP_Framework/Framework/transform_layer/xiuos/transform.c
View File

@ -79,11 +79,13 @@ int PrivTaskStartup(pthread_t *thread)
{ {
return 0; return 0;
} }
#ifdef SEPARATE_COMPILE
/* private API of xiuos to search the first user task in manage list */ /* private API of xiuos to search the first user task in manage list */
int PrivUserTaskSearch(void) int PrivUserTaskSearch(void)
{ {
return UserTaskSearch(); return UserTaskSearch();
} }
#endif
int PrivTaskDelete(pthread_t thread, int sig) int PrivTaskDelete(pthread_t thread, int sig)
{ {