UART

3.1.1串口接收问题

发布于 2018-10-23 22:08:16 浏览：1894 订阅该版

* 本帖最后由 aozima 于 2018-10-23 23:44 编辑 *

原来使用的是2.1.0版本，对GPS模块的数据进行接收没有问题的。现在换3.1.1  GPS接收卡在了接收中断里面。

有什么区别吗？麻烦大家给看看。

```rt_uint8_t gps_stack[1024];
struct rt_thread gps_thread;

rt_uint8_t GPS_timeflag=0;
rt_uint8_t GPS_stateflag=0;
rt_uint16_t GPS_timeCnt=0;

struct gps_rx_msg  
{  
    rt_device_t dev;  
    rt_size_t   size;  
};

static struct rt_messagequeue gps_rx_mq;

static unsigned char gps_rx_buffer[1024];
static unsigned char gps_msg_pool[1024];

rt_err_t gps_input(rt_device_t dev, rt_size_t size)
{
        struct gps_rx_msg msg;
        msg.dev = dev;
        msg.size = size;

rt_mq_send(&gps_rx_mq, &msg, sizeof(struct gps_rx_msg));
        return RT_EOK;
}

void gps_thread_entry(void* parameter)
{
        uint8_t gpspow_openstate=0;                
        struct gps_rx_msg msg;
        rt_device_t device;
        rt_err_t result = RT_EOK;
        
        
        device = rt_device_find(GPS_USE_UART);
        if (device!= RT_NULL)
        {

rt_device_set_rx_indicate(device, gps_input);

if(rt_device_open(device, RT_DEVICE_OFLAG_RDWR|RT_DEVICE_FLAG_INT_RX)== RT_EOK)
                        ;
                else
                        rt_kprintf("Open GPS %s false! <br>",GPS_USE_UART);
        }
        else
                rt_kprintf("Find GPS %s false! <br>",GPS_USE_UART);
        
        GPS_pow_on();
        
        while(1)
        {
                
                result = rt_mq_recv(&gps_rx_mq, &msg, sizeof(struct gps_rx_msg), 10);                        
                if (result == -RT_ETIMEOUT)
                {
                }
                if (result == RT_EOK)
                {
                        rt_uint32_t rx_length;
                        rx_length = (sizeof(gps_rx_buffer) - 1) > msg.size ? msg.size : sizeof(gps_rx_buffer) - 1;
                        
                        rx_length = rt_device_read(msg.dev, 0, &gps_rx_buffer[0],rx_length);
            gps_rx_buffer[rx_length] = '\0';
                        rt_kprintf("%s",gps_rx_buffer);
                }                
        }        
}
void gps_app_init(void)
{
                rt_thread_t thread ;  
                        
                rt_err_t result;

result = rt_mq_init(&gps_rx_mq, "mqt", &gps_msg_pool[0], 128 - sizeof(void*), sizeof(gps_msg_pool), RT_IPC_FLAG_FIFO);  
                 
                if (result != RT_EOK)   
                {   
                                rt_kprintf("init message queue failed.<br>");   
                                return;   
                }   
    thread = rt_thread_create("gps",  
        gps_thread_entry, RT_NULL,  
        4096, 25, 100);

if (thread != RT_NULL)  
        rt_thread_startup(thread);          
}```

程序全速时，可以到rt_device_read这个函数，然后就死在了串口中断里面出不了。其他线程也都卡住了。

使用堵塞模块是可以接收数据的。

请大家多多指教！！谢谢！！！

4 个回答

jeasey 2018-10-23

这家伙很懒，什么也没写！

aozima 2018-10-23

调网络不抓包，调I2C等时序不上逻辑分析仪，就像电工不用万用表！多用整理的好的文字，比截图更省流量，还能在整理过程中思考。

jeasey 2018-10-24

这家伙很懒，什么也没写！

[i=s] 本帖最后由 aozima 于 2018-10-25 19:31 编辑 [/i]

现在3.1.1版本串口中断处理都时使用的HAL库。源代码是这样的

```
#if defined(RT_USING_UART2)
/* UART2 device driver structure */
static struct drv_uart uart2;
struct rt_serial_device serial2;
void USART2_IRQHandler(void)
{
    struct drv_uart *uart;
    uart = &uart2;
    /* enter interrupt */
    rt_interrupt_enter();
    /* UART in mode Receiver -------------------------------------------------*/
    if ((__HAL_UART_GET_FLAG(&uart->UartHandle, UART_FLAG_RXNE) != RESET) &&
            (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET))
    {
        rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND);
        /* Clear RXNE interrupt flag */
        __HAL_UART_CLEAR_FLAG(&uart->UartHandle, UART_FLAG_RXNE);
    }
    /* leave interrupt */
    rt_interrupt_leave();
}
#endif /* RT_USING_UART2 */

原来使用的2.1.0使用的是库函数版本，源代码是这样的
void USART1_IRQHandler(void)
{
    /* enter interrupt */
    rt_interrupt_enter();

uart_isr(&serial1);

/* leave interrupt */
    rt_interrupt_leave();
}

static void uart_isr(struct rt_serial_device *serial)
{
    struct stm32_uart *uart = (struct stm32_uart *) serial->parent.user_data;

RT_ASSERT(uart != RT_NULL);

if(USART_GetITStatus(uart->uart_device, USART_IT_RXNE) != RESET)
    {
        rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
        /* clear interrupt */
        USART_ClearITPendingBit(uart->uart_device, USART_IT_RXNE);
    }
    if(USART_GetITStatus(uart->uart_device, USART_IT_IDLE) != RESET)
    {
        dma_uart_rx_idle_isr(serial);
    }
    if (USART_GetITStatus(uart->uart_device, USART_IT_TC) != RESET)
    {
        /* clear interrupt */
        USART_ClearITPendingBit(uart->uart_device, USART_IT_TC);
    }
    if (USART_GetFlagStatus(uart->uart_device, USART_FLAG_ORE) == SET)
    {
        USART_ReceiveData(uart->uart_device);
    }
}
```

也没有清溢出中断。

还请多多指教！！！谢谢！！！