zynq串口接收超时加软件FIFO+printf重定向

zynq的PS端裸跑时，其串口带有硬件FIFO，可大大降低中断频率。配合接收超时中断，可实现任意长度数据的非阻塞收发。

应用与驱动解耦

为实现驱动层与应用层解耦，不在中断服务函数中执行处理操作，串口的收发均使用软件环形队列解耦。

发送时：应用层将数据流写入发送队列，驱动层不是立刻发送，而是闲时从队列中取得，发出（发送至硬件FIFO）

接收时：驱动层将串口数据从硬件FIFO中取出，送入接收队列。应用层不是立刻处理，而是闲时从队列中取得，进行处理。

这样，驱动层中断服务函数仅操作队列，而应用层完全由主函数调用。

串口设备初始化

本来想使用Xilinx的固件库，可是他这库和STM32的固件库一样臃肿，串口本身非常简单，直接自己写了：

定义寄存器：（参考ug585）

#pragma pack(1)
typedef struct
{
    vu32 CR; //使能收发
    vu32 MR; //停止位等
    vu32 IER; //写1中断使能
    vu32 IDR; //写1中断失能
    vu32 IMR; //中断是否使能
    vu32 ISR; //中断状态
    vu32 BAUD;
    vu32 RX_TO; //接收超时，单位4bit
    vu32 RX_WM; //接收FIFO触发数
    vu32 MODEMCR; 
    vu32 MODEMSR;
    vu32 SR; //状态寄存器：
        //RXFIFO超限，RX空，RX满，TX空，TX满
    vu32 FIFO; //最多64
    vu32 BAUD_DIV;
    vu32 FLOW_DELAY;
    vu32 TX_TR; //发送FIFO触发数
} UART_TypeDef;
#pragma pack()

#define UART0 ((UART_TypeDef*)0xe0000000)
#define UART1 ((UART_TypeDef*)0xe0001000)

然后就能用UART0这样的方式来访问寄存器了。然后初始化寄存器：

void uart_initial(S_UART *obj,int b)
{
    int irq=XPAR_XUARTPS_0_INTR;
    if(obj->uart==UART0)
    {
        Queue_ini(uart0_tx_buf,sizeof(uart0_tx_buf),&(obj->que_tx));
        Queue_ini(uart0_rx_buf,sizeof(uart0_rx_buf),&(obj->que_rx));
    }
    if(obj->uart==UART1)
    {
        Queue_ini(uart1_tx_buf,sizeof(uart1_tx_buf),&(obj->que_tx));
        Queue_ini(uart1_rx_buf,sizeof(uart1_rx_buf),&(obj->que_rx));
        irq=XPAR_XUARTPS_1_INTR;
    }
    obj->uart->BAUD_DIV=6; //默认15误差大
    obj->uart->BAUD=100000000/b/(obj->uart->BAUD_DIV+1);
    obj->uart->CR = 0x14; //使能收发
    obj->uart->MR = 0x20; //n81
    obj->uart->RX_TO = 200; //单位4bit
    obj->uart->RX_WM = 60; //接收FIFO触发数
    obj->uart->TX_TR = 60; //发送FIFO触发数
//    obj->uart->IER = (1<<8) | //RX_TO
//                    (0<<3) | //TX空
//                    (1<<0); //接收
    obj->uart->IER = 0x101; //接收
    obj->uart->IER = 0x101; //接收,需要写两遍

    irq_reg(irq,uart_irq,obj);
    irq_enable(irq,1); //使能GIC中的串口中断
}

其中波特率为频率除以分频数再除以BAUD寄存器的值，为了保证精度，分频数需要选的比较小，默认为15（15+1分频），出115200波特率的时候误差比较大，无法正确接收数据。

收发FIFO触发数可以选择比较大，在不到FIFO触发数量时，通过接收超时机制来读数据。

其中IER不知道为啥需要写2遍，才能把接收超时的中断打开。

配置好串口寄存器后，通过GIC开串口中断。

串口发送流程

串口的发送是通过发送FIFO空中断实现的，机制与STM32的串口发送一样：

1、当无数据需要发送时，发送缓冲区空中断是关闭的。

2、当应用层需要发送数据时，所需发送的数据入队列，开发送缓冲区空中断，发送函数返回，不阻塞应用层调用。

3、由于发送缓冲区无数据，所以立刻进入中断，在中断中，从队列中取得数据，填入发送FIFO，直到FIFO接近满

4、中断返回

5、待FIFO中的数据发送完成，继续进发送空中断

6、中断中继续发送，或判断发送完成了，关闭发送空中断。

对比STM32的每个字节一个中断，zynq通过发送FIFO，可以实现60多字节一次中断，降低了中断频率。

发送函数：

void uart_send(u8 *p,int n,S_UART *obj) //串口发送
{
    int i;
    OS_CLOSE_INT;
    for(i=0;i<n;i++)
    {
        Queue_set_1(p[i],&(obj->que_tx));
    }
    obj->uart->IER = (1<<3);//TXE使能
    OS_OPEN_INT;
}

在发送函数中，先关闭中断，进入临界区，才能操作队列。

串口接收流程

串口的接收使用FIFO触发中断，设置触发数量为60，则串口接收满60字节才会触发中断。若串口需接收的字节数少于60个，则不会触发此中断。因此，还需要串口接收超时中断实现短帧接收。

串口接收超时机制需要在串口中断结束时人工复位：CR 的 bit6置位，然后才会产生新的计时

串口接收超时中断使能会被串口发送空中断失能信号清除，所以要注意在中断中使能此中断。

最后不能忘了清除中断标志，否则会一直出不来。中断服务函数：

void uart_irq(void *para)
{
    u8 t;
    S_UART *obj=(S_UART*)para;
    //u32 irq=obj->uart->ISR;
    obj->uart->ISR=0xfff; //清中断
    obj->uart->ISR=0xfff; //清中断，为什么需要清两次？

    while((obj->uart->SR & 0x02)==0)//接收非空
    {
        t=(u8)(obj->uart->FIFO);
        Queue_set_1(t,&(obj->que_rx));
    }
    if(obj->uart->SR & 8)//发送空TXE
    {
        while((obj->uart->SR & (1<<14))==0) //TX 没有接近满
        {
            if(Queue_get_1(&t,&(obj->que_tx))==0)
            {
                obj->uart->FIFO=t;
            }
            else
            {
                obj->uart->IDR = (1<<3);//TXE失能，会导致接收超时的中断失能
                obj->uart->IER |= (1<<8); //接收超时
                break;
            }
        }
    }
    obj->uart->CR = 0x14 | (1<<6); //使能收发，超时重置
}

应用层队列访问

在应用层访问队列时，需要通过临界区实现队列的互斥：

int get_que_data(u8 *p,Queue *q)
{
    int rst=1;
    OS_CLOSE_INT;
    rst=Queue_get_1(p,q);
    OS_OPEN_INT;
    return rst;
}

在主循环中查询接收队列：

if(uart0.que_rx.dlen>0) //这个只读不用锁
{
    while(get_que_data(&tt,&uart0.que_rx)==0)
    {
        rec_head(tt,&apptest_syn_obj);
    }
}

 printf重定向

zynq裸机的printf重定向是需要重载write函数，而write函数是封装在BSP中了，在应用程序中重载不成功。所以需要改BSP：

在ps7_cortexa9_0\libsrc\standalone_v6_8\src\write.c中重写write函数：

void void_write(u8 *p,int n){}
void (*printf_write)(u8 *p,int n)=void_write;
__attribute__((weak)) sint32 write (sint32 fd, char8* buf, sint32 nbytes)
{
    printf_write(buf,nbytes);
    return nbytes;
}

然后在应用程序中给printf_write函数指针赋值，将其设置为想要的数据流中，例如设置为uart0：

在main.c中添加：

void write (u8 *buf, int n) //重定向printf
{
    uart_send((u8*)buf,n,&uart0);
}
extern void (*printf_write)(u8 *p,int n);

int main()
{
    …………
    printf_write=write;
    printf("hello");
}

然后就能用非阻塞的printf了，中断里也能用，打印数据量大的话，可以提高队列容量