串口通信数据在多任务系统中的操作总结

串口数据在中断中根据通信空闲判断结束帧，接收到整包数据后把整包数据通过发送到消息队列，处理数据的任务在任务函数中从消息队列获取数据并处理

 

1、框架

 

//中断服务程序

void USART3_IRQHandler(void)                    

{

 

 

    uint8_t  err = 0;

    uart3_rx_msg_t *uart_rx_msg;

 

    OSIntEnter();    

 

    if((__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("3RXNE\r\n");

        __HAL_UART_CLEAR_FLAG(&UART3_Handler,UART_FLAG_RXNE);

          

    }

    if((__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_IDLE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("3IDLE\r\n");//根据空闲判断整包接收完成

 

        UART_ConfigMode_Set_RecvData(&uart3_config);

        if(UART_Is_ConfigMode(&uart3_config) == 0)

        {

            uart3_rx_len = USART3_DMA_RecvData(uart3_rx_buffer);

            //uart3_rx_buffer[uart3_rx_len] = '\0';

            //PRINTF("%s",uart3_rx_buffer);

 

            uart_rx_msg = (uart3_rx_msg_t*)OSMemGet(mem_uart3,&err);

            if(err != OS_ERR_NONE || uart_rx_msg == NULL)//

            {

                if(err == OS_ERR_MEM_NO_FREE_BLKS)

                {

                    //无剩余内存块的时候，恢复任务去处理

                    OSTaskResume(UART3_TASK_PRIO);

                }

                PRINTF("\r\n WARNING: OSMemGet for uart3_rx_msg failed,return err = %d !\r\n",err);

                __HAL_UART_CLEAR_IDLEFLAG(&UART3_Handler);

                OSIntExit();  

                return;

            }

            memset(uart_rx_msg->buffer,0,sizeof(uart_rx_msg->buffer));

            uart_rx_msg->len = uart3_rx_len;

            memcpy(uart_rx_msg->buffer, uart3_rx_buffer, uart3_rx_len);

            err = OSQPost(uart3_Q,uart_rx_msg); //将串口收到数据用消息队列发出

            if(err != OS_ERR_NONE)

            {

                OSMemPut(mem_uart3,uart_rx_msg);

                PRINTF("\r\n WARNING: OSQPost uart3_rx_msg failed,return err =%d !\r\n",err);

            }

            

            //OSTimeDlyResume(UART3_TASK_PRIO);

            OSTaskResume(UART3_TASK_PRIO);

            

        }

        

        __HAL_UART_CLEAR_IDLEFLAG(&UART3_Handler);

    }

    if((__HAL_UART_GET_FLAG(&UART3_Handler,UART_FLAG_TC)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("3TC\r\n");

        __HAL_UART_CLEAR_FLAG(&UART3_Handler,UART_FLAG_TC);

    }

    HAL_UART_IRQHandler(&UART3_Handler);    

 

    OSIntExit();                                              

 

}

 

//任务函数

void UART3_Task_RFC1(void *pdata)

{

    uint8_t err = 0;

    uart3_rx_msg_t *uart_rx_msg;

 

    PRINTF("UART3_Task_RFC1 Start.\r\n");

    while(1)

    {

        //PRINTF("UART3_Task_RFC1\r\n");

        uart_rx_msg = OSQAccept(uart3_Q, &err);//从消息队列获取数据

        while(err == OS_ERR_NONE)

        {

            PRINTF("UART3_Task_RFC1 recv len:%d\r\n", uart_rx_msg->len);

            PRINTF("UART3_Task_RFC1 recv data:%s\r\n", uart_rx_msg->buffer);

            printf_hex("UART3_Task_RFC1 recv data:", uart_rx_msg->buffer, uart_rx_msg->len);

 

            OSMemPut(mem_uart3, uart_rx_msg);

            uart_rx_msg = OSQAccept(uart3_Q, &err);

        }

       

        //OSTimeDly(10);

        //delay_ms(10);

        //PRINTF("UART3_Task_RFC1 Suspend.\r\n");

        OSTaskSuspend(UART3_TASK_PRIO);

    }

 

 

}

 

2、在以上框架下对数据操作分情况讨论

 

1、串口数据都是主送上送，任务只负责处理以及应答

 

只有一个任务操作读写串口数据时，不存在资源抢占，使用框架结构处理即可，但

 

 

2、串口数据存在主动上送，也存在主动召读，召读有超时时间

 

主动上送数据由专门处理任务，发起召读命令的任务与专门处理任务能是一个任务，否则数据处理会因为召读等待得不到及时处理

 

Interrupt 负责把数据发送到消息队列

 

召读命令请求数据时，数据直接从串口获取，添加标志不通过Interrupt 把数据发送到消息队列

 

 

//USART2中断服务程序

void USART2_IRQHandler(void)                    

{

 

 

    uint8_t  err = 0;

    uart2_rx_msg_t *uart_rx_msg;

 

    OSIntEnter();    

 

    if((__HAL_UART_GET_FLAG(&UART2_Handler,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("2RXNE\r\n");

        __HAL_UART_CLEAR_FLAG(&UART2_Handler,UART_FLAG_RXNE);

          

    }

    if((__HAL_UART_GET_FLAG(&UART2_Handler,UART_FLAG_IDLE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("2IDLE\r\n");

        

        UART_ConfigMode_Set_RecvData(&uart2_config);//判断是否是召读命令应答，如果是，则不发到消息队列，有召读处自己读取

        if(UART_Is_ConfigMode(&uart2_config) == 0)

        {

            uart2_rx_len = USART2_DMA_RecvData(uart2_rx_buffer);

            //uart2_rx_buffer[uart2_rx_len] = '\0';

            //PRINTF("%s",uart2_rx_buffer);

 

            uart_rx_msg = (uart2_rx_msg_t*)OSMemGet(mem_uart2,&err);

            if(err != OS_ERR_NONE || uart_rx_msg == NULL)//

            {

                if(err == OS_ERR_MEM_NO_FREE_BLKS)

                {

                    //无剩余内存块的时候，恢复任务去处理

                    OSTaskResume(UART2_TASK_PRIO);

                }

                PRINTF("\r\n WARNING: OSMemGet for uart2_rx_msg failed,return err = %d !\r\n",err);

                __HAL_UART_CLEAR_IDLEFLAG(&UART2_Handler);

                OSIntExit();  

                return;

            }

            memset(uart_rx_msg->buffer,0,sizeof(uart_rx_msg->buffer));

            uart_rx_msg->len = uart2_rx_len;

            memcpy(uart_rx_msg->buffer, uart2_rx_buffer, uart2_rx_len);

            err = OSQPost(uart2_Q,uart_rx_msg); //将串口收到数据用消息队列发出

            if(err != OS_ERR_NONE)

            {

                OSMemPut(mem_uart2,uart_rx_msg);

                PRINTF("\r\n WARNING: OSQPost uart2_rx_msg failed,return err =%d !\r\n",err);

            }

            

            //OSTimeDlyResume(UART2_TASK_PRIO);

            OSTaskResume(UART2_TASK_PRIO);

            

        }

        

        __HAL_UART_CLEAR_IDLEFLAG(&UART2_Handler);

            

    }

    if((__HAL_UART_GET_FLAG(&UART2_Handler,UART_FLAG_TC)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("2TC\r\n");

        __HAL_UART_CLEAR_FLAG(&UART2_Handler,UART_FLAG_TC);

    }

    HAL_UART_IRQHandler(&UART2_Handler);    

 

    OSIntExit();                                              

 

}

 

 

uint8_t GPRS_Setpara(const char *cmd,const char *para, uint32_t timeout_ms)

{

    uint8_t s[128];

    uint8_t ret = 0;

 

    memset(s,0,sizeof(s));

    (void)sprintf((char *)s,"%s%s",cmd,para);

    

    UART_Enter_ConfigMode(&uart2_config);//标记召读开始

    GPRS_Send_ATCMD((char *)s);

    

    if(GPRS_Receive(gprs_rxbuf, timeout_ms))//召读处直接获取数据，并处理

    {

        if(GPRS_Find_bina(gprs_rxbuf, (uint8_t *)"OK")!=NULL)

        {

          

//            PRINTF("ATCMD Return:%s\r\n", gprs_rxbuf);

            ret = 1;

        }

        

        if(GPRS_Find_bina(gprs_rxbuf, (uint8_t *)"+QIOPEN: 0,566")!=NULL)

        {

            ret = 0;

        }

           

    }

    UART_Exit_ConfigMode(&uart2_config);

    

    return ret;

 

}

 

缺点：如果在召读标记的过程中，串口收到主动上送的非召读数据，导致非召读数据得不到正常处理，且导致等待召读应答较久，该方式适合无主动上报的纯召读-应答模式，可不使用消息队列

 

 

3、串口数据存在主动上送也存在召读，且高效处理

 

不管是召读数据还是主动上报数据全部由Interrupt 负责把数据发送到消息队列;任务函数中根据数据类型理解处理:标记是否收到数据，并且根据是否需要返回数据进行数据返回，以便召读处可立即获取到数据。

 

该方式实现依赖于一个动态链表，链表存放召读处期待的数据类型，以及节点地址，该链表会在任务函数处理中用来查看，是否有对应的召读，根据标志情况返回数据。

 

 

node_list_t *node_list_head = NULL;

node_list_t *node_list_current = NULL;

 

 

node_list_t *find_node_list(uint8_t addr, uint8_t type)

{

 

    node_list_t *node;

 

    if(node_list_head == NULL){

//        PRINTF("node_list_head is NULL\r\n");

        return NULL;

    }

 

    node = node_list_head;

    do{

        if(node->addr == addr && node->type == type){

//            PRINTF("node addr:%02x type:%02x node_list finded\r\n", addr, type);

            return node;

        }

        node = node->next;

    

    }while(node != NULL);

 

    PRINTF("node addr:%02x type:%02x no node_list, return NULL\r\n", addr, type);

    return node;    

 

}

 

 

node_list_t *create_node_list(uint8_t addr, uint8_t type)

{

 

    uint8_t err = 0;

    node_list_t *node = NULL;

 

    node = find_node_list(addr, type);

    if(node != NULL){

 

//        PRINTF("node addr:%02x type:%02x node_list has exist\r\n", addr, type);

        return node;

 

    }

   

    //if((node =  (node_list_t *)malloc(sizeof(node_list_t))) != NULL)

    if((node = (node_list_t*)OSMemGet(mem_nodelist,&err)) != NULL)

    {

 

//        PRINTF("node addr:%02x type:%02x OSMemGet node_list_t succeed\r\n", addr, type);

    }

    else{

 

//        PRINTF("node addr:%02x type:%02x OSMemGet node_list_t failed,return err:%d\r\n", addr, type, err);

        return NULL;

    }

 

    node->addr = addr;

    node->type = 0;

    node->tx = 0;

    node->rx = 0;

    node->len = 0;

    node->buf = NULL;

    node->next = NULL;

 

    

    if(node_list_head == NULL){

 

        node_list_head = node;

        node_list_current = node;

        

    }

    else{

        

        node_list_current->next = node;

        node_list_current = node;        

 

    }

 

    return node;    

    

}

 

int delete_node_list(uint8_t addr, uint8_t type)

{

    uint8_t err = 0;

    node_list_t *node = NULL;

    node_list_t *last = NULL;

 

    node = find_node_list(addr, type);

    if(node == NULL){

 

//        PRINTF("node addr:%02x type:%02x node_list don't exist\r\n", addr, type);

        return 0;

 

    }

 

    if(node == node_list_head){

        

        node_list_head = node->next;

        if(node_list_head == NULL)

            node_list_current = NULL;

//        PRINTF("node addr:%02x type:%02x node_list delete\r\n", addr, type);

        //free(node);

        err = OSMemPut(mem_nodelist, node);

        if(err != OS_ERR_NONE) PRINTF("OSMemPut node_list Failed.\r\n");

 

        

    }

    else{

 

            last = node_list_head;

            do{

                if(last->next == node){

//                    PRINTF("node addr:%02x type:%02x last node_list finded\r\n",addr, type);

                    break;

                }

                last = last->next;

            

            }while(last != NULL);

 

            if(last != NULL)

            {

 

                last->next  = node->next;

                if(node == node_list_current) node_list_current = last;

//                PRINTF("node addr:%02x type:%02x node_list delete\r\n", addr, type);

                //free(node);

                err = OSMemPut(mem_nodelist, node);

                if(err != OS_ERR_NONE) PRINTF("OSMemPut node_list Failed.\r\n");

 

 

                

            }

            else

            {

//                PRINTF("node addr:%02x type:%02x node_list delete failed\r\n", addr, type);

                return 0;

 

            }

            

        

    }

 

    return 1;

 

 

}

 

 

int delete_node_list_usenode(node_list_t *node)

{

    uint8_t err = 0;

    node_list_t *last = NULL;

 

    if(node == node_list_head){

        

        node_list_head = node->next;

        if(node_list_head == NULL)

            node_list_current = NULL;

        PRINTF("node addr:%02x type:%02x node_list delete succeed\r\n",node->addr, node->type);

        //free(node);

        err = OSMemPut(mem_nodelist, node);

        if(err != OS_ERR_NONE) PRINTF("OSMemPut node_list Failed.\r\n");

 

        

    }

    else{

 

            last = node_list_head;

            do{

                if(last->next == node){

//                    PRINTF("node addr:%02x type:%02x last node_list finded\r\n",node->addr, node->type);

                    break;

                }

                last = last->next;

            

            }while(last != NULL);

 

            if(last != NULL)

            {

 

                last->next  = node->next;

                if(node == node_list_current) node_list_current = last;

//                PRINTF("node addr:%02x type:%02x node_list delete succeed\r\n",node->addr, node->type);

                //free(node);

                err = OSMemPut(mem_nodelist, node);

                if(err != OS_ERR_NONE) PRINTF("OSMemPut node_list Failed.\r\n");

 

                

            }

            else

            {

//                PRINTF("node addr:%02x type:%02x node_list delete failed\r\n",node->addr, node->type);

                return 0;

 

            }

            

        

    }

 

    return 1;

 

 

}

 

void node_init(node_list_t *node, uint8_t addr, uint8_t type, uint8_t tx, uint8_t * buf)

{

    if(node == NULL) return;

    

    node->addr = addr;

    node->type = type;

    node->tx = tx;

    //node->rx = 0;

    //node->len = 0;

    node->buf = buf;

    //node->next = NULL;

    

}

 

 

 

 

 

//UART4中断服务程序

void UART4_IRQHandler(void)                    

{

    uint8_t  err = 0;

    uart4_rx_msg_t *uart_rx_msg;

 

    OSIntEnter();    

 

    if((__HAL_UART_GET_FLAG(&UART4_Handler,UART_FLAG_RXNE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("4RXNE\r\n");

        UART4_RecvData(uart4_rx_buffer);

        __HAL_UART_CLEAR_FLAG(&UART4_Handler,UART_FLAG_RXNE);

          

    }

    if((__HAL_UART_GET_FLAG(&UART4_Handler,UART_FLAG_IDLE)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("4IDLE\r\n");

        //非DMA方式

        UART4_RX_STA|=0x4000;

        

        UART_ConfigMode_Set_RecvData(&uart4_config);

        if(UART_Is_ConfigMode(&uart4_config) == 0)

        {

            if((UART4_RX_STA&0xc000)==0xc000)

            {

                //uart4_rx_buffer[uart4_rx_len] = '\0';

                //PRINTF("%s",uart4_rx_buffer);

                //PRINTF("%s",uart1_rx_buffer);

                if(ucosii_start_ok == 0)

                {

                    UART4_RX_STA = 0;

                    __HAL_UART_CLEAR_IDLEFLAG(&UART4_Handler);

                    OSIntExit();  

                    return;

                }

 

                uart_rx_msg = (uart4_rx_msg_t*)OSMemGet(mem_uart4,&err);

                if(err != OS_ERR_NONE || uart_rx_msg == NULL)//

                {

                    if(err == OS_ERR_MEM_NO_FREE_BLKS)

                    {

                        //无剩余内存块的时候，恢复任务去处理

                        OSTaskResume(UART4_TASK_PRIO);

                    }

                    PRINTF("\r\n WARNING: OSMemGet for uart4_rx_msg failed,return err = %d !\r\n",err);

                    UART4_RX_STA = 0;

                    __HAL_UART_CLEAR_IDLEFLAG(&UART4_Handler);

                    OSIntExit();  

                    return;

                }

                memset(uart_rx_msg->buffer,0,sizeof(uart_rx_msg->buffer));

                uart_rx_msg->len = uart4_rx_len;

                memcpy(uart_rx_msg->buffer, uart4_rx_buffer, uart4_rx_len);

                err = OSQPost(uart4_Q,uart_rx_msg); //将串口收到数据用消息队列发出

                if(err != OS_ERR_NONE)

                {

                    OSMemPut(mem_uart4,uart_rx_msg);

                    PRINTF("\r\n WARNING: OSQPost uart4_rx_msg failed,return err =%d !\r\n",err);

                }

                

                UART4_RX_STA = 0;

                //OSTimeDlyResume(UART4_TASK_PRIO);

                OSTaskResume(UART4_TASK_PRIO);

 

            }

        }

        __HAL_UART_CLEAR_IDLEFLAG(&UART4_Handler);

    }

    if((__HAL_UART_GET_FLAG(&UART4_Handler,UART_FLAG_TC)!=RESET))  //接收中断(接收到的数据必须是0x0d 0x0a结尾)

    {

        //PRINTF("4TC\r\n");

        __HAL_UART_CLEAR_FLAG(&UART4_Handler,UART_FLAG_TC);

    }

    HAL_UART_IRQHandler(&UART4_Handler);    

 

    OSIntExit();                                              

 

}

 

void UART8_Task_DTU(void *pdata)

{

    

    uint8_t err = 0;

    uart8_rx_msg_t *uart_rx_msg;

    char str[30];

    

    uint32_t time_now = 0;

    uint32_t time_ms = 0;

    uint8_t m2taddr = 0x01;

//    uint8_t m2t_Init_ok = 0;

//    uint8_t heart_timeout = 0;//0超时，1未超时

 

    

    PRINTF("UART8_Task_DTU Start.\r\n");

    time_now = gettime();

    while(1)

    {

        //PRINTF("UART8_Task_DTU\r\n");

        uart_rx_msg = OSQAccept(uart4_Q, &err);

        while(err == OS_ERR_NONE)

        {

            PRINTF("UART8_Task_DTU recv len:%d\r\n", uart_rx_msg->len);

//            PRINTF("UART8_Task_DTU recv data:%s\r\n", uart_rx_msg->buffer);

            printf_hex("UART8_Task_DTU recv data", uart_rx_msg->buffer, uart_rx_msg->len);

            

            M2T_Process(uart_rx_msg->buffer, uart_rx_msg->len);//任务函数中根据数据类型理解处理

            OSMemPut(mem_uart4, uart_rx_msg);

            uart_rx_msg = OSQAccept(uart4_Q, &err);

        }

        

        time_ms += 10;

        if(time_ms >= 1000)

        {

            time_ms = 0;

            time_now = gettime();

        }

 

        //OSTimeDly(10);

        delay_ms(10);

        //PRINTF("UART8_Task_DTU Suspend.\r\n");

        //OSTaskSuspend(UART6_TASK_PRIO);

    }

 

 

}

 

//协议处理

uint8_t M2T_Process(uint8_t *data, uint16_t datalen)

{

    uint8_t ret = 0;

    m2tpara_t m2tpara;

    node_list_t *node = NULL;

    

    m2tpara.data = m2t_txbuf;

    m2tpara.len = M2T_Get_UserData(data, datalen, &m2tpara);

    

    node = find_node_list(m2tpara.m2taddr, m2tpara.ti);

    

    if(node == NULL)

    {

        PRINTF("M2T_Process discard accident frame\r\n");

        return ret;

    }

    

    switch(m2tpara.ti)

    {

        case TI_LINK_START://链路启动

            if(node->buf == NULL)

            {//数据不需要返回则立即处理

                if(node->tx == 1) node->rx = 1;

                PRINTF("M2T_Process recv TI_LINK_START\r\n");

                

            }

            else

            {//数据返回

                if(node->tx == 1)

                {                    

                    memcpy(node->buf, data, datalen);

                    node->len = datalen;

                    node->rx = 1;

                }

                //M2T_Queue_Post(data, datalen);

            }

            break;

         

         case TI_CALL_ALL://总召唤

            if(node->buf == NULL)

            {//数据不需要返回则立即处理

                if(node->tx == 1) node->rx = 1;

                PRINTF("M2T_Process recv TI_CALL_ALL\r\n");

                

            }

            else

            {//数据返回

                if(node->tx == 1)

                {                    

                    memcpy(node->buf, data, datalen);

                    node->len = datalen;

                    node->rx = 1;

                }

                //M2T_Queue_Post(data, datalen);

            }

            break;

         

         

         

         case TI_ALARM://突发召换告警

            if(node->buf == NULL)

            {//数据不需要返回则立即处理

                if(node->tx == 1) node->rx = 1;

                PRINTF("M2T_Process recv M2T_Heart_Ack\r\n");

                

            }

            else

            {//数据返回

                if(node->tx == 1)

                {                    

                    memcpy(node->buf, data, datalen);

                    node->len = datalen;

                    node->rx = 1;

                }

                //M2T_Queue_Post(data, datalen);

            }

            break;

 

         default :

             PRINTF("M2T_Process recv ERROR\r\n");

             break;

 

    }

    

    return ret;

    

}

 

//时钟同步

uint8_t M2T_Clock_Syn(uint8_t m2taddr)

{

    uint16_t len;

    m2tpara_t m2tpara;

    uint8_t ret = 0;

    uint8_t timelen = 0;

    node_list_t *node = NULL;

    

    //时间临时数据存到m2t_rxbuf

    timelen = M2T_Get_Time(m2t_rxbuf);

    if(timelen == 0)

    {   PRINTF("M2T Get Time failed.\r\n");

        return 0; //时钟同步失败

    }

    

    if(M2T_MutexPend() == 0) return ret;

    m2tpara.m2taddr = m2taddr;

    m2tpara.ti = TI_CLOCK_SYN;

    m2tpara.cot = COT_ACTIVE;

    m2tpara.ct = 1;

    m2tpara.data = m2t_txbuf;

    len = M2T_Create_Frame(&m2tpara, m2t_rxbuf, timelen);

    

    //UART_Enter_ConfigMode(&uart6_config);

    node = create_node_list(m2tpara.m2taddr, m2tpara.ti);

    if(node == NULL)

    {

        M2T_MutexPost();

        return 0;

    }

    node_init(node, m2tpara.m2taddr, m2tpara.ti, 1, m2t_rxbuf);

    

    M2T_Send(m2t_txbuf,len);

    

   

    //len = M2T_Receive(m2t_rxbuf, M2T_RECV_TIMEOUT);

    if(M2T_Receive_Check(node, M2T_RECV_TIMEOUT, node->tx, node->tx))

    {

        len = node->len;

    }

    else

    {

        len = 0;

    }

    if(len)

    {

        memset(m2t_txbuf, 0, sizeof(m2t_txbuf));

        m2tpara.len = M2T_Get_UserData(m2t_rxbuf, len, &m2tpara);

        if((m2tpara.ti == TI_CLOCK_SYN) && (m2tpara.cot == COT_ACTIVE_ACK) && (m2tpara.ct == 1) && (m2tpara.len == 7))

        {

            ret = 1;//时钟同步成功

            PRINTF("M2T_Clock_Syn succeed.\r\n");

        }

        

    }

    

    if(ret ==0 ) PRINTF("M2T_Clock_Syn failed.\r\n");

    delete_node_list_usenode(node);

    M2T_MutexPost();

    //UART_Exit_ConfigMode(&uart6_config);

    return ret;

 

}

 

 

//检查node是否收到数据，timeout_ms是最大超时时间,返回0，超时，1接收成功

uint8_t M2T_Receive_Check(node_list_t *node, int32_t timeout_ms, uint8_t tx, uint8_t rx)

{

    uint16_t singletime_ms;

    uint8_t ret = 0;

    

    singletime_ms = 100;

    while(timeout_ms)

    {

        delay_ms(singletime_ms);

        if(node->tx == tx && node->rx == rx)

        {

            ret = 1;

            break;

        }

        timeout_ms -= singletime_ms;

    }

    

    return ret;

  

}