[技术问答] 串口驱动与中断控制器

/*************************************************************************************************************

 * 文件名:                        uart.c

 * 功能:                        NUC970 UART通讯支持

 * 作者:                        cp1300@139.com

 * 创建时间:                2020-08-29

 * 最后修改时间:        2020-08-29

 * 详细:                        串口通信底层支持,可惜串口都不支持DMA传输，只能使用中断方式接收数据

*************************************************************************************************************/

#include "nuc970_system.h"

#include "uart.h"

#include "typedef.h"

#include "irq_aic.h"

 

//串口中断接收函数

__inline static void UARTx_IRQHandler(UART_CH_Type ch);                                //串口中断处理

static void UART0_IRQHandler(void) {UARTx_IRQHandler(UART_CH0);}        //串口0接收中断

static void UART1_IRQHandler(void) {UARTx_IRQHandler(UART_CH1);}        //串口1接收中断

static void UART2_IRQHandler(void) {UARTx_IRQHandler(UART_CH2);}        //串口2接收中断

static void UART3_IRQHandler(void) {UARTx_IRQHandler(UART_CH3);}        //串口3接收中断

static void UART4_IRQHandler(void) {UARTx_IRQHandler(UART_CH4);}        //串口4接收中断

static void UART5_IRQHandler(void) {UARTx_IRQHandler(UART_CH5);}        //串口5接收中断

static void UART6_IRQHandler(void) {UARTx_IRQHandler(UART_CH6);}        //串口6接收中断

static void UART7_IRQHandler(void) {UARTx_IRQHandler(UART_CH7);}        //串口7接收中断

static void UART8_IRQHandler(void) {UARTx_IRQHandler(UART_CH8);}        //串口8接收中断

static void UART9_IRQHandler(void) {UARTx_IRQHandler(UART_CH9);}        //串口9接收中断

static void UART10_IRQHandler(void) {UARTx_IRQHandler(UART_CH10);}        //串口10接收中断

 

//中断编号

static const AIC_IRQ_Typedef scg_UartIrqType[UART_ChMax] = 

{        AIC_UART0_INT,         AIC_UART1_INT,         AIC_UART2_INT,         AIC_UART3_INT,         AIC_UART4_INT, 

        AIC_UART5_INT,         AIC_UART6_INT,         AIC_UART7_INT,         AIC_UART8_INT,         AIC_UART9_INT, AIC_UART10_INT};        

//中断函数集合        

static const void *scg_pUartIrqHandle[UART_ChMax] = 

        {(const void *)UART0_IRQHandler,         (const void *)UART1_IRQHandler,         (const void *)UART2_IRQHandler, 

        (const void *)UART3_IRQHandler,         (const void *)UART4_IRQHandler,         (const void *)UART5_IRQHandler, 

        (const void *)UART6_IRQHandler,                (const void *)UART7_IRQHandler,         (const void *)UART8_IRQHandler, 

        (const void *)UART9_IRQHandler,         (const void *)UART10_IRQHandler};

//串口基址        

static const u32 scg_UARTx_Base[UART_ChMax] = 

{        UART0_BASE,         UART1_BASE,         UART2_BASE,         UART3_BASE,         UART4_BASE,         UART5_BASE, 

        UART6_BASE,         UART7_BASE,         UART8_BASE,         UART9_BASE,         UART10_BASE};

//时钟使能        

static const SYS_DEV_CLOCK scg_UARTx_DeviceClockEnable[UART_ChMax]         = 

{        DEV_UART0,         DEV_UART1,         DEV_UART2,         DEV_UART3,         DEV_UART4,         DEV_UART5, 

        DEV_UART6,         DEV_UART7,         DEV_UART8,         DEV_UART9,         DEV_UART10};                

//外设复位        

static const SYS_DEV_RESET scg_UARTx_DeviceReset[UART_ChMax] = 

{        DEV_RESET_UART0,         DEV_RESET_UART1,         DEV_RESET_UART2,         DEV_RESET_UART3, DEV_RESET_UART4,         DEV_RESET_UART5, 

        DEV_RESET_UART6,         DEV_RESET_UART7,         DEV_RESET_UART8,         DEV_RESET_UART9, DEV_RESET_UART10};                        

//IO复用功能

static const GPIO_AF_Type scg_UARTx_AF_GPIO[UART_ChMax][2] = 

{

        {GPIO_PE0_UART0_TXD,         GPIO_PE1_UART0_RXD},         {GPIO_PE2_UART1_TXD,         GPIO_PE3_UART1_RXD},         {GPIO_PF11_UART2_TXD,         GPIO_PF12_UART2_RXD},

        {GPIO_PE12_UART3_TXD,         GPIO_PE13_UART3_RXD},        {GPIO_PH8_UART4_TXD,        GPIO_PH9_UART4_RXD},        {GPIO_PB0_UART5_TXD,        GPIO_PB1_UART5_RXD},

        {GPIO_PB2_UART6_TXD,        GPIO_PB3_UART6_RXD},        {GPIO_PG4_UART7_TXD,        GPIO_PG5_UART7_RXD},        {GPIO_PH12_UART8_TXD,        GPIO_PH13_UART8_RXD},

        {GPIO_PD14_UART9_TXD,        GPIO_PD15_UART9_RXD},        {GPIO_PB12_UART10_TXD,        GPIO_PB13_UART10_RXD}

};

        

        

        

//相关UART状态结构

typedef struct

{

        bool                isNewDataFlag;        //接收到新数据

        bool                isBuffFull;                //接收Buff满

        bool                isIntRx;                //是否开启中断接收

        u8                         *RxBuff;                //接收Buff指针

        u16                        RxBuffSize;                //接收缓冲区大小,一帧数据大小

        u16                 UartRxCnt;                //接收数据计数器

        u8                        TempData;                //用于接收溢出后读取数据寄存器，清除读取数据标志

} UartRx_TypeDef;

static UartRx_TypeDef sg_UartRx[UART_ChMax];

 

/*************************************************************************************************************************

*函数                :        bool UARTx_Config(UART_CH_Type ch,UART_Config_TypeDef * cfg)

*功能                :        串口配置

*参数                :        ch：串口号；cfg：配置结构体

*返回                :        TRUE:配置成功; FALSE: 配置失败

*依赖                        :         底层宏定义

*作者               :        cp1300@139.com

*时间                     :        2020-08-11

*最后修改时间        :        2020-08-30

*说明                :        配置前最好确保数据已经发送完成，没有数据正在发送

*************************************************************************************************************************/

bool UARTx_Config(UART_CH_Type ch,UART_Config_TypeDef * cfg)

{

        u32 temp;

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return FALSE;                                                        //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                                        //获取设备基址

        

        temp = 0;

        //奇偶校验

        switch(cfg->OddEvenVerify)        

        {

                case UART_ODD:        //奇校验

                {

                        temp |= BIT3;        //使能奇偶校验-校验位发送

                }break;

                case UART_EVEN:        //偶校验

                {

                        temp |= BIT4;        //偶校验

                        temp |= BIT3;        //使能奇偶校验-校验位发送

                }break;

                default:break;        //无校验

        }

        //停止位

        if(cfg->StopBitWidth != UART_STOP_1BIT)        //不止1个停止位

        {

                temp |= BIT2;        //当选择6位，7位和8位字长时，将生成两个“ STOP位”

        }

        //数据长度

        temp |= cfg->DataBitWidth & 0x03;        //数据位长度设置

        

        while((UARTx->FSR & BIT28) == 0);        //等待发送移位寄存器为空，等待数据发送完成再进行配置

        UARTx->LCR = temp;

 

        return TRUE;

}

 

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_SetBaudRate(UART_CH_Type ch,u32 baud)

* 功能        :        串口波特率设置

* 参数        :        ch:通道选择,baud:波特率,如9600,115200等等

* 返回        :        无

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        2013316

* 最后修改时间 : 2013316

* 说明        :         USART1~UART5,对应通道UART_CH1-UART_CH5

                        设置前必须关闭串口

                        会自动获取系统当前的时钟,并进行计算.

*************************************************************************************************************************/

bool UARTx_SetBaudRate(UART_CH_Type ch,u32 baud)

{

        u32 temp = 0;

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return FALSE;                        //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];        //获取设备基址

        temp = 12000000;                                                                //获取系统时钟

        temp = temp / baud;                                                                //计算波特率分频系数

        temp -= 2;

        if(temp < 9) temp = 9;

        temp |= 0x03 << 28;                                                                //DIV_X_EN=1 DIV_X_ONE=1 模式3 波特率=时钟/(A+2), A 必须大于9

        

        while((UARTx->FSR & BIT28) == 0);                                //等待发送移位寄存器为空，等待数据发送完成再进行配置

        UARTx->BAUD = temp;

 

        return TRUE;

}

 

 

 

 

/*************************************************************************************************************************

* 函数        :        bool UARTx_Init(UART_CH_Type ch,u32 Speed,bool isEnableRx)

* 功能        :        串口初始化

* 参数        :        ch:通道选择,0->usart1,Speed:串口速度,isEnableRx:是否使能接收

* 返回        :        TRUE:成功,FALSE:失败

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 2020-08-17

* 说明        :         

*************************************************************************************************************************/

bool UARTx_Init(UART_CH_Type ch,u32 Speed,bool isEnableRx)

{

        UART_Config_TypeDef cfg;

        UART_TypeDef *UARTx;

 

        if(ch > (UART_ChMax - 1)) return FALSE;                                                        //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                                        //获取设备基址

        

        SYS_DeviceClockEnable(scg_UARTx_DeviceClockEnable[ch], TRUE);        //使能时钟

        SYS_DeviceReset(scg_UARTx_DeviceReset[ch]);                                                //复位外设

 

        UARTx->IER = 0;                                                                                                        //关闭所有中断

        UARTx->FCR = (5<<4) | BIT2 | BIT1;                                                                //接收FIFO阈值46/14,开启接收，收发FIFO复位

        if(isEnableRx)                                                                                                        //是否使能接收-禁用接收

        {

                UARTx->IER = BIT11 | BIT4 | BIT0;                                                        //开启接收超时计数器，开启接收超时中断,使能接收数据有效中断

        }

        else

        {

                AIC_IrqEnable(scg_UartIrqType[ch], FALSE);                                        //关闭串口AIC中断

        }

        //配置

        UARTx->TOR = (0<<8) | (6*10);                                                                        //发送字节延时为0，接收超时计数器为6个字节时间

        cfg.DataBitWidth = UART_DATA_8BIT;                                                                //数据宽度8

        cfg.OddEvenVerify = UART_VERIFY_NULL;                                                        //无奇偶校验

        cfg.StopBitWidth = UART_STOP_1BIT;                                                                //1个停止位

        if(UARTx_SetBaudRate(ch, Speed) == FALSE) return FALSE;                        //设置波特率

        if(UARTx_Config(ch, &cfg) == FALSE) return FALSE;                                //设置串口数据格式

        sg_UartRx[ch].isIntRx = FALSE;                                                                        //没有开启中断接收

        

        //IO初始化

        SYS_GPIOx_SetAF(scg_UARTx_AF_GPIO[ch][0]);                                                 //TXD 复用功能设置

        SYS_GPIOx_SetAF(scg_UARTx_AF_GPIO[ch][1]);                                                 //RXD 复用功能设置

        if(isEnableRx)

        {

                UARTx->ISR = UARTx->ISR;                                                                                                //清除中断信息

                AIC_SetIrqTriggered(scg_UartIrqType[ch], AIC_HIGHT_EDGE);                                //设置串口中断上升沿触发

                AIC_SetIrqPriority(scg_UartIrqType[ch], UART_INT_PRIO);                                        //设置一个中断优先级

                AIC_RegisterIRQHandler(scg_UartIrqType[ch], (void (*)(void))scg_pUartIrqHandle[ch]);        //注册中断服务程序

                AIC_IrqEnable(scg_UartIrqType[ch], TRUE);                                                                //开启串口AIC中断

                

                sg_UartRx[ch].isIntRx = FALSE;                                                                                        //开启了中断接收

        }

 

        return TRUE;

}

 

 

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_SendByte(UART_CH_Type ch,u8 data)

* 功能        :        UART单字节发送

* 参数        :        ch:通道号,dataL:要发送的数据

* 返回        :        无

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 2020-08-12

* 说明        :         单字节发送不要使用DMA，浪费

*************************************************************************************************************************/

void UARTx_SendByte(UART_CH_Type ch,u8 data)

{

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return;                                                //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                        //获取设备基址

        while(UARTx->FSR & BIT23);                                                                //等待TX FIFO未满

         UARTx->RBR_THR = data;                                                                        //发送数据-写到FIFO中而已，并不会等待数据发送完成

}

 

 

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_SendData(UART_CH_Type ch,u8 *tx_buff,u16 byte_number)

* 功能        :        UART数据发送函数

* 参数        :        ch:通道号,tx_buff:发送缓冲区,byte_number:需要发送的字节

* 返回        :        无

* 依赖        :        void UART_SendByte(u8 ch,u8 data)

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 20120403

* 说明        :         

*************************************************************************************************************************/

void UARTx_SendData(UART_CH_Type ch,u8 *pTxBuff,u16 DataLen)

{

        u16 i;

        if(ch > (UART_ChMax - 1)) return;                                        //端口号超出范围

        

        for(i = 0;i < DataLen;i++)                                                        //循环发送,直至发送完毕

        {

                 UARTx_SendByte(ch, pTxBuff[i]);

        }

#if (!UART_TX_TO_FIFI)        //要求等待数据发送完成

        UARTx_WaitSendComplete(ch);                                //等待数据发送完成-从串口发送完成

#endif //UART_TX_TO_FIFI        

}

 

 

/*************************************************************************************************************************

* 函数                        :        void UARTx_WaitSendComplete(UART_CH_Type ch)

* 功能                        :        等待数据发送完成-从串口发送完成

* 参数                        :        ch:通道号

* 返回                        :        无

* 依赖                        :        无

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-29

* 最后修改时间         :         2020-08-29

* 说明                        :

*************************************************************************************************************************/

void UARTx_WaitSendComplete(UART_CH_Type ch)

{

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return;                                                //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                        //获取设备基址

        while((UARTx->FSR & BIT28) == 0);                                                //等待发送移位寄存器为空

}

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_SendString(UART_CH_Type ch,char *pString)

* 功能        :        UART发送字符串

* 参数        :        ch:通道号

                        pString:字符串指针

* 返回        :        无

* 依赖        :        void UART_SendByte(u8 ch,u8 data)

* 作者        :        cp1300@139.com

* 时间        :        2013-04-18

* 最后修改时间 : 2013-04-18

* 说明        :         非DMA方式,非FIFO方式发送

*************************************************************************************************************************/

#include "string.h"

void UARTx_SendString(UART_CH_Type ch,char *pString)

{        

        if(ch > (UART_ChMax - 1)) return;                                        //端口号超出范围

        

        UARTx_SendData(ch, (u8 *)pString, strlen(pString));

}

 

 

 

 

 

 

/*************************************************************************************************************************

* 函数        :        bool UARTx_GetNewDataFlag(UART_CH_Type ch)

* 功能        :        获取串口新数据标志

* 参数        :        ch:通道选择

* 返回        :        TRUE:成功,FALSE:失败

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 20120403

* 说明        :         用于判断是否有新的数据,会清除掉新数据标志的

*************************************************************************************************************************/

bool UARTx_GetNewDataFlag(UART_CH_Type ch)

{

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return FALSE;                                                //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                                //获取设备基址

 

        if(sg_UartRx[ch].isIntRx == TRUE)                                                        //开启了中断接收

        {

                if(sg_UartRx[ch].isNewDataFlag == TRUE)                                 //有新数据

                {

                         sg_UartRx[ch].isNewDataFlag = FALSE;                                //清除标志

                        return TRUE;                                                                                //返回有新数据

                }

        }

        else                                                                                                                //没开启中断接收

        {

                 if((UARTx->FSR & BIT14) == 0)                                                        //接收FIFO不为空

                {

                        return TRUE;

                }

        }

        return FALSE;

}

 

 

/*************************************************************************************************************************

* 函数        :        bool UARTx_GetRxBuffFullFlag(UART_CH_Type ch)

* 功能        :        获取串口接收缓冲区满标志

* 参数        :        ch:通道选择

* 返回        :        TRUE:成功,FALSE:失败

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 20120403

* 说明        :         用于判断接收缓冲区是否满,会清除标志

*************************************************************************************************************************/

bool UARTx_GetRxBuffFullFlag(UART_CH_Type ch)

{

        if(ch > (UART_ChMax - 1)) return FALSE;                                        //端口号超出范围

 

        if(sg_UartRx[ch].isBuffFull == TRUE)                        //缓冲区已满

        {

                 sg_UartRx[ch].isBuffFull = FALSE;                        //清除满标志

                return TRUE;

        }

        return FALSE;

}

 

 

 

 

/*************************************************************************************************************************

* 函数        :        u8 UARTx_GetNewData(UART_CH_Type ch)

* 功能        :        获取串口新数据

* 参数        :        ch:通道选择

* 返回        :        收到的数据

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 20120403

* 说明        :         用于接收一个字节数据

*************************************************************************************************************************/

u8 UARTx_GetNewData(UART_CH_Type ch)

{

        UART_TypeDef *UARTx;

        

        if(ch > (UART_ChMax - 1)) return FALSE;                                                //端口号超出范围

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                                //获取设备基址

 

        return UARTx->RBR_THR;                                                                                        //返回数据

}

 

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_SetRxBuff(UART_CH_Type ch,u8 *RxBuff,u16 RxBuffSize)

* 功能        :        设置串口接收缓冲区

* 参数        :        ch:通道选择,RxBuffSize:缓冲区大小,RxBuff:缓冲区指针

* 返回        :        无

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20120403

* 最后修改时间 : 20120403

* 说明        :         一定要设置,否则开启中断接收时可能会异常

*************************************************************************************************************************/

void UARTx_SetRxBuff(UART_CH_Type ch,u8 *RxBuff,u16 RxBuffSize)

{

#ifdef _UCOS_II_

        OS_CRITICAL_SR_VAL;

#endif        //_UCOS_II_

        

        if(ch > (UART_ChMax - 1)) return;                                        //端口号超出范围

                

#ifdef _UCOS_II_

        OS_EnterCriticalSection();                         //进入临界区

#endif        //_UCOS_II_

        sg_UartRx[ch].RxBuffSize = RxBuffSize;                                 //设置缓冲区大小

        sg_UartRx[ch].RxBuff = RxBuff;                                                //设置缓冲区指针        

        sg_UartRx[ch].UartRxCnt = 0;                                                //计数器清零

#ifdef _UCOS_II_

        OS_LeaveCriticalSection();                         //退出临界区

#endif        //_UCOS_II_

}

 

 

 

 

 

/*************************************************************************************************************************

* 函数        :        u32 UARTx_GetRxCnt(UART_CH_Type ch)

* 功能        :        获取串口接收数据计数器

* 参数        :        ch:通道选择

* 返回        :        接收到的数据数量

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20130307

* 最后修改时间 : 20130307

* 说明        :         无

*************************************************************************************************************************/

u32 UARTx_GetRxCnt(UART_CH_Type ch)

{        

        if(ch > (UART_ChMax - 1)) return 0;                                        //端口号超出范围

        

        return sg_UartRx[ch].UartRxCnt;                                                //返回计数值        

}

 

 

 

 

/*************************************************************************************************************************

* 函数        :        void UARTx_ClearRxCnt(UART_CH_Type ch)

* 功能        :        清除串口接收数据计数器

* 参数        :        ch:通道选择

* 返回        :        无

* 依赖        :        底层宏定义

* 作者        :        cp1300@139.com

* 时间        :        20130307

* 最后修改时间 : 20130307

* 说明        :         无

*************************************************************************************************************************/

void UARTx_ClearRxCnt(UART_CH_Type ch)

{

        if(ch > (UART_ChMax - 1)) return;                                        //端口号超出范围

        sg_UartRx[ch].UartRxCnt = 0;                                                //计数器清零

}

 

 

 

//用于串口中断中循环读取数据

__inline static void UARTx_ReadRxData(UART_CH_Type ch, UART_TypeDef *UARTx)

{

    while((UARTx->FSR & BIT14) == 0)                                                                                                                                                   //接收FIFO中有数据，循环读取

    {

        if((sg_UartRx[ch].RxBuffSize) > 0 && (sg_UartRx[ch].UartRxCnt < sg_UartRx[ch].RxBuffSize))                        //接收缓冲区大于0,并且没有满

        {

            (sg_UartRx[ch].RxBuff)[(sg_UartRx[ch].UartRxCnt) ++] = UARTx->RBR_THR;                                                         //将数据存放到缓冲区

            if(sg_UartRx[ch].UartRxCnt == sg_UartRx[ch].RxBuffSize)                                                                                 //缓冲区已满

            {

                 //sg_UartRx[ch].UartRxCnt = 0;                                                                                                                                //接收计数器清零

                  sg_UartRx[ch].isBuffFull = TRUE;                                                                                                                        //缓冲区已满标志

            }        

        }

        else //缓冲区满了，清除接收到的数据

        {

            sg_UartRx[ch].TempData = UARTx->RBR_THR;

        }

    }

}

 

 

 

//串口中断处理

__inline static void UARTx_IRQHandler(UART_CH_Type ch)

{

        UART_TypeDef *UARTx;

        

        UARTx = (UART_TypeDef *) scg_UARTx_Base[ch];                                //获取设备基址

        if(UARTx->ISR & BIT0)                                                                                //FIFO收到指定数据的数据了

        {

                UARTx_ReadRxData(ch, UARTx);

        }

        

        if(UARTx->ISR & BIT4)                                                                                //FIFO有数据，但是收到足够数据并且超时了，需要去除余下的数据

        {

        UARTx_ReadRxData(ch, UARTx);                                                        //收到的数据没有满足FIFO阈值

        }

        

        UARTx->ISR = UARTx->ISR;                                                                        //清除中断

}

 

/*************************************************************************************************************

 * 文件名:                        uart.h

 * 功能:                        NUC970 UART通讯支持

 * 作者:                        cp1300@139.com

 * 创建时间:                2020-08-29

 * 最后修改时间:        2020-08-29

 * 详细:                        串口通信底层支持

*************************************************************************************************************/

#ifndef _UART_H_  

#define _UART_H_

#include "nuc970_system.h"

 

/***********************配置相关************************/

#define UART_TX_TO_FIFI        1                        //1:数据发送到发送FIFO则认为发送完成; 0:数据从移位寄存器发送完成则认为发送完成

#define UART_ChMax                11                        //串口通道数量

#define UART_INT_PRIO        3                        //中断优先级，1-7

 

/*********************************************************/

 

 

 

//串口选择,串口1开始,到串口3

typedef enum

{

        UART_CH0        =                0,        //UART0

        UART_CH1        =                1,        //UART1-高速

        UART_CH2        =                2,        //UART2-高速

        UART_CH3        =                3,        //UART3

        UART_CH4        =                4,        //UART4-高速

        UART_CH5        =                5,        //UART5

        UART_CH6        =                6,        //UART6-高速

        UART_CH7        =                7,        //UART7

        UART_CH8        =                8,        //UART8-高速

        UART_CH9        =                9,        //UART9

        UART_CH10        =                10,        //UART10

}UART_CH_Type;

 

 

//UART配置相关结构定义

typedef struct

{

        u8 OddEvenVerify;        //奇偶校验,奇,偶,无

        u8 StopBitWidth;        //停止位位宽1,2

        u8 DataBitWidth;        //数据位宽度

} UART_Config_TypeDef;

 

 

//奇偶校验

#define UART_VERIFY_NULL        0        //无校验

#define UART_ODD                        1        //奇校验

#define UART_EVEN                        2        //偶校验

//停止位

#define UART_STOP_1BIT                0        //一个停止位

#define UART_STOP_2BIT                1        //2个停止位

//数据位数

#define UART_DATA_5BIT                0        //5位数据长度

#define UART_DATA_6BIT                1        //6位数据长度

#define UART_DATA_7BIT                2        //7位数据长度

#define UART_DATA_8BIT                3        //8位数据长度

 

//相关API

bool UARTx_Init(UART_CH_Type ch,u32 Speed, bool isEnableRx);                //串口初始化

void UARTx_SendByte(UART_CH_Type ch,u8 data);                                                //UART单字节发送

void UARTx_SendData(UART_CH_Type ch,u8 *pTxBuff,u16 DataLen);                //UART数据发送函数

void UARTx_WaitSendComplete(UART_CH_Type ch);                                                //等待数据发送完成-从串口发送完成

void UARTx_SendString(UART_CH_Type ch,char *pString);                                //UART发送字符串

bool UARTx_GetNewDataFlag(UART_CH_Type ch);                                                        //获取串口新数据标志

bool UARTx_GetRxBuffFullFlag(UART_CH_Type ch);                                                //获取串口接收缓冲区满标志

u8          UARTx_GetNewData(UART_CH_Type ch);                                                                //获取串口新数据

void UARTx_SetRxBuff(UART_CH_Type ch,u8 *RxBuff,u16 RxBuffSize);        //设置串口接收缓冲区

void UARTx_ClearRxInt(UART_CH_Type ch);                                                                //清除串口接收中断标志

u32  UARTx_GetRxCnt(UART_CH_Type ch);                                                                //获取串口接收数据计数器

void UARTx_ClearRxCnt(UART_CH_Type ch);                                                                //清除串口接收数据计数器

 

#endif //_UART_H_

 

 

/*************************************************************************************************************

 * 文件名:                        irq_aic.c

 * 功能:                        NUC970 中断控制器

 * 作者:                        cp1300@139.com

 * 创建时间:                2020-08-30

 * 最后修改时间:        2020-08-30

 * 详细:                        中断控制器驱动

*************************************************************************************************************/

#include "nuc970_system.h"

#include "irq_aic.h"

#include "typedef.h"

 

static void NULL_IRQHandler(void){};                                //一个空的中断服务程序

static void *sg_IRQHandlerTable[NUMBER_OF_INT_VECTORS];             //中断服务程序入口列表

static bool sg_AIC_InitStatus = FALSE;                                                                //AIC初始化状态,防止重复初始化

        

 

/*************************************************************************************************************************

* 函数                        :        void AIC_Init(void)

* 功能                        :        AIC中断控制器初始化（在系统初始化中调用，请勿重复调用）

* 参数                        :        无

* 返回                        :        无

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        初始化屏蔽所有中断，设置所有中断优先级为最低，并初始化所有中断服务程序入口

                                        请不要重复初始化

*************************************************************************************************************************/

void AIC_Init(void)

{

        u32 i;

        

        if(sg_AIC_InitStatus == TRUE)        return;

        for(i = 0;i < NUMBER_OF_INT_VECTORS;i ++)

        {

                sg_IRQHandlerTable[i] = NULL_IRQHandler;                                //设置默认的中断函数

                AIC_ClearIrqActive((AIC_IRQ_Typedef) i);                                //AIC软件中断激活状态清除

                AIC_IrqEnable((AIC_IRQ_Typedef)i, FALSE);                                //设置一个中断使能状态-关闭

                AIC_SetIrqTriggered((AIC_IRQ_Typedef)i, AIC_LOW_LEVEL);        //设置一个中断触发方式-低电平触发

                AIC_SetIrqPriority((AIC_IRQ_Typedef)i, 7);                                //设置一个中断优先级-最低优先级

        }

        sg_AIC_InitStatus = TRUE;                                                                        //已经初始化了

        AIC->EOSCR = 1;                //写入任何值，告诉AIC中断执行完毕了,防止之前有未退出的中断

}

        

 

 

/*************************************************************************************************************************

* 函数                        :        void AIC_RegisterIRQHandler(AIC_IRQ_Typedef AIC_IRQ_n, void (*pIRQHandler)(void))

* 功能                        :        注册中断服务程序

* 参数                        :        AIC_IRQ_n：中断源；pIRQHandler：中断服务程序

* 返回                        :        无

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        

*************************************************************************************************************************/

void AIC_RegisterIRQHandler(AIC_IRQ_Typedef AIC_IRQ_n, void (*pIRQHandler)(void))

{

    if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

    if(pIRQHandler == NULL) //无效的，则使用默认的替代，防止为空

    {

        sg_IRQHandlerTable[AIC_IRQ_n] = (void *)NULL_IRQHandler;

    }

    else

    {

        sg_IRQHandlerTable[AIC_IRQ_n] = (void *)pIRQHandler;

    }

}

 

 

 

 

/*************************************************************************************************************************

* 函数                        :        void AIC_SetIrqTriggered(AIC_IRQ_Typedef AIC_IRQ_n, AIC_IntType AIC_INT_Triggered) 

* 功能                        :        设置一个中断触发方式

* 参数                        :        AIC_IRQ_n：中断源；AIC_INT_Triggered：触发方式，见AIC_IntType

* 返回                        :        无

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        

*************************************************************************************************************************/

void AIC_SetIrqTriggered(AIC_IRQ_Typedef AIC_IRQ_n, AIC_IntType AIC_INT_Triggered) 

{

        u8 n,i;

        u32 temp;

        

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

        n = AIC_IRQ_n / 4;

        i = AIC_IRQ_n % 4;

 

        temp = AIC->SCR[n];

        temp &= ~(0x03 << (i*8 + 6));                                                        //清除之前配置

        temp |= (AIC_INT_Triggered & 0x03) << (i*8 + 6);                //重新配置

        AIC->SCR[n] = temp;

}

 

/*************************************************************************************************************************

* 函数                        :        void AIC_SetIrqPriority(AIC_IRQ_Typedef AIC_IRQ_n, u8 AIC_INT_Prio) 

* 功能                        :        设置一个中断优先级

* 参数                        :        AIC_IRQ_n：中断源；AIC_INT_Prio：优先级0-7

* 返回                        :        无

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        优先级0会变为快速中断

*************************************************************************************************************************/

void AIC_SetIrqPriority(AIC_IRQ_Typedef AIC_IRQ_n, u8 AIC_INT_Prio) 

{

        u8 n,i;

        u32 temp;

 

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

        n = AIC_IRQ_n / 4;

        i = AIC_IRQ_n % 4;

        

        if(AIC_INT_Prio > 7) AIC_INT_Prio = 7;                                        //优先级限制最低为7

        temp = AIC->SCR[n];

        temp &= ~(0x07 << (i*8 + 0));                                                        //清除之前配置

        temp |= (AIC_INT_Prio & 0x07) << (i*8 + 0);                                //重新配置

        AIC->SCR[n] = temp;

}

 

/*************************************************************************************************************************

* 函数                        :        bool AIC_GetIrqRawStatus(AIC_IRQ_Typedef AIC_IRQ_n) 

* 功能                        :        获取中断原始触发状态

* 参数                        :        AIC_IRQ_n：中断源

* 返回                        :        TRUE:中断已经触发;FALSE:中断未触发

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        获取的是每个中断通道内的内部状态，不受中断屏蔽影响

*************************************************************************************************************************/

bool AIC_GetIrqRawStatus(AIC_IRQ_Typedef AIC_IRQ_n) 

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return FALSE;

        if(AIC->IRSR[AIC_IRQ_n/32] & (1 << (AIC_IRQ_n%32))) 

        {

                return TRUE;

        }

        else

        {

                return FALSE;

        }

}

 

 

/*************************************************************************************************************************

* 函数                        :        bool AIC_GetIrqActiveStatus(AIC_IRQ_Typedef AIC_IRQ_n) 

* 功能                        :        获取中断活动状态

* 参数                        :        AIC_IRQ_n：中断源

* 返回                        :        TRUE:中断已经激活;FALSE:中断未激活

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        不受中断屏蔽影响

*************************************************************************************************************************/

bool AIC_GetIrqActiveStatus(AIC_IRQ_Typedef AIC_IRQ_n)

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return FALSE;

        if(AIC->IASR[AIC_IRQ_n/32] & (1 << (AIC_IRQ_n%32))) 

        {

                return TRUE;

        }

        else

        {

                return FALSE;

        }

}

 

 

/*************************************************************************************************************************

* 函数                        :        bool AIC_GetIrqStatus(AIC_IRQ_Typedef AIC_IRQ_n) 

* 功能                        :        获取中断状态(中断使能并有效的状态)

* 参数                        :        AIC_IRQ_n：中断源

* 返回                        :        TRUE:中断有效;FALSE:中断无效

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        会受到中断屏蔽影响

*************************************************************************************************************************/

bool AIC_GetIrqStatus(AIC_IRQ_Typedef AIC_IRQ_n)

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return FALSE;

        if(AIC->ISR[AIC_IRQ_n/32] & (1 << (AIC_IRQ_n%32))) 

        {

                return TRUE;

        }

        else

        {

                return FALSE;

        }

}

 

 

/*************************************************************************************************************************

* 函数                        :        u8 AIC_GetThisIntIRQorFIQ(void)

* 功能                        :        获取当前的中断是IRQ还是FIQ

* 参数                        :        无

* 返回                        :        0：无中断；1：IRQ;2:FIQ

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        

*************************************************************************************************************************/

u8 AIC_GetThisIntIRQorFIQ(void)

{

        if(AIC->OISR & BIT1) return 1;

        else if(AIC->OISR & BIT0) return 2;

        else return 0;

}

 

 

/*************************************************************************************************************************

* 函数                        :        bool AIC_GetIrqEnableStatus(AIC_IRQ_Typedef AIC_IRQ_n)

* 功能                        :        获取中断使能状态

* 参数                        :        AIC_IRQ_n：中断源

* 返回                        :        TRUE:中断使能;FALSE:中断关闭

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        获取对应中断开关状态

*************************************************************************************************************************/

bool AIC_GetIrqEnableStatus(AIC_IRQ_Typedef AIC_IRQ_n) 

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return FALSE;

        if(AIC->IMR[AIC_IRQ_n/32] & (1 << (AIC_IRQ_n%32))) 

        {

                return TRUE;

        }

        else

        {

                return FALSE;

        }

}

 

 

/*************************************************************************************************************************

* 函数                        :        void AIC_IrqEnable(AIC_IRQ_Typedef AIC_IRQ_n, bool isEnable) 

* 功能                        :        设置一个中断使能状态

* 参数                        :        AIC_IRQ_n：中断源；isEnable：是否使能中断

* 返回                        :        无

* 依赖                        :        底层

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-30

* 最后修改时间         :         2020-08-30

* 说明                        :        

*************************************************************************************************************************/

void AIC_IrqEnable(AIC_IRQ_Typedef AIC_IRQ_n, bool isEnable)

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

        if(isEnable)        //使能对应中断

        {

                AIC->MECR[AIC_IRQ_n/32] = 1 << (AIC_IRQ_n%32);        //写1开启对应中断

        }

        else //关闭对应中断

        {

                AIC->MDCR[AIC_IRQ_n/32] = 1 << (AIC_IRQ_n%32);        //写1关闭对应中断

        }

}

 

 

/*************************************************************************************************************************

*函数                :        void AIC_SetIrqActive(AIC_IRQ_Typedef AIC_IRQ_n)

*功能                :        AIC中断设置为激活状态（软件触发某个中断）

*参数                :        AIC_IRQ_n：中断源

*返回                :        无

*依赖                        :         底层宏定义

*作者               :        cp1300@139.com

*时间                     :        2020-08-30

*最后修改时间        :        2020-08-30

*说明                :        相当于软件触发某个中断

*************************************************************************************************************************/

void AIC_SetIrqActive(AIC_IRQ_Typedef AIC_IRQ_n)

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

        AIC->SSCR[AIC_IRQ_n/32] = 1 << (AIC_IRQ_n%32);        //写1软件触发对应中断

}

 

 

/*************************************************************************************************************************

*函数                :        void AIC_ClearIrqActive(AIC_IRQ_Typedef AIC_IRQ_n)

*功能                :        AIC软件中断激活状态清除

*参数                :        V3S_IRQ_n：中断编号

*返回                :        无

*依赖                        :         底层宏定义

*作者               :        cp1300@139.com

*时间                     :        2020-08-30

*最后修改时间        :        2020-08-30

*说明                :        相当于清除1个已经触发软件中断的状态

*************************************************************************************************************************/

void AIC_ClearIrqActive(AIC_IRQ_Typedef AIC_IRQ_n)

{

        if(AIC_IRQ_n >= NUMBER_OF_INT_VECTORS) return;

        AIC->SCCR[AIC_IRQ_n/32] = 1 << (AIC_IRQ_n%32);        //写1清除软件触发对应中断

}

 

 

#if(UCOS_II_EN) //使能了操作系统

 

#else

/*************************************************************************************************************************

* 函数                        :        void SystemIrqHandler(void)

* 功能                        :        系统中断处理（无操作系统接口）

* 参数                        :        无

* 返回                        :        无

* 依赖                        :        需要在中断程序汇编中编写保护现场，并调用

* 作者                        :        cp1300@139.com

* 时间                        :        2020-08-21

* 最后修改时间         :         2020-08-21

* 说明                        :        用于非OS情况下调用，会直接在startup.s中调用

*************************************************************************************************************************/

void SystemIrqHandler(void) 

{

        u32 mISNR;        

        u32 intNum;

 

        mISNR = AIC->IPER;        //需要先读取IPER，否则ISNR可能没更新，IPER的值>>2位是等于ISNR的，必须先读取IPRE

        mISNR >>= 2;

        //mISNR = AIC->ISNR;        //这个寄存器只能读取一次，下次读取会被清零的,ISNR有时候没有及时更新

        intNum = mISNR & 0X3F;

        if ((intNum == 0) || (intNum>=NUMBER_OF_INT_VECTORS))   

        {

                AIC->EOSCR = 1;        //写入任何值，告诉AIC中断执行完毕了

                return;

        }

        //执行中断服务程序

        ((void (*)(void)) sg_IRQHandlerTable[intNum])();     //执行中断服务程序

        AIC->EOSCR = 1;                //写入任何值，告诉AIC中断执行完毕了

}

 

#endif //UCOS_II_EN

 

/*************************************************************************************************************

 * 文件名:                        irq_aic.h

 * 功能:                        NUC970 中断控制器

 * 作者:                        cp1300@139.com

 * 创建时间:                2020-08-30

 * 最后修改时间:        2020-08-30

 * 详细:                        中断控制器驱动

*************************************************************************************************************/

#ifndef _IRQ_AIC_H_  

#define _IRQ_AIC_H_

#include "nuc970_system.h"

 

 

 

//中断源

typedef enum

{

        AIC_NULL_INT        =        0,                        //无效的中断

        AIC_WDT_INT                =        1,                        //Watch Dog Timer Interrupt

        AIC_WWDT_INT        =        2,                        //Windowed-WDT Interrupt

        AIC_LVD_INT                =        3,                        //Low Voltage Detect Interrupt

        AIC_EXT0_INT        =        4,                        //外部中断0

        AIC_EXT1_INT        =        5,                        //外部中断1

        AIC_EXT2_INT        =        6,                        //外部中断2

        AIC_EXT3_INT        =        7,                        //外部中断3

        AIC_EXT4_INT        =        8,                        //外部中断4

        AIC_EXT5_INT        =        9,                        //外部中断5

        AIC_EXT6_INT        =        10,                        //外部中断6

        AIC_EXT7_INT        =        11,                        //外部中断7

        AIC_ACTL_INT        =        12,                        //Audio Controller Interrupt

        AIC_LCD_INT                =        13,                        //LCD Controller Interrupt

        AIC_CAP_INT                =        14,                        //Sensor Interface Controller Interrupt

        AIC_RTC_INT                =        15,                        //RTC Interrupt

        AIC_TMR0_INT        =        16,                        //Timer 0 Interrupt

        AIC_TMR1_INT        =        17,                        //Timer 1 Interrupt

        AIC_ADC_INT                =        18,                        //ADC Interrupt

        AIC_EMC0_RX_INT        =        19,                        //EMC 0 RX Interrupt

        AIC_EMC1_RX_INT        =        20,                        //EMC 1 RX Interrupt

        AIC_EMC0_TX_INT        =        21,                        //EMC 0 TX Interrupt

        AIC_EMC1_TX_INT        =        22,                        //EMC 1 TX Interrupt

        AIC_EHCI_INT        =        23,                        //USB 2.0 Host Controller Interrupt

        AIC_OHCI_INT        =        24,                        //USB 1.1 Host Controller Interrupt

        AIC_GDMA0_INT        =        25,                        //GDMA Channel 0 Interrupt

        AIC_GDMA1_INT        =        26,                        //GDMA Channel 1 Interrupt

        AIC_SDH_INT                =        27,                        //SD/SDIO Host Interrupt

        AIC_SIC_INT                =        28,                        //SIC Interrupt

        AIC_UDC_INT                =        29,                        //USB Device Controller Interrupt

        AIC_TMR2_INT        =        30,                        //Timer 2 Interrupt

        AIC_TMR3_INT        =        31,                        //Timer 3 Interrupt

        AIC_TMR4_INT        =        32,                        //Timer 4 Interrupt

        AIC_JPEG_INT        =        33,                        //JPEG Engine Interrupt

        AIC_GE2D_INT        =        34,                        //2D Graphic Engine Interrupt

        AIC_CRYPTO_INT        =        35,                        //CRYPTO Engine Interrupt

        AIC_UART0_INT        =        36,                        //UART 0 Interrupt

        AIC_UART1_INT        =        37,                        //UART 1 Interrupt

        AIC_UART2_INT        =        38,                        //UART 2 Interrupt

        AIC_UART4_INT        =        39,                        //UART 4 Interrupt

        AIC_UART6_INT        =        40,                        //UART 6 Interrupt

        AIC_UART8_INT        =        41,                        //UART 8 Interrupt

        AIC_UART10_INT        =        42,                        //UART 10 Interrupt

        AIC_UART3_INT        =        43,                        //UART 3 Interrupt

        AIC_UART5_INT        =        44,                        //UART 5 Interrupt

        AIC_UART7_INT        =        45,                        //UART 7 Interrupt

        AIC_UART9_INT        =        46,                        //UART 9 Interrupt

        AIC_ETMR0_INT        =        47,                        //Enhanced Timer 0 Interrupt

        AIC_ETMR1_INT        =        48,                        //Enhanced Timer 1 Interrupt

        AIC_ETMR2_INT        =        49,                        //Enhanced Timer 2 Interrupt

        AIC_ETMR3_INT        =        50,                        //Enhanced Timer 3 Interrupt

        AIC_USI0_INT        =        51,                        //USI 0 Interrupt

        AIC_USI1_INT        =        52,                        //USI 1 Interrupt

        AIC_I2C0_INT        =        53,                        //I2C 0 Interrupt

        AIC_I2C1_INT        =        54,                        //I2C 1 Interrupt

        AIC_SMC0_INT        =        55,                        //SmartCard 0 Interrupt

        AIC_SMC1_INT        =        56,                        //SmartCard 1 Interrupt

        AIC_GPIO_INT        =        57,                        //GPIO Interrupt

        AIC_CAN0_INT        =        58,                        //CAN 0 Interrupt

        AIC_CAN1_INT        =        59,                        //CAN 1 Interrupt

        AIC_PWM_INT                =        60,                        //PWM Interrupt

        AIC_KPI_INT                =        61,                        //KPI Interrupt

}AIC_IRQ_Typedef;

#define NUMBER_OF_INT_VECTORS   62       //中断数量

 

 

//中断类型

typedef enum

{

        AIC_LOW_LEVEL        =        0,        //低电平触发-注意：电平触发的中断会被自动清除，电平消失后就没了

        AIC_HIGHT_LEVEL        =        1,        //高电平触发-注意：电平触发的中断会被自动清除，电平消失后就没了

        AIC_LOW_EDGE        =        2,        //下降沿触发

        AIC_HIGHT_EDGE        =        3,        //上升沿触发

}AIC_IntType;

 

//相关API

void AIC_Init(void);                                                                                                                                //AIC中断控制器初始化（在系统初始化中调用，请勿重复调用）

void AIC_RegisterIRQHandler(AIC_IRQ_Typedef AIC_IRQ_n, void (*pIRQHandler)(void));        //注册中断服务程序

void AIC_IrqEnable(AIC_IRQ_Typedef AIC_IRQ_n, bool isEnable);                                                //设置一个中断使能状态

void AIC_SetIrqTriggered(AIC_IRQ_Typedef AIC_IRQ_n, AIC_IntType AIC_INT_Triggered);        //设置一个中断触发方式

void AIC_SetIrqPriority(AIC_IRQ_Typedef AIC_IRQ_n, u8 AIC_INT_Prio);                                //设置一个中断优先级

bool AIC_GetIrqRawStatus(AIC_IRQ_Typedef AIC_IRQ_n);                                                                //获取中断原始触发状态

bool AIC_GetIrqActiveStatus(AIC_IRQ_Typedef AIC_IRQ_n);                                                                //获取中断活动状态

bool AIC_GetIrqStatus(AIC_IRQ_Typedef AIC_IRQ_n);                                                                        //获取中断状态(中断使能并有效的状态)

u8 AIC_GetThisIntIRQorFIQ(void);                                                                                                        //获取当前的中断是IRQ还是FIQ

bool AIC_GetIrqEnableStatus(AIC_IRQ_Typedef AIC_IRQ_n);                                                                //获取中断使能状态

void AIC_SetIrqActive(AIC_IRQ_Typedef AIC_IRQ_n);                                                                        //AIC中断设置为激活状态（软件触发某个中断）

void AIC_ClearIrqActive(AIC_IRQ_Typedef AIC_IRQ_n);                                                                        //AIC软件中断激活状态清除

 

 

#endif //_IRQ_AIC_H_

 

 

static u8 buff[1024];

u32 cnt1=0,cnt2 = 0;

 

UARTx_Init(UART_CH0, 115200, TRUE);                        //串口初始化

UARTx_SetRxBuff(UART_CH0, (u8 *)buff, 1024-1);

        SYS_EnableIrq();        //使能系统总中断

        while(1)

        {

                cnt1 = UARTx_GetRxCnt(UART_CH0);

                SYS_DelayMS(10);

                GPIOB->DATAOUT &= ~BIT1;

                cnt2 = UARTx_GetRxCnt(UART_CH0);

                if(cnt2 > 0 && cnt1 == cnt2)

                {

            //uart_printf("接收数据长度:%d\r\n", cnt1);

                        UARTx_SendData(UART_CH0, (u8 *)buff, cnt2);

                        UARTx_ClearRxCnt(UART_CH0);

                }

                SYS_DelayMS(20);

                

                GPIOB->DATAOUT |= BIT1;

                

        }