
/*  程序版本  REV 0.1  */

/*  包含头文件  */
#include "MFS_UART.h"
#include "GPIO.h"
#include "Radar_R3.h"

#if MFS_UART_PRINTF_EN
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#endif  /*  MFS_UART_PRINTF_EN  */
#include "WDT.h"

unsigned int recv_flag;
unsigned char recv_dat;

/*---------------------------------------------------------------------*/
/*  私有函数声明  */
static void MFS_UART_RecvData_OnHandle(unsigned int channel, unsigned char dat);
static void MFS_UART_CPU_SleepIdle(void);
static void MFS_UART_RICwrite(un_ric_resinn_t val, uint_io16_t* const preg_addr);
static void MFS_UART_ConfigureGPIO(unsigned int channel);
static void MFS_UART_ConfigError(void);
static __irq __arm  void MFS_UART_InterruptService_CH0_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH1_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH2_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH3_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH4_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH5_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH6_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH7_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH8_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH9_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH10_RX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH11_RX_IRQ(void);
static void MFS_UART_CH0_OnRecv(unsigned char dat);
static void MFS_UART_CH1_OnRecv(unsigned char dat);
static void MFS_UART_CH2_OnRecv(unsigned char dat);
static void MFS_UART_CH3_OnRecv(unsigned char dat);
static void MFS_UART_CH4_OnRecv(unsigned char dat);
static void MFS_UART_CH5_OnRecv(unsigned char dat);
static void MFS_UART_CH6_OnRecv(unsigned char dat);
static void MFS_UART_CH7_OnRecv(unsigned char dat);
static void MFS_UART_CH8_OnRecv(unsigned char dat);
static void MFS_UART_CH9_OnRecv(unsigned char dat);
static void MFS_UART_CH10_OnRecv(unsigned char dat);
static void MFS_UART_CH11_OnRecv(unsigned char dat);
static __irq __arm  void MFS_UART_InterruptService_CH0_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH1_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH2_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH3_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH4_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH5_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH6_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH7_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH8_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH9_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH10_TX_IRQ(void);
static __irq __arm  void MFS_UART_InterruptService_CH11_TX_IRQ(void);

/*---------------------------------------------------------------------*/
/*  公共用户回调函数  */
/*  参数：channel是当前收到数据的通道号  */
/*  参数：dat是当前收到的数据内容  */
/*  当接收到一个字节的数据  */
static void MFS_UART_RecvData_OnHandle(unsigned int channel, unsigned char dat)
{
}

/*  释放CPU回调，用于降低功耗 或 操作系统调度  */
/*  一般内部可以写释放一个操作系统的调度节拍  */
static void MFS_UART_CPU_SleepIdle(void)
{
    WDT_Clear();   /*  阻塞发送时，防止看门狗复位  */
}

/*  当用户配置错误  */
static void MFS_UART_ConfigError(void)
{
    while(1)
    {
        ;      /*  死循环  */
    }
}

/*  通道0接收数据用户回调函数  */
static void MFS_UART_CH0_OnRecv(unsigned char dat)
{
}

/*  通道1接收数据用户回调函数  */
static void MFS_UART_CH1_OnRecv(unsigned char dat)
{
  Uart_Data_Get(dat);
}

/*  通道2接收数据用户回调函数  */
static void MFS_UART_CH2_OnRecv(unsigned char dat)
{
}

/*  通道3接收数据用户回调函数  */
static void MFS_UART_CH3_OnRecv(unsigned char dat)
{
}

/*  通道4接收数据用户回调函数  */
static void MFS_UART_CH4_OnRecv(unsigned char dat)
{
}

/*  通道5接收数据用户回调函数  */
static void MFS_UART_CH5_OnRecv(unsigned char dat)
{
}

/*  通道6接收数据用户回调函数  */
static void MFS_UART_CH6_OnRecv(unsigned char dat)
{
}

/*  通道7接收数据用户回调函数  */
static void MFS_UART_CH7_OnRecv(unsigned char dat)
{
}

/*  通道8接收数据用户回调函数  */
static void MFS_UART_CH8_OnRecv(unsigned char dat)
{
}

/*  通道9接收数据用户回调函数  */
static void MFS_UART_CH9_OnRecv(unsigned char dat)
{

}

/*  通道10接收数据用户回调函数  */
static void MFS_UART_CH10_OnRecv(unsigned char dat)
{
}

/*  通道11接收数据用户回调函数  */
static void MFS_UART_CH11_OnRecv(unsigned char dat)
{
}


/*---------------------------------------------------------------------*/
/*  封装好的部分  */

/*  定义发送的控制状态  */
typedef enum
{
    MFS_UART_SendCmd_NULL = 0,               /*  当前无发送命令  */
    MFS_UART_SendCmd_BUSY,                   /*  正在发送中  */
}E_MFS_UART_SendCmd;

/*  定义发送缓冲区控制数据结构  */
typedef struct
{
    unsigned int len;            /*  要发送的长度  */
    unsigned char* pdat;         /*  发送数据所在的首地址  */
    E_MFS_UART_SendCmd flag;       /*  发送的控制状态  */
}S_MFS_UART_SendCtrl;

/*  定义所有通道发送串口的对象  */
static S_MFS_UART_SendCtrl MFS_UART_SendCtrl[12];

/*  寄存器操作数组定义  参考资源[6]  */
volatile static stc_cpg_mfsn_uart_t* const pMFS_UART[12] =
{
    /*  此处地址定义参考 s6j3360_MFS_UART.h 文件72行  */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4800000U),          /*  MFS 通道0   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4800400U),          /*  MFS 通道1   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4800800U),          /*  MFS 通道2   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4800C00U),          /*  MFS 通道3   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4801000U),          /*  MFS 通道4   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4801400U),          /*  MFS 通道5   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4801800U),          /*  MFS 通道6   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4801C00U),          /*  MFS 通道7   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4880000U),          /*  MFS 通道8   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4880400U),          /*  MFS 通道9   */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4880800U),          /*  MFS 通道10  */
    (volatile stc_cpg_mfsn_uart_t*)(0xB4880C00U)           /*  MFS 通道11  */
};  

/*  向一个资源输入寄存器写入一个值  */
/*  参数：val是要写入的值  */
/*  参数：preg_addr是要写入的寄存器地址  */
/*  配置方法参考资源[1]第P2790页  */
static void MFS_UART_RICwrite(un_ric_resinn_t val, uint_io16_t* const preg_addr)
{
    /*  定义临时变量  */
    unsigned int tmp_val = 0u;                                     /*  解锁钥匙寄存器的临时变量  */
    unsigned int tmp_addr = (unsigned int)(preg_addr);   /*  获取地址  */
    
    /*  进入临界，防止中断打断写入钥匙  */
    /*  参考资源[1]第P2790页  */
    IRQ_DISABLE_LOCAL()
      
    /*  写入钥匙配置  */
    tmp_val = (0u << 30u) | (1u << 28u) | ( 0x07FFFu & tmp_addr);  RIC_KEYCDR = tmp_val;
    tmp_val = (1u << 30u) | (1u << 28u) | ( 0x07FFFu & tmp_addr);  RIC_KEYCDR = tmp_val;
    tmp_val = (2u << 30u) | (1u << 28u) | ( 0x07FFFu & tmp_addr);  RIC_KEYCDR = tmp_val;
    tmp_val = (3u << 30u) | (1u << 28u) | ( 0x07FFFu & tmp_addr);  RIC_KEYCDR = tmp_val;
    
    /*  写入配置数据  */
    preg_addr[0] = val.u16Register;
    
    /*  退出临界，完成钥匙写入  */
    IRQ_RESTORE()
}

/*  配置指定通道MFS的GPIO为串口模式  */
/*  注意：这里仅仅修改输入资源控制，输出资源请在GPIO_Config.xlsm文件中的运行模式中配置  */
/*  参数 channel 为通道号：0 到 11  */
static void MFS_UART_ConfigureGPIO(unsigned int channel)
{
    /*  定义变量  */
    un_ric_resinn_t tmp_cfg;                    /*  输入资源临时变量  */
    
    /*  初始化变量  */
    tmp_cfg.u16Register = 0x0000u;              /*  初始清零  */
    
    /*  根据通道选择配置  */
    /*  配置流程参考资源[7]第4页  */
    /*  输入分配参考资源[5]第113页  */
    switch(channel)
    {
        /*  通道0  */
        case 0:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH0_SIN == 84u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P1_14  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN0);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH0_SIN == 143u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P2_29  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN0);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道1  */
        case 1:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH1_SIN == 139u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P2_25  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN7);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH1_SIN == 7u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P0_05  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN7);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道2  */
        case 2:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH2_SIN == 21u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P0_15  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN14);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH2_SIN == 116u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P2_06  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN14);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道3  */
        case 3:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH3_SIN == 31u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P0_22  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN21);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH3_SIN == 123u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P2_11  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN21);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道4  */
        case 4:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH4_SIN == 130u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P2_18  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN28);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH4_SIN == 13u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P0_09  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN28);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道5  */
        case 5:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH5_SIN == 106u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P2_00  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN35);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道6  */
        case 6:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH6_SIN == 64u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P1_04  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN42);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道7  */
        case 7:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH7_SIN == 67u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P1_07  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN49);
            }
            /*  RXD  组1配置  */
            else if(MFS_UART_CH7_SIN == 4u)
            {
                tmp_cfg.stcField.u4PORTSEL = 1u;               /*  P0_02  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN49);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道8  */
        case 8:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH8_SIN == 52u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P0_27  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN56);
            }
            /*  RXD  组2配置  */
            else if(MFS_UART_CH8_SIN == 30u)
            {
                tmp_cfg.stcField.u4PORTSEL = 2u;               /*  P0_21  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN56);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道9  */
        case 9:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH9_SIN == 92u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P1_20  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN63);
            }
            /*  RXD  组2配置  */
            else if(MFS_UART_CH9_SIN == 21u)
            {
                tmp_cfg.stcField.u4PORTSEL = 2u;               /*  P0_15  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN63);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道10  */
        case 10:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组0配置  */
            if(MFS_UART_CH10_SIN == 95u)
            {
                tmp_cfg.stcField.u4PORTSEL = 0u;               /*  P1_23  */
                MFS_UART_RICwrite(tmp_cfg, &RIC_RESIN70);
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  通道11  */
        case 11:
        {
            /*  RXD  准备配置  */
            tmp_cfg.u16Register = 0x0000u;                     /*  初始清零  */
            
            /*  RXD  组1配置  */
            if(MFS_UART_CH11_SIN == 103u)
            {
                /*  无需配置，芯片硬件固定  */                 /*  P1_29  */
            }
            /*  错误的配置  */
            else
            {
                MFS_UART_ConfigError();                        /*  配置错误  */
            }
            
        }break;
        
        /*  错误的通道  */
        default:break;
    }
}


/*  初始化  */
/*  参数 channel 为通道号：0 到 11  */
/*  参数 baud 为波特率  */
void MFS_UART_Init(unsigned int channel, unsigned int baud)
{
    /*  检查通道,配置错误 */
    if(channel > 11u)
    {
        /*  忽略全部操作  */
    }
    /*  配置正确  */
    else
    {
        /*  定义临时变量  */
        unsigned int tmp_value = 0u;
        
        /*  初始化该通道的发送控制对象  */
        MFS_UART_SendCtrl[channel].len = 0u;
        MFS_UART_SendCtrl[channel].pdat = 0u;
        MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_NULL;
        
        /*  配置对应管脚  */
        MFS_UART_ConfigureGPIO(channel);
        
        /*  注册接收中断函数  参考资源[5]第P70页  */
        switch(channel)
        {
            case 0:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_46, (uint32_t)MFS_UART_InterruptService_CH0_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH0_RX);   break;
            case 1:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_48, (uint32_t)MFS_UART_InterruptService_CH1_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH1_RX);   break;
            case 2:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_50, (uint32_t)MFS_UART_InterruptService_CH2_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH2_RX);   break;
            case 3:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_52, (uint32_t)MFS_UART_InterruptService_CH3_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH3_RX);   break;
            case 4:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_54, (uint32_t)MFS_UART_InterruptService_CH4_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH4_RX);   break;
            case 5:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_56, (uint32_t)MFS_UART_InterruptService_CH5_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH5_RX);   break;
            case 6:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_58, (uint32_t)MFS_UART_InterruptService_CH6_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH6_RX);   break;
            case 7:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_60, (uint32_t)MFS_UART_InterruptService_CH7_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH7_RX);   break;
            case 8:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_62, (uint32_t)MFS_UART_InterruptService_CH8_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH8_RX);   break;
            case 9:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_64, (uint32_t)MFS_UART_InterruptService_CH9_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH9_RX);   break;
            case 10: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_66, (uint32_t)MFS_UART_InterruptService_CH10_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH10_RX); break; 
            case 11: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_68, (uint32_t)MFS_UART_InterruptService_CH11_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH11_RX); break;
            default:break;
        }
        
        /*  注册发送中断函数  */
        switch(channel)
        {
            case 0:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_47, (uint32_t)MFS_UART_InterruptService_CH0_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH0_TX);   break;
            case 1:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_49, (uint32_t)MFS_UART_InterruptService_CH1_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH1_TX);   break;
            case 2:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_51, (uint32_t)MFS_UART_InterruptService_CH2_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH2_TX);   break;
            case 3:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_53, (uint32_t)MFS_UART_InterruptService_CH3_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH3_TX);   break;
            case 4:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_55, (uint32_t)MFS_UART_InterruptService_CH4_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH4_TX);   break;
            case 5:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_57, (uint32_t)MFS_UART_InterruptService_CH5_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH5_TX);   break;
            case 6:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_59, (uint32_t)MFS_UART_InterruptService_CH6_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH6_TX);   break;
            case 7:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_61, (uint32_t)MFS_UART_InterruptService_CH7_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH7_TX);   break;
            case 8:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_63, (uint32_t)MFS_UART_InterruptService_CH8_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH8_TX);   break;
            case 9:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_65, (uint32_t)MFS_UART_InterruptService_CH9_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH9_TX);   break;
            case 10: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_67, (uint32_t)MFS_UART_InterruptService_CH10_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH10_TX); break;
            case 11: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_69, (uint32_t)MFS_UART_InterruptService_CH11_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH11_TX); break;
            default:break;
        }
        
        /*  根据流程对MFS进行UART模式的初始化，参考资源[2]的mfs_uart.c的491行  */
        /*  清除可编程位  */
        pMFS_UART[channel]->unSCR.stcField.u1UPCL = 1u;        /*  写入寄存器  */
        
        /*  配置串行模式寄存器  */        
        /*  设置MFS模式  */
        pMFS_UART[channel]->unSMR.stcField.u3MD = 0u;          /*  操作模式0，参考资源[1]的P1875页  */
        
        /*  设置发送的数据位的排列方向  */
        pMFS_UART[channel]->unSMR.stcField.u1BDS = 0u;        /*  低位先发送，参考资源[3]的图1  */
        
        /*  设置停止位长度  */
        pMFS_UART[channel]->unSMR.stcField.u1SBL = 0u;        /*  1个停止位，下面还有一处也是决定停止位的  */
        
        /*  开启串行数据输出使能  */
        pMFS_UART[channel]->unSMR.stcField.u1SOE = 1u;        /*  开启，参考资源[1]的P1876页  */
                
        /*  设置波特率  */
        tmp_value = (CLK_LCP0A_FREQ / baud) - 1u;             /*  算法参考资源[2]的mfs_uart.c的534行至550行  */
        pMFS_UART[channel]->unBGR.u16Register = (unsigned short)(tmp_value & 0x0FFFFu);    /*  写入寄存器  */
                
        /*  配置扩展通信控制寄存器  */
        /*  硬件流控设置  */
        pMFS_UART[channel]->unESCR.stcField.u1FLWEN = 0u;    /*  关闭硬件流控  */
        
        /*  设置数据格式  */
        pMFS_UART[channel]->unESCR.stcField.u1INV = 0u;      /*  NRZ编码格式  */
                                                             /*  参考资源[4]，RS232-TTL为NRZ编码格式  */
        
        /*  设置校验位  */
        pMFS_UART[channel]->unESCR.stcField.u1PEN = 0u;      /*  关闭校验位  */
        pMFS_UART[channel]->unESCR.stcField.u1P = 0u;        /*  参考资源[2]的mfs_uart.c的643行，取消校验功能时，校验模式配置为Even  */
        
        /*  设置停止位长度  */
        pMFS_UART[channel]->unESCR.stcField.u1ESBL = 0u;     /*  1个停止位，上面还有一处也是决定停止位的  */
        
        /*  设置数据位长度  */
        pMFS_UART[channel]->unESCR.stcField.u3L = 0u;        /*  8位数据长度，参考资源[3]的图1  */
                
        /*  配置串行状态寄存器  */
        pMFS_UART[channel]->unSSR.stcField.u1REC = 1u;       /*  清除接收错误标志位  */
        
        /*  配置串行控制寄存器  */
        /*  开启接收  */
        pMFS_UART[channel]->unSCR.stcField.u1RXE = 1u;
        
        /*  开启发送  */
        pMFS_UART[channel]->unSCR.stcField.u1TXE = 1u;
        
        /*  开启接收中断  */
        pMFS_UART[channel]->unSCR.stcField.u1RIE = 1u;
        
        /*  关闭发送中断  */
        pMFS_UART[channel]->unSCR.stcField.u1TIE = 0u;        /*  在REV 0.2版本中修改  */
    }  
    
}


/*  初始化,带有校验设置  */
/*  参数 channel 为通道号：0 到 11  */
/*  参数 baud 为波特率  */
/*  参数 parity_type 为校验类型  */
void MFS_UART_InitWithParity(unsigned int channel, unsigned int baud, EMFS_UART_ParityType parity_type)
{
    /*  检查通道,配置错误 */
    if(channel > 11u)
    {
        /*  忽略全部操作  */
    }
    /*  配置正确  */
    else
    {
        /*  定义临时变量  */
        unsigned int tmp_value = 0u;
        
        /*  初始化该通道的发送控制对象  */
        MFS_UART_SendCtrl[channel].len = 0u;
        MFS_UART_SendCtrl[channel].pdat = 0u;
        MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_NULL;
        
        /*  配置对应管脚  */
        MFS_UART_ConfigureGPIO(channel);
        
        /*  注册接收中断函数  参考资源[5]第P70页  */
        switch(channel)
        {
            case 0:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_46, (uint32_t)MFS_UART_InterruptService_CH0_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH0_RX);   break;
            case 1:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_48, (uint32_t)MFS_UART_InterruptService_CH1_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH1_RX);   break;
            case 2:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_50, (uint32_t)MFS_UART_InterruptService_CH2_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH2_RX);   break;
            case 3:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_52, (uint32_t)MFS_UART_InterruptService_CH3_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH3_RX);   break;
            case 4:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_54, (uint32_t)MFS_UART_InterruptService_CH4_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH4_RX);   break;
            case 5:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_56, (uint32_t)MFS_UART_InterruptService_CH5_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH5_RX);   break;
            case 6:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_58, (uint32_t)MFS_UART_InterruptService_CH6_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH6_RX);   break;
            case 7:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_60, (uint32_t)MFS_UART_InterruptService_CH7_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH7_RX);   break;
            case 8:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_62, (uint32_t)MFS_UART_InterruptService_CH8_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH8_RX);   break;
            case 9:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_64, (uint32_t)MFS_UART_InterruptService_CH9_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH9_RX);   break;
            case 10: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_66, (uint32_t)MFS_UART_InterruptService_CH10_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH10_RX); break; 
            case 11: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_68, (uint32_t)MFS_UART_InterruptService_CH11_RX_IRQ, MFS_UART_IRQ_PRIORITY__CH11_RX); break;
            default:break;
        }
        
        /*  注册发送中断函数  */
        switch(channel)
        {
            case 0:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_47, (uint32_t)MFS_UART_InterruptService_CH0_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH0_TX);   break;
            case 1:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_49, (uint32_t)MFS_UART_InterruptService_CH1_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH1_TX);   break;
            case 2:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_51, (uint32_t)MFS_UART_InterruptService_CH2_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH2_TX);   break;
            case 3:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_53, (uint32_t)MFS_UART_InterruptService_CH3_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH3_TX);   break;
            case 4:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_55, (uint32_t)MFS_UART_InterruptService_CH4_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH4_TX);   break;
            case 5:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_57, (uint32_t)MFS_UART_InterruptService_CH5_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH5_TX);   break;
            case 6:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_59, (uint32_t)MFS_UART_InterruptService_CH6_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH6_TX);   break;
            case 7:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_61, (uint32_t)MFS_UART_InterruptService_CH7_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH7_TX);   break;
            case 8:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_63, (uint32_t)MFS_UART_InterruptService_CH8_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH8_TX);   break;
            case 9:  Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_65, (uint32_t)MFS_UART_InterruptService_CH9_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH9_TX);   break;
            case 10: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_67, (uint32_t)MFS_UART_InterruptService_CH10_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH10_TX); break;
            case 11: Interrupt_IRQ_ISR_Register(INTERRUPTS_IRQ_NUMBER_69, (uint32_t)MFS_UART_InterruptService_CH11_TX_IRQ, MFS_UART_IRQ_PRIORITY__CH11_TX); break;
            default:break;
        }
        
        /*  根据流程对MFS进行UART模式的初始化，参考资源[2]的mfs_uart.c的491行  */
        /*  清除可编程位  */
        pMFS_UART[channel]->unSCR.stcField.u1UPCL = 1u;        /*  写入寄存器  */
        
        /*  配置串行模式寄存器  */        
        /*  设置MFS模式  */
        pMFS_UART[channel]->unSMR.stcField.u3MD = 0u;          /*  操作模式0，参考资源[1]的P1875页  */
        
        /*  设置发送的数据位的排列方向  */
        pMFS_UART[channel]->unSMR.stcField.u1BDS = 0u;        /*  低位先发送，参考资源[3]的图1  */
        
        /*  设置停止位长度  */
        pMFS_UART[channel]->unSMR.stcField.u1SBL = 0u;        /*  1个停止位，下面还有一处也是决定停止位的  */
        
        /*  开启串行数据输出使能  */
        pMFS_UART[channel]->unSMR.stcField.u1SOE = 1u;        /*  开启，参考资源[1]的P1876页  */
                
        /*  设置波特率  */
        tmp_value = (CLK_LCP0A_FREQ / baud) - 1u;             /*  算法参考资源[2]的mfs_uart.c的534行至550行  */
        pMFS_UART[channel]->unBGR.u16Register = (unsigned short)(tmp_value & 0x0FFFFu);    /*  写入寄存器  */
                
        /*  配置扩展通信控制寄存器  */
        /*  硬件流控设置  */
        pMFS_UART[channel]->unESCR.stcField.u1FLWEN = 0u;    /*  关闭硬件流控  */
        
        /*  设置数据格式  */
        pMFS_UART[channel]->unESCR.stcField.u1INV = 0u;      /*  NRZ编码格式  */
                                                             /*  参考资源[4]，RS232-TTL为NRZ编码格式  */
        
        /*  设置校验位  */
        /*  无校验  */
        if(parity_type == MFS_UART_NoneParity)
        {
            pMFS_UART[channel]->unESCR.stcField.u1PEN = 0u;      /*  关闭校验位  */
            pMFS_UART[channel]->unESCR.stcField.u1P = 0u;        /*  参考资源[2]的mfs_uart.c的643行，取消校验功能时，校验模式配置为Even  */
        }
        /*  偶校验  */
        else if(parity_type == MFS_UART_EvenParity)
        {
            pMFS_UART[channel]->unESCR.stcField.u1PEN = 1u;      /*  关闭校验位  */
            pMFS_UART[channel]->unESCR.stcField.u1P = 0u;        /*  参考资源[2]的mfs_uart.c的643行，取消校验功能时，校验模式配置为Even  */
        }
        /*  奇校验  */
        else if(parity_type == MFS_UART_OddParity)
        {
            pMFS_UART[channel]->unESCR.stcField.u1PEN = 1u;      /*  关闭校验位  */
            pMFS_UART[channel]->unESCR.stcField.u1P = 1u;        /*  参考资源[2]的mfs_uart.c的643行，取消校验功能时，校验模式配置为Even  */
        }
        /*  错误配置  */
        else
        {
            /*  当用户配置错误的时候，默认自动为无校验  */
            pMFS_UART[channel]->unESCR.stcField.u1PEN = 0u;      /*  关闭校验位  */
            pMFS_UART[channel]->unESCR.stcField.u1P = 0u;        /*  参考资源[2]的mfs_uart.c的643行，取消校验功能时，校验模式配置为Even  */
        }
        /*  设置停止位长度  */
        pMFS_UART[channel]->unESCR.stcField.u1ESBL = 0u;     /*  1个停止位，上面还有一处也是决定停止位的  */
        
        /*  设置数据位长度  */
        pMFS_UART[channel]->unESCR.stcField.u3L = 0u;        /*  8位数据长度，参考资源[3]的图1  */
                
        /*  配置串行状态寄存器  */
        pMFS_UART[channel]->unSSR.stcField.u1REC = 1u;       /*  清除接收错误标志位  */
        
        /*  配置串行控制寄存器  */
        /*  开启接收  */
        pMFS_UART[channel]->unSCR.stcField.u1RXE = 1u;
        
        /*  开启发送  */
        pMFS_UART[channel]->unSCR.stcField.u1TXE = 1u;
        
        /*  开启接收中断  */
        pMFS_UART[channel]->unSCR.stcField.u1RIE = 1u;
        
        /*  关闭发送中断  */
        pMFS_UART[channel]->unSCR.stcField.u1TIE = 0u;        /*  在REV 0.2版本中修改  */
    }  

}

/*  发送一个字节  */
/*  参数 channel 为通道号：0 到 11  */
/*  参数：type是发送类型，为MFS_UART_SendType_Blocking是阻塞，为MFS_UART_SendType_Interrupt是中断  */
/*  参数 in 为你要发送的字节数据  */
/*  返回值：MFS_UART_OptSt_OK=发送成功， MFS_UART_OptSt_BUSY=发送忙中*/
EMFS_UART_OptSt MFS_UART_SendOneByte(unsigned int channel, EMFS_UART_SendType type, unsigned char in)
{
    /*  定义返回值  */
    EMFS_UART_OptSt re_value = MFS_UART_OptSt_BUSY;    
    
    /*  获取当前忙状态  */
    re_value = MFS_UART_IsSendBusy(channel);
    
    /*  当忙  */
    if(re_value == MFS_UART_OptSt_BUSY)
    {
    }
    /*  当不忙  */
    else
    {      
        /*  关闭发送中断  */
        /*  因为当发送1个字节的时候用不到发送中断  */
        pMFS_UART[channel]->unSCR.stcField.u1TIE = 0u;    
        
        /*  检查发送类型，当为阻塞发送  */
        if(type == MFS_UART_SendType_Blocking)
        {
            /*  设置该通道的控制  */
            MFS_UART_SendCtrl[channel].len = 0u;
            MFS_UART_SendCtrl[channel].pdat = 0u;
            MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_NULL;      /*  不存在多个字节的发送  */
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[channel]->unRDR.u16Register = ((unsigned short)in) & 0x00FFu;  /*  只采用用户数据的低8位  */
            
            /*  阻塞当前通道，直到完成  */
            MFS_UART_WaitForSendReady(channel);
        }
        /*  当为中断发送  */
        else
        {
            /*  设置该通道的控制  */
            MFS_UART_SendCtrl[channel].len = 0u;
            MFS_UART_SendCtrl[channel].pdat = 0u;
            MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_NULL;      /*  不存在多个字节的发送  */
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[channel]->unRDR.u16Register = ((unsigned short)in) & 0x00FFu;  /*  只采用用户数据的低8位  */
        }
    }
    
    /*  返回结果  */
    return re_value;
}

/*  获取发送的忙状态，即发送是忙着呢吗？  */
/*  参数 channel 为通道号：0 到 11  */
/*  返回值：MFS_UART_OptSt_OK=发送空闲， MFS_UART_OptSt_BUSY=发送忙中*/
EMFS_UART_OptSt MFS_UART_IsSendBusy(unsigned int channel)
{
    /*  定义返回值  */
    EMFS_UART_OptSt re_value = MFS_UART_OptSt_BUSY;
    
    /*  检查通道,配置错误 */
    if(channel > 11u)
    {
        /*  返回忙  */
        re_value = MFS_UART_OptSt_BUSY;
    }
    /*  配置正确  */
    else
    {
        /*  发送控制流程参考资源[1]第P1831页的发送操作  */
        /*  检查当前发送寄存器是否忙，当忙  */
        if((pMFS_UART[channel]->unSSR.u8Register & (1u<<1u)) == 0u)
        {
            /*  返回忙  */
            re_value = MFS_UART_OptSt_BUSY;
        }
        /*  当不忙  */
        else
        {
            /*  检查当前是否存在中断式发送任务，当存在  */
            if(MFS_UART_SendCtrl[channel].flag == MFS_UART_SendCmd_BUSY)
            {
                /*  返回忙  */
                re_value = MFS_UART_OptSt_BUSY;
            }
            /*  当不存在  */
            else
            {
                /*  返回不忙  */
                re_value = MFS_UART_OptSt_OK;
            }
        }
    }  
    
    /*  返回结果  */
    return re_value;
}

/*  阻塞等待发送忙完，即发送准备好了  */
/*  参数 channel 为通道号：0 到 11  */
void MFS_UART_WaitForSendReady(unsigned int channel)
{    
    /*  阻塞等待  */
    while(MFS_UART_IsSendBusy(channel) == MFS_UART_OptSt_BUSY)
    {
        MFS_UART_CPU_SleepIdle();  /*  释放CPU  */
    }
}

/*  发送多个字节  */
/*  参数 channel 为通道号：0 到 11  */
/*  参数：type是发送类型，为MFS_UART_SendType_Blocking是阻塞，为MFS_UART_SendType_Interrupt是中断  */
/*  参数：pdat是用户待发送数据的指针，注意！！该指针在为中断发送时，必须是可以全局访问的！！并且注意该缓冲区的生命周期！！！  */
/*  参数：len是要发送的长度  */
/*  返回值：MFS_UART_OptSt_OK=发送成功， MFS_UART_OptSt_BUSY=发送忙中*/
EMFS_UART_OptSt MFS_UART_SendMultiByte(unsigned int channel, EMFS_UART_SendType type, unsigned char* pdat, unsigned int len)
{
    /*  定义返回值  */
    EMFS_UART_OptSt re_value = MFS_UART_OptSt_BUSY;
    
    /*  获取当前忙状态  */
    re_value = MFS_UART_IsSendBusy(channel);
    
    /*  当忙  */
    if(re_value == MFS_UART_OptSt_BUSY)
    {
    }
    /*  当不忙  */
    else
    {
        /*  检查发送类型，当为阻塞发送  */
        if(type == MFS_UART_SendType_Blocking)
        {
            /*  定义循环变量  */
            unsigned int i = 0u;
            
            /*  关闭发送中断  */
            /*  阻塞发送时不需要发送中断  */
            pMFS_UART[channel]->unSCR.stcField.u1TIE = 0u;    
            
            /*  遍历每个要发送的字节  */
            for(i=0u;i<len;i++)
            {
                /*  设置该通道的控制  */
                MFS_UART_SendCtrl[channel].len = 0u;
                MFS_UART_SendCtrl[channel].pdat = 0u;
                MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_NULL;      /*  不存在多个字节的发送  */
                
                /*  向发送数据寄存器写入数据  */
                /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
                /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
                pMFS_UART[channel]->unRDR.u16Register = ((unsigned short)pdat[i]) & 0x00FFu;  /*  只采用用户数据的低8位  */
                
                /*  阻塞当前通道，直到完成  */
                MFS_UART_WaitForSendReady(channel);
            }
        }
        /*  当为中断发送  */
        else
        {
            /*  设置该通道的控制  */
            MFS_UART_SendCtrl[channel].len = len;
            MFS_UART_SendCtrl[channel].pdat = pdat;
            MFS_UART_SendCtrl[channel].flag = MFS_UART_SendCmd_BUSY;      /*  开始连续发送  */
            
            /*  开启发送中断  */
            pMFS_UART[channel]->unSCR.stcField.u1TIE = 1u;    
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[channel]->unRDR.u16Register = ((unsigned short)pdat[0]) & 0x00FFu;  /*  只采用用户数据的低8位  */
        }
    }
    
    /*  返回结果  */
    return re_value;
}

#if MFS_UART_PRINTF_EN
/*  printf格式化打印输出  */
/*  参数 channel 为通道号：0 到 11  */
/*  参数：type是发送类型，为MFS_UART_SendType_Blocking是阻塞，为MFS_UART_SendType_Interrupt是中断  */
/*  后面参数兼容标准ANSI C的printf，但不建议使用浮点！！  */
void MFS_UART_printf(unsigned int channel, EMFS_UART_SendType type, char* str, ...)
{
    static char s[MFS_UART_PRINTF_BUF_SIZE];
    va_list arg_ptr;
    va_start(arg_ptr, str);

    memset(s,0x00,sizeof(s));

    vsprintf(s,str,arg_ptr);
    va_end(arg_ptr);

    MFS_UART_SendMultiByte(channel, type, (unsigned char*)s, strlen(s));
}
#endif  /*  MFS_UART_PRINTF_EN  */

/*  中断服务函数  通道0的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH0_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[0]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH0_OnRecv((unsigned char)(pMFS_UART[0]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(0u, (unsigned char)(pMFS_UART[0]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[0]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_46;
}

/*  中断服务函数  通道1的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH1_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[1]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH1_OnRecv((unsigned char)(pMFS_UART[1]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(1u, (unsigned char)(pMFS_UART[1]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[1]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_48;
}

/*  中断服务函数  通道2的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH2_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[2]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH2_OnRecv((unsigned char)(pMFS_UART[2]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(2u, (unsigned char)(pMFS_UART[2]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[2]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_50;
}

/*  中断服务函数  通道3的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH3_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[3]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH3_OnRecv((unsigned char)(pMFS_UART[3]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(3u, (unsigned char)(pMFS_UART[3]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[3]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_52;
}

/*  中断服务函数  通道4的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH4_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[4]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH4_OnRecv((unsigned char)(pMFS_UART[4]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(4u, (unsigned char)(pMFS_UART[4]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[4]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_54;
}

/*  中断服务函数  通道5的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH5_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[5]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH5_OnRecv((unsigned char)(pMFS_UART[5]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(5u, (unsigned char)(pMFS_UART[5]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[5]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_56;
}

/*  中断服务函数  通道6的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH6_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[6]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH6_OnRecv((unsigned char)(pMFS_UART[6]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(6u, (unsigned char)(pMFS_UART[6]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[6]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_58;
}

/*  中断服务函数  通道7的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH7_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[7]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH7_OnRecv((unsigned char)(pMFS_UART[7]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(7u, (unsigned char)(pMFS_UART[7]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[7]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_60;
}

/*  中断服务函数  通道8的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH8_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[8]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH8_OnRecv((unsigned char)(pMFS_UART[8]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(8u, (unsigned char)(pMFS_UART[8]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[8]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_62;
}

/*  中断服务函数  通道9的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH9_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[9]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH9_OnRecv((unsigned char)(pMFS_UART[9]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(9u, (unsigned char)(pMFS_UART[9]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[9]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_64;
}

/*  中断服务函数  通道10的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH10_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[10]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH10_OnRecv((unsigned char)(pMFS_UART[10]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(10u, (unsigned char)(pMFS_UART[10]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[10]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_66;
}

/*  中断服务函数  通道11的接收  */
static __irq __arm  void MFS_UART_InterruptService_CH11_RX_IRQ(void)
{
    /*  处理流程参考资源[7]第6页  */
    /*  获取当前状态寄存器  */
    un_cpg_mfsn_uart_ssr_t cur_status = pMFS_UART[11]->unSSR;
    
    /*  当帧错误  */
    if(cur_status.stcField.u1FRE != 0u)
    {
    }
    /*  超限错误  */
    else if(cur_status.stcField.u1ORE != 0u)
    {
    }
    /*  正常接收数据  */
    else
    {
        /*  调用用户回调函数处理数据  */
        MFS_UART_CH11_OnRecv((unsigned char)(pMFS_UART[11]->unRDR.u16Register & 0x0FFu));
        MFS_UART_RecvData_OnHandle(11u, (unsigned char)(pMFS_UART[11]->unRDR.u16Register & 0x0FFu));
        
    }
    
    /*  强制清除全部标志  */
    pMFS_UART[11]->unSSR.u8Register = 0x0FFu;
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_68;
}

/*  中断服务函数  通道0的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH0_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[0].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[0].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[0].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[0]->unRDR.u16Register = MFS_UART_SendCtrl[0].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[0].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[0].len == 0u)
            {
                MFS_UART_SendCtrl[0].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[0]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[0].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_47;
}

/*  中断服务函数  通道1的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH1_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[1].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[1].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[1].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[1]->unRDR.u16Register = MFS_UART_SendCtrl[1].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[1].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[1].len == 0u)
            {
                MFS_UART_SendCtrl[1].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[1]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[1].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_49;
}

/*  中断服务函数  通道2的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH2_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[2].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[2].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[2].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[2]->unRDR.u16Register = MFS_UART_SendCtrl[2].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[2].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[2].len == 0u)
            {
                MFS_UART_SendCtrl[2].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[2]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[2].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_51;
}

/*  中断服务函数  通道3的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH3_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[3].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[3].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[3].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[3]->unRDR.u16Register = MFS_UART_SendCtrl[3].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[3].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[3].len == 0u)
            {
                MFS_UART_SendCtrl[3].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[3]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[3].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_53;
}

/*  中断服务函数  通道4的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH4_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[4].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[4].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[4].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[4]->unRDR.u16Register = MFS_UART_SendCtrl[4].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[4].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[4].len == 0u)
            {
                MFS_UART_SendCtrl[4].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[4]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[4].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_55;
}

/*  中断服务函数  通道5的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH5_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[5].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[5].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[5].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[5]->unRDR.u16Register = MFS_UART_SendCtrl[5].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[5].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[5].len == 0u)
            {
                MFS_UART_SendCtrl[5].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[5]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[5].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_57;
}

/*  中断服务函数  通道6的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH6_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[6].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[6].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[6].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[6]->unRDR.u16Register = MFS_UART_SendCtrl[6].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[6].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[6].len == 0u)
            {
                MFS_UART_SendCtrl[6].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[6]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[6].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_59;
}

/*  中断服务函数  通道7的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH7_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[7].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[7].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[7].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[7]->unRDR.u16Register = MFS_UART_SendCtrl[7].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[7].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[7].len == 0u)
            {
                MFS_UART_SendCtrl[7].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[7]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[7].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_61;
}

/*  中断服务函数  通道8的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH8_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[8].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[8].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[8].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[8]->unRDR.u16Register = MFS_UART_SendCtrl[8].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[8].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[8].len == 0u)
            {
                MFS_UART_SendCtrl[8].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[8]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[8].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_63;
}

/*  中断服务函数  通道9的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH9_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[9].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[9].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[9].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[9]->unRDR.u16Register = MFS_UART_SendCtrl[9].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[9].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[9].len == 0u)
            {
                MFS_UART_SendCtrl[9].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[9]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[9].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_65;
}

/*  中断服务函数  通道10的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH10_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[10].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[10].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[10].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[10]->unRDR.u16Register = MFS_UART_SendCtrl[10].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[10].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[10].len == 0u)
            {
                MFS_UART_SendCtrl[10].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[10]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[10].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_67;
}

/*  中断服务函数  通道11的发送  */
static __irq __arm  void MFS_UART_InterruptService_CH11_TX_IRQ(void)
{
    /*  当在发送中  */
    if(MFS_UART_SendCtrl[11].flag == MFS_UART_SendCmd_BUSY)
    {
        /*  并且还有剩余数据没有发送完成  */
        if(MFS_UART_SendCtrl[11].len > 0u)
        {
            /*  统计已经发送的字节个数  */
            MFS_UART_SendCtrl[11].len--;
            
            /*  向发送数据寄存器写入数据  */
            /*  参考资源[1]第1805页寄存器映射表，TDR与RDR内存地址相同  */
            /*  参考资源[1]第1882页描述，对该地址读取时为RDR，对该地址写入时为TDR  */
            pMFS_UART[11]->unRDR.u16Register = MFS_UART_SendCtrl[11].pdat[0];
            
            /*  发送下一个  */
            MFS_UART_SendCtrl[11].pdat++;
            
            /*  当全部发送完成  */
            if(MFS_UART_SendCtrl[11].len == 0u)
            {
                MFS_UART_SendCtrl[11].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
                
               /*  关闭发送中断  */
               pMFS_UART[11]->unSCR.stcField.u1TIE = 0u;    
            }
        }
        /*  错误情况，设置发送完成  */
        else
        {
            MFS_UART_SendCtrl[11].flag = MFS_UART_SendCmd_NULL;    /*  设置操作完成  */
        }
    }
    
    /*  清除中断保持寄存器  */
    /*  参考资源[1]第1230页  */
    IRC0_IRQHC = INTERRUPTS_IRQ_NUMBER_69;
}

/*  文件结束 MFS_UART.c  */

