RT-Thread-串口每隔5s 接收24个数据的正确的处理方式应该怎么操作呢？RT-Thread问答社区

串口每隔5s 接收24个数据的正确的处理方式应该怎么操作呢？

发布于 2019-01-18 22:47:41 浏览：1921 订阅该版

* 本帖最后由 小住住 于 2019-1-18 22:49 编辑 *

按如下的方式处理，会出现错位的情况，那么问题来了这种很经典的问题的处理方式如何进行呢？

```   void uart_thread_entry(void* parameter)
{
    rt_uint8_t uart_rx_data[24];
      rt_uint8_t uart_reply_data[2];
     
      rt_uint8_t receive_byte_count=0;
      protocol_485_Delay_board_init();
    rt_pin_mode(DRIVER_485_TXH_RXL,PIN_MODE_OUTPUT);
      rt_pin_write(DRIVER_485_TXH_RXL, PIN_HIGH);
    /* ???? */
    if (uart_open("uart2") != RT_EOK)
    {
        rt_kprintf("uart open error.<br>");
         while (1)
         {
            rt_thread_delay(10);
         }
    }
while (1)
    {   
                          rt_uint8_t uart_rx_first;
        /* ??? */
         uart_rx_first= uart_getchar();//uart_rx_data[receive_byte_count]
        /* ?? */
       // uart_rx_data* = uart_rx_data* + 1;
       if ((uart_rx_first == 0x81) || (uart_rx_first == 0x82) || (uart_rx_first == 0x83))
                         {
                                uart_rx_data[0] = uart_rx_first ;
                                for(receive_byte_count = 1;receive_byte_count < 24 ; receive_byte_count++)
                                 {
                                        uart_rx_data[receive_byte_count] = uart_getchar();
                                }
                                        rt_pin_write(DRIVER_485_TXH_RXL, PIN_HIGH);
                                 // uart_rx_data[0]=0x11;
                          //        uart_putstring(uart_rx_data);
                          //if(receive_byte_count > 23)
                                //{
                                 if (protocol_485_parse_data(uart_rx_data,receive_byte_count))
                                        {
                                                rt_pin_write(DRIVER_485_TXH_RXL, PIN_HIGH);
                                                uart_reply_data[0] = uart_rx_data[0] + 5;
                                                uart_reply_data[1] = 0xAA;
                                                uart_putstring(uart_reply_data);
                                        }        
                                                receive_byte_count = 0;
                                          rt_memset(uart_rx_data,0,sizeof(uart_rx_data));
                                          rt_pin_write(DRIVER_485_TXH_RXL, PIN_LOW);
                                //}                
                           }                         
                          else
                          {                
                                  receive_byte_count = 0;
                          }```
```  tid2 = rt_thread_create("test",
                    uart_thread_entry, 
                    RT_NULL,
                    512, 
                    3, 
                    10);                 
                         if (tid2 != RT_NULL)
        rt_thread_startup(tid2);        ```
```/*
 * File      : app_uart.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 *2017-12-15      DQL          the first version 
 */

#include <rthw.h>
#include <rtthread.h>

#include "app_uart.h"

/* ´®¿Ú½ÓÊÕÊÂ¼þ±êÖ¾ */
#define UART_RX_EVENT (1 << 0)

/* ÊÂ¼þ¿ØÖÆ¿é */
static struct rt_event event;
/* ´®¿ÚÉè±¸¾ä±ú */
static rt_device_t uart_device = RT_NULL;
    
/* »Øµ÷º¯Êý */
static rt_err_t uart_intput(rt_device_t dev, rt_size_t size)
{
    /* ·¢ËÍÊÂ¼þ */
    rt_event_send(&event, UART_RX_EVENT);
    
    return RT_EOK;
}

rt_uint8_t uart_getchar(void)
{
    rt_uint32_t e;
    rt_uint8_t ch;
    
    /* ¶ÁÈ¡1×Ö½ÚÊý¾Ý */
    while (rt_device_read(uart_device, 0, &ch, 1) != 1)
    {
         /* ½ÓÊÕÊÂ¼þ */
        rt_event_recv(&event, UART_RX_EVENT,RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,RT_WAITING_FOREVER, &e);
    }

return ch;
}

void uart_putchar(const rt_uint8_t c)
{
    rt_size_t len = 0;
    rt_uint32_t timeout = 0;
    do
    {
        len = rt_device_write(uart_device, 0, &c, 1);
        timeout++;
    }
    while (len != 1 && timeout < 500);
}

void uart_putstring(const rt_uint8_t *s)
{
    while(*s)
    {
        uart_putchar(*s++);
    }
}

rt_err_t uart_open(const char *name)
{
    rt_err_t res;
                                 
    /* ²éÕÒÏµÍ³ÖÐµÄ´®¿ÚÉè±¸ */
    uart_device = rt_device_find(name);   
    /* ²éÕÒµ½Éè±¸ºó½«Æä´ò¿ª */
    if (uart_device != RT_NULL)
    {   
       
        res = rt_device_set_rx_indicate(uart_device, uart_intput);
        /* ¼ì²é·µ»ØÖµ */
        if (res != RT_EOK)
        {
            rt_kprintf("set %s rx indicate error.%d<br>",name,res);
            return -RT_ERROR;
        }

/* ´ò¿ªÉè±¸£¬ÒÔ¿É¶ÁÐ´¡¢ÖÐ¶Ï·½Ê½ */
        res = rt_device_open(uart_device, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX );       
        /* ¼ì²é·µ»ØÖµ */
        if (res != RT_EOK)
        {
            rt_kprintf("open %s device error.%d<br>",name,res);
            return -RT_ERROR;
        }

}
    else
    {
        rt_kprintf("can't find %s device.<br>",name);
        return -RT_ERROR;
    }

/* ³õÊ¼»¯ÊÂ¼þ¶ÔÏó */
    rt_event_init(&event, "event", RT_IPC_FLAG_FIFO); 
    
    return RT_EOK;
}

```

![111.png](https://oss-club.rt-thread.org/uploads/201901/18/224852gm1mz5q9dy5cm1by.png)

![111.png](https://oss-club.rt-thread.org/uploads/201901/18/224919qppluk4uul4iqi45.png)