类似于TCP三次握手、超时检测以及自动重发机制的通信任务该如何设计

ba_wang_mao · 发表于 2020-1-17 14:44:03

我的设备的USART1和一个小模块进行通信，但是通信之前需要握手，过程如下：

      第一步：  我的设备先定时（定时200毫秒时间，时间不需要非常准确）给小模块发送握手请求报文A
                  设备正常收到小模块的应答报文后，跳转到第二步；否则重复发送请求报文A
      第二步：我的设备先定时（定时200毫秒时间，时间不需要非常准确）给小模块发送握手请求报文B
                  设备正常收到小模块的应答报文后，跳转到第三步；
                  否则重复发送请求报文B，如果自动重发次数超过3，则跳转到第一步，重新发送握手请求报文A。
   第三步：我的设备开始定时（定时500毫秒时间，时间不需要非常准确）给小模块发送请求报文C。
                  请求报文C中包含要发送的数据从USART2通信和USART3通信以及其它任务中读取。
                  如果长时间（假如1分钟，时间不需要非常准确）没有收到小模块的应答报文（心跳包报文），则跳转到第一步，重新发送握手请求报文A。

   请问：我该如何设计和规划通信任务？

ba_wang_mao · 发表于 2020-1-17 14:44:32

通信要求如下：

   步骤1：
               发送请求报文A，然后等待应答报文；
               （1）、如果收到应答报文，跳转到步骤2.
               （2）、如果没有收到应答，定时重发发送请求报文A。
   步骤2：
               发送请求报文B，然后等待应答报文；
               （1）、如果收到应答报文，跳转到步骤3.
               （2）、如果超时未等到应答报文，重发发送请求报文B，如果连续3次超时，则跳转到步骤1。
   步骤3：
               （1）、等待接收USART2的通信数据。
               （2）、等待接收USART3的通信数据。
               （3）、IF (先后收到USART2的通信数据和USART3的通信数据)
                     {
                        发送请求报文C
                     }

               （4）、等待应答报文。
               (5)、如果连续1分钟没有收到应答报文，则跳转到步骤1

  我的任务设计如下，是否可行，请指教！
   如果有缺陷，请指出好的方法！

事先创建2个消息队列，以下简称消息队列A和消息队列B
   消息队列A用来接收应答报文
   消息队列B用来接收USART2和USART3的通信数据

   void my_task(void)
   {
         static int step = 0; // 0=发送请求报文A，1=发送请求报文B，2=发送请求报文C
         static int count = 0;  //计数器，自动重发超过3次，跳转到step=0，转去发送请求报文A
         static int time = 0; //计时，连续1分钟计时
         static int OK=0;    //是否收齐USART2和USART3的通信数据

//-------------------------定时发送USART1的请求报文部分
         switch (step)
         {
               case 0:
                     调用子程序，发送发送请求报文A;
                     break;

               case 1:
                     count++;
                     if (count > 3) //自动重发超过3次，跳转到step=0
                     {
                           count =0;
                           step=0;
                     }
                     else
                     {
                           调用子程序，发送发送请求报文B;
                     }
                     break;

                  case 2:

                     通过消息队列B，等待USART2的消息队列通信数据，如果收到OK|=0x01;
                     通过消息队列B，等待USART3的消息队列通信数据，如果收到OK|=0x02;
                     if (k==0x03) //收齐USART2和USART3的通信数据
                     {
                        OK=0;
                        调用子程序，发送发送请求报文C;
                     }

            }

//-------------------------等待USART1的应答报文部分

         通过消息队列A，等待usart1的消息队列（最大等待时间=500ms）
         switch (step)
         {
               case 0:
                     if (消息队列收到消息)
                     {
                        解析报文
                        if （报文ok)
                           step = 1;
                     }
                     break;
               case 1:
                     if (消息队列收到消息)
                     {
                        解析报文
                        if （报文ok)
                        {
                           count =0;//自动重发次数清零
                           step = 2;
                        }
                     else
                     {
                        count++: //自动重发次数+1
                     }
                     break;
               case 2:
                     if (消息队列收到消息)
                     {
                        解析报文
                        time = 0x00;//连续1分钟计时单元清零
                     }
                     else
                     {
                        time++;//连续1分钟计时单元+1
                        if (time >= 20) //如果1分钟到时
                        {
                           OK=0;
                           count=0;
                           time=0;
                        }
                     }
                     break;
         }
   }
}

ba_wang_mao · 发表于 2020-1-17 14:45:33

疑问：
   1、在上线握手过程中，USART2和USART3的通信数据导致消息队列B满该怎么办呢？（注：USART2和USART3的通信数据本机无法控制）。
   2、对系统有影响吗？
   3、该如何消除？
   4、是增加限制条件吗？（即：握手不成功时，USART2和USART3的通信任务不发送消息）
            这种增加限制条件，即条件不满足时不发送消息队列数据，是否太牵强了！

ba_wang_mao · 发表于 2020-6-12 16:39:05

ba_wang_mao 发表于 2020-1-17 14:45
疑问：
1、在上线握手过程中，USART2和USART3的通信数据导致消息队列B满该怎么办呢？（注：USART2和 ...

经过一段时间的学习，这个问题我已经编程解决了，代码如下

void hex_to_string(uint8_t hex_buffer[] , char *string , uint16_t n)
{
uint16_t i;
char *p = string;
for (i = 0 ; i < n ; i++)
*p++ = hex_buffer[i];
*p = '\0';
}
uint8_t IOT_Connect_Buffer_Init(char send_string[] , uint8_t send_buffer[])
{
char *q = send_string;
uint8_t *p = send_buffer;
uint8_t len;
while (*q != '\0')
*p++ = *q++;
len = strlen(send_string);
return (len);
}
void IOT_4G_Poll(void)
{
const TickType_t xTicksToWait = pdMS_TO_TICKS( 200UL );
BaseType_t xResult;
BaseType_t xStatus;
static uint16_t IOT_4G_Outtime = 0x00;
static uint16_t IOT_TCP_port_count = 0x00;
uint8_t Buffer[10];
switch (IOT_4G_isr)
{
case 0:
strcpy(IOT_send_string , "AT\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "AT\r\r\nOK\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 1;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 1:
if (++IOT_4G_Outtime > 2)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 0;
break;
}
strcpy(IOT_send_string , "ATE1\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "ATE1\r\r\nOK\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 2;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 2:
if (++IOT_4G_Outtime > 2)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 0;
break;
}
strcpy(IOT_send_string , "AT+CPIN?\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "AT+CPIN?\r\r\n+CPIN: READY\r\n\r\nOK\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 3;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 3:
if (++IOT_4G_Outtime > 2)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 0;
break;
}
strcpy(IOT_send_string , "AT+CREG=?\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "AT+CREG=?\r\r\n+CREG:");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 4;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 4:
if (++IOT_4G_Outtime > 2)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 0;
break;
}
strcpy(IOT_send_string , "AT+CSQ\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "AT+CSQ\r\r\n+CSQ:");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 5;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 5:
if (++IOT_4G_Outtime > 2)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 0;
break;
}
strcpy(IOT_send_string , "AT+QIDEACT=1\r");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "AT+QIDEACT=1\r\r\nOK\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 7;
vTaskDelay(100);
break;
}
}
vTaskDelay(100);
break;
case 7:
strcpy(IOT_send_string , "AT+QIOPEN=1,0,"TCP","192.168.1.10",5000,0,2\r\0");
MB_USART2.sendCount = IOT_Connect_Buffer_Init(IOT_send_string , MB_USART2.send_buffer);
USART2_Begin_Send();
vTaskDelay(15000 / portTICK_RATE_MS);
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "\r\nCONNECT\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_TCP_port_count = 0x00;
IOT_4G_isr = 20;
vTaskDelay(100);
KK4++;
break;
}
}
if (++IOT_TCP_port_count >= 8)
{
IOT_TCP_port_count = 0x00;
IOT_4G_isr = 10;
KK5++;
break;
}
IOT_4G_isr = 0;
KK6++;
vTaskDelay(100);
break;
case 20:
xStatus = xQueueReceive( xQueue_EC20, &Buffer, xTicksToWait);//portMAX_DELAY);
if( xStatus == pdPASS )
{
switch (Buffer[0])
{
case 1:
IOT_DI1_1 = Buffer[1];
IOT_DI1_2 = Buffer[2];
break;
case 2:
IOT_DI2_1 = Buffer[1];
IOT_DI2_2 = Buffer[2];
break;
case 3:
IOT_Clock.year = Buffer[1];
IOT_Clock.month = Buffer[2];
IOT_Clock.day = Buffer[3];
IOT_Clock.hour = Buffer[4];
IOT_Clock.minute = Buffer[5];
IOT_Clock.second = Buffer[6];
IOT_Clock.week = Buffer[7];
break;
}//switch (Buffer[0])
}//if( xStatus == pdPASS )
MB_USART2.send_buffer[0] = IOT_DI1_1;
MB_USART2.send_buffer[1] = IOT_DI1_2;
MB_USART2.send_buffer[2] = IOT_DI2_1;
MB_USART2.send_buffer[3] = IOT_DI2_2;
MB_USART2.send_buffer[4] = 0x20;
MB_USART2.send_buffer[5] = IOT_Clock.year;
MB_USART2.send_buffer[6] = IOT_Clock.month;
MB_USART2.send_buffer[7] = IOT_Clock.day;
MB_USART2.send_buffer[8] = IOT_Clock.hour;
MB_USART2.send_buffer[9] = IOT_Clock.minute;
MB_USART2.send_buffer[10] = IOT_Clock.second;
MB_USART2.send_buffer[11] = 0x0D;
MB_USART2.send_buffer[12] = 0x0A;
MB_USART2.sendCount = 13;
USART2_Begin_Send();
//vTaskDelay(50);
xResult = xSemaphoreTake(xSemaphore , xTicksToWait);//portMAX_DELAY);
if (xResult == pdTRUE)
{
strcpy(IOT_target_string , "\r\nNO CARRIER\r\n");
hex_to_string(MB_USART2.mscomm_buffer , IOT_source_string , MB_USART2.receCount);
if (strstr(IOT_source_string , IOT_target_string) != NULL)
{
IOT_4G_Outtime = 0x00;
IOT_4G_isr = 10;
vTaskDelay(100);
break;
}
}
vTaskDelay(1000);
break;
default:
vTaskDelay(100);
break;
}//switch (IOT_4G_isr)
}

复制代码

账号		自动登录	找回密码
密码			注册

类似于TCP三次握手、超时检测以及自动重发机制的通信任务该如何设计

主题推荐