瑞萨单片机论坛
直播中

jf_1137202360

8年用户 1357经验值
擅长:嵌入式技术
私信 关注
[经验]

【RA4M2设计挑战赛】+串口驱动设计

前言
串口是最常用的通讯方式,简单方便,所以我们先实现该接口。我们需要实现一个比较好用的串口驱动,方便后面各种基于串口的模块使用。老规矩我们还是从手册开始一点一点进行驱动的实现。
过程串口模块介绍IO引脚
UART0
P410
P411
UART4
P205
P206
UART9
P109
P110
参考手册《27. Serial Communications Interface (SCI)》
瑞萨的SCI与其他家有点不一样,瑞萨家的SCI是一个大集合,包括了UART,SPI,IIC等串行通讯接口,按照不同配置可以实现不同的接口。我们这里只关注UART。
首先我们要从以下方向了解SCI模块
整体框图如下
时钟
SCI使用PLCKA
需要先使能外设时钟
MSTPCRB的bit31 27 22分别对应SCI0 SCI4 SCI9,默认为1不使能,需要修改为0使能。
寄存器
l RSR:移位寄存器,收到数据后自动放入RDR, RDRHL或者接收FIFO,CPU也可以直接访问(虽然一半不会这么做)。
l RDR:只读接收数据寄存器,RSR接收到一字节后复制到RDR,然后RSR可以继续接收。RDR必须有接收标志SCIn_RXI才能去读,如果没来得及读出RSR又有新的数据过来会溢出。
l RDRHL:类似于RDR只是是Non-Manchester模式9位串口模式使用,16位,低8位就是RDR的影子寄存器。7位9位模式不能访问。
l RDRHL_MAN:类似于RDRHL只是是Manchester模式使用,有一些其他同步信息。
l FRDRHL/FRDRH/FRDRL: FIFO模式下读数据和状态,读出的状态和SSR_FIFO一样,写SSR_FIFO
寄存器的对应bit为0清除状态(注意只需要清除的标志位写0其他位写1)。最好一起直接16位读FRDRHL,硬是要分开8位读，则先读FRDRH再读FRDRL。
l TDR:发送寄存器,发送移位寄存器TSR空时,自动TDR移动到TSR进行发送。可读可写，只有发送空SCIn_TXI(TDR已经移动到TSR)才能进行下一次写。
l TDRHL:类似于TDR, Non-Manchester模式使用。
l TDRHL_MAN:类似于TDRHL Manchester模式使用,有一些其他同步信息。
l FTDRHL/FTDRH/FTDRL:类似于TDR,不过是FIFO模式使用。
l TSR:发送移位寄存器。TDR数据自动移动到TSR再按位发出,CPU不能直接访问。
l SMR: Non-Smart Card模式的串行模式选择,即选择串口的额时钟源,是否多机模式,停止校验,数据长度,模式是SPI,IIC还是UART。
l SMR_SMCI:Smart Card接口使用我们这里不关心。
l SCR: Non-Smart Card模式串行接口控制,收发使能控制,收发多机处理中断使能控制,时钟输出控制
l  Non-Smart Card:Smart Card接口使用我们这里不关心。
l SSR状态寄存器: Non-Smart Card , Non-FIFO 模式使用。
l SSR_FIFO:状态寄存器FIFO模式,Non-Smart Card模式使用。
l SSR_SMCI:Smart Card接口使用我们这里不关心。
l SSR_MANC:Manchester模式使用我们这里不关心。
l SCMR:Smart Card模式使用我们这里不关心。
l BRR:波特率设置寄存器
l MDDR:波特率微调寄存器(调整小数部分)
l SEMR:调制参数配置,这里不使用不关心。
l SNFR:噪声过滤,串口模式只能设置为0
l SIMR1,SIMR2,SIMR3,SISR:IIC相关这里不关心
l SPMR:SPI相关这里不关心
l FCR:FIFO控制
l FDR:FIFO中收发数据个数。
l LSR:错误计数,溢出标志
l CDR,DCCR:多机通讯有地址匹配的才使用,这里不关心.
l SPTRL:端口配置电平翻转等。
l ACTR:时序调整配置
l MMR,TMPR,RMPR,MESR,MECR:Manchester模式使用这里不关心。
l ESMER：Extended Serial Module控制这里不使用不关心。
l CR0,CR1,CR2,CR3
l PCR:端口极性控制。
l ICR:中断控制
l STR:状态
l STCR:状态清除
l CF0DR,CF0CR,CF0RR,PCF1DR,SCF1DR,CF1CR,CF1RR,不使用不关心
l TCR,TMR,TPRE,TCNT不使用不关心。
信号采样
串口是以16倍bit速率采样的,也就是一个bit的时间有16个CLK,在第8个CLK进行采样,也就是中间位置读输入引脚状态。
波特率计算
配置流程
引脚配置->
使能时钟->
参数配置->
串口中断配置->
NVIC中断配置->
使能
串口驱动实现
有driver和hal层实现,driver层只需要调用hal层的接口即可。
整体思想如下:
对于接收,串口接收中断将数据写入缓冲区，串口接收接口查询缓冲区读出即可，无数据则等待或者返回错误
对于发送，发送接口将数据写入缓冲区，串口发送中断中查询缓冲区有则继续发送，直到发送完，所以第一次如果未处于发送中则需要手动触发一次中断，后续就都是在发送完中断中处理。
核心代码
hal_uart.c
  1. #include "R7FA4M2AD.h"
  2. #include "hal_uart.h"
  3. #include "clk.h"


  6. // read FRDRHL  SSR_FIFO FDR


  9. /**
  10. *****************************************************************************
  11. * fn          int HAL_UART_Init(HAL_UART_ID_e id)
  12. * brief       初始化UART模块,完成模块相关必要的初始化配置.
  13. * note        使用UART前必须调用,所有UART按默认配置(BSP实现).
  14. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  15. * retval      0 初始化成功.
  16. * retval      -1 初始化失败.
  17. *****************************************************************************
  18. */
  19. int HAL_UART_Init(HAL_UART_ID_e id)
  20. {
  21.     return 0;
  22. }

  24. /**
  25. *****************************************************************************
  26. * fn          int HAL_UART_CheckSend(HAL_UART_ID_e id,unsigned char byte)
  27. * brief       查询的方式发送一个字节.
  28. * note        阻塞发送,直到发送完才会返回.  
  29. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  30. * param[in]   byte 需要发送的字节.
  31. * retval      0 发送成功.
  32. * retval      其他值 发送失败(实际上没有发送完会阻塞所以不会返回其他值).
  33. *****************************************************************************
  34. */
  35. int HAL_UART_CheckSend(HAL_UART_ID_e id,unsigned char value)
  36. {
  37.         int res = 0;
  38.         switch(id)
  39.   {
  40.           case 0:
  41.                         if(R_SCI0->SSR_FIFO_b.TDFE == 1)
  42.       {
  43.                                 R_SCI0->FTDRL = value;
  44.                                 res = 0;
  45.                         }
  46.                         else
  47.       {
  48.                                 res = -1;
  49.                         }
  50.                 break;
  51.           case HAL_UART_4:
  52.                         if(R_SCI4->SSR_FIFO_b.TDFE == 1)
  53.       {
  54.                                 R_SCI4->FTDRL = value;
  55.                                 res = 0;
  56.                         }
  57.                         else
  58.       {
  59.                                 res = -1;
  60.                         }
  61.                 break;
  62.           case HAL_UART_9:
  63.                         if(R_SCI9->SSR_FIFO_b.TDFE == 1)
  64.       {
  65.                                 R_SCI9->FTDRL = value;
  66.                                 res = 0;
  67.                         }
  68.                         else
  69.       {
  70.                                 res = -1;
  71.                         }
  72.                 break;
  73.                 default:
  74.                                 res = -1;
  75.                         break;
  76.         }
  77.         return res;
  78. }

  80. /**
  81. *****************************************************************************
  82. * fn          int HAL_UART_CheckRead(HAL_UART_ID_e id,unsigned char* byte);
  83. * brief       查询的方式读一个字节.
  84. * note        阻塞读,直到有数据才会返回.  
  85. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  86. * param[in]   byte 存储读到的字节.
  87. * retval      0 读成功.
  88. * retval      其他值 读失败(实际上读不到数据会阻塞所以不会返回其他值).
  89. *****************************************************************************
  90. */
  91. int HAL_UART_CheckRead(HAL_UART_ID_e id,unsigned char* byte)
  92. {
  93.     return 0;
  94. }

  96. /**
  97. *****************************************************************************
  98. * fn          int HAL_UART_Send(HAL_UART_ID_e id,unsigned char byte)
  99. * brief       直接发送一个字节.
  100. * note        直接发送,直接往硬件发送缓冲写字节立即返回.  
  101. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  102. * param[in]   byte 需要发送的字节.
  103. * retval      0 发送成功.
  104. * retval      其他值 发送失败(实际上不会返回其他值).
  105. *****************************************************************************
  106. */
  107. int HAL_UART_Send(HAL_UART_ID_e id,unsigned char byte)
  108. {
  109.     return 0;
  110. }

  112. /**
  113. *****************************************************************************
  114. * fn          int HAL_UART_Read(HAL_UART_ID_e id,unsigned char* byte);
  115. * brief       直接读一个字节.
  116. * note        直接读,直接读硬件缓冲立即返回.  
  117. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  118. * param[in]   byte 存储读到的字节.
  119. * retval      0 读成功.
  120. * retval      其他值 读失败(实际上不会返回其他值).
  121. *****************************************************************************
  122. */
  123. int HAL_UART_Read(HAL_UART_ID_e id,unsigned char* byte)
  124. {
  125.     return 0;
  126. }

  128. /**
  129. *****************************************************************************
  130. * fn          int HAL_UART_SetTxISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  131. * brief       设置发送缓冲区空中断服务回调函数.
  132. * note        .  
  133. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  134. * param[in]   callbackfun 回调函数.
  135. * retval      0 设置成功.
  136. * retval      其他值 设置失败.
  137. *****************************************************************************
  138. */
  139. int HAL_UART_SetTxISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  140. {
  141.     return 0;
  142. }

  144. /**
  145. *****************************************************************************
  146. * fn          int HAL_UART_SetTxCmpISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  147. * brief       设置发送完中断服务回调函数.
  148. * note        .  
  149. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  150. * param[in]   callbackfun 回调函数.
  151. * retval      0 设置成功.
  152. * retval      其他值 设置失败.
  153. *****************************************************************************
  154. */
  155. int HAL_UART_SetTxCmpISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  156. {
  157.     return 0;;
  158. }

  160. /**
  161. *****************************************************************************
  162. * fn          int HAL_UART_SetRxCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  163. * brief       设置接收缓冲满中断服务回调函数.
  164. * note        .  
  165. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  166. * param[in]   callbackfun 回调函数.
  167. * retval      0 设置成功.
  168. * retval      其他值 设置失败.
  169. *****************************************************************************
  170. */
  171. int HAL_UART_SetRxCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  172. {
  173.     return 0;
  174. }

  176. /**
  177. *****************************************************************************
  178. * fn          int HAL_UART_SetRxErrCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  179. * brief       设置接收错误中断服务回调函数.
  180. * note        .  
  181. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  182. * param[in]   callbackfun 回调函数.
  183. * retval      0 设置成功.
  184. * retval      其他值 设置失败.
  185. *****************************************************************************
  186. */
  187. int HAL_UART_SetRxErrCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  188. {
  189.     return 0;
  190. }

  192. /**
  193. *****************************************************************************
  194. * fn          int HAL_UART_SetCfg(HAL_UART_ID_e id,HAL_UART_CFG_t* cfg)
  195. * brief       配置UART参数.
  196. * note        .  
  197. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  198. * param[in]   cfg 指向配置参数结构体 ref HAL_UART_CFG_t.
  199. * retval      0 设置成功.
  200. * retval      其他值 设置失败.
  201. *****************************************************************************
  202. */
  203. int HAL_UART_SetCfg(HAL_UART_ID_e id,HAL_UART_CFG_t* cfg)
  204. {
  205.         int res = 0;
  206.         switch(id)
  207.   {
  208.           case HAL_UART_0:
  209.                           /* Enable CLK */
  210.                                 R_MSTP->MSTPCRB_b.MSTPB31 = 0;  /* SCI0 */
  211.                
  212.                     /* disable */
  213.                                 R_SCI0->SCR_b.RE = 0;
  214.                                 R_SCI0->SCR_b.TE = 0;
  215.                
  216.                    /*P410 RXD0 PSEL:4
  217.                     *P411 TXD0 PSEL:4
  218.                     */
  219.                                 R_PMISC->PWPR_b.B0WI = 0;
  220.                                 R_PMISC->PWPR_b.PFSWE = 1;
  221.                
  222.                           R_PFS->PORT[4].PIN[10].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  223.                           //R_PFS->PORT[4].PIN[10].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  224.                                 R_PFS->PORT[4].PIN[10].PmnPFS_b.PDR = 0;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  225.                                 R_PFS->PORT[4].PIN[10].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  226.                     //R_PFS->PORT[4].PIN[10].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  227.                                 R_PFS->PORT[4].PIN[10].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  228.                           R_PFS->PORT[4].PIN[10].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  229.                     R_PFS->PORT[4].PIN[10].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  230.                     R_PFS->PORT[4].PIN[10].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  231.                                 R_PFS->PORT[4].PIN[10].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  232.               R_PFS->PORT[4].PIN[10].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  233.                                 R_PFS->PORT[4].PIN[10].PmnPFS_b.PSEL = 4;  /* Peripheral Select */
  234.                                
  235.                           R_PFS->PORT[4].PIN[11].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  236.                           //R_PFS->PORT[4].PIN[11].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  237.                                 R_PFS->PORT[4].PIN[11].PmnPFS_b.PDR = 1;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  238.                                 R_PFS->PORT[4].PIN[11].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  239.                     //R_PFS->PORT[4].PIN[11].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  240.                                 R_PFS->PORT[4].PIN[11].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  241.                           R_PFS->PORT[4].PIN[11].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  242.                     R_PFS->PORT[4].PIN[11].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  243.                     R_PFS->PORT[4].PIN[11].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  244.                                 R_PFS->PORT[4].PIN[11].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  245.               R_PFS->PORT[4].PIN[11].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  246.                                 R_PFS->PORT[4].PIN[11].PmnPFS_b.PSEL = 4;  /* Peripheral Select */
  247.                                
  248.                                 R_PMISC->PWPR_b.PFSWE = 0;
  249.                                 R_PMISC->PWPR_b.B0WI = 1;
  250.                                
  251.                                 /*
  252.                                  *  set param
  253.                                  */
  254.                                  R_SCI0->SMR_b.CKS = 0; /* 00: PCLK clock (n = 0) 01: PCLK/4 clock 10: PCLK/16 clock 11: PCLK/64 clock  */
  255.                                  R_SCI0->SMR_b.MP = 0;  /*0: Disable multi-processor communications function 1: Enable multi-processor communications function */
  256.                                  R_SCI0->SMR_b.STOP = 0;  /*0: 1 stop bit 1: 2 stop bits */
  257.                                  R_SCI0->SMR_b.PM = 0;   /* 0: Even parity 1: Odd parity */
  258.                                  R_SCI0->SMR_b.PE = 0;   /* 0: Parity Disable 1: Parity Enable */
  259.                                  R_SCI0->SMR_b.CHR = 0;   /* SCMR.CHR1=0: 0-9bits 1-9bits  SCMR.CHR1=1: 0-8bits 1-7bits */
  260.                                  R_SCI0->SMR_b.CM = 0;    /* 0: Asynchronous mode or simple IIC mode 1: Clock synchronous mode or simple SPI mode*/
  261.                                  
  262.                                  R_SCI0->SCR_b.CKE = 0;   /*1 Clock Enable 0 Clock Disable*/
  263.                                  R_SCI0->SCR_b.TEIE = 0;  /* 0: Disable SCIn_TEI interrupt requests 1: Enable SCIn_TEI interrupt requests */
  264.                                  R_SCI0->SCR_b.MPIE = 0;
  265.                                  R_SCI0->SCR_b.RIE = 1;
  266.                                  R_SCI0->SCR_b.TIE = 0;
  267.                                  
  268.                                  R_SCI0->FCR_b.FM = 1;     /* 0: Non-FIFO mode. 1: FIFO mode. */
  269.                                  R_SCI0->FCR_b.RFRST = 1;  /* 0: Do not reset FRDRHL 1: Reset FRDRHL */
  270.                                  R_SCI0->FCR_b.RFRST = 0;
  271.                                  R_SCI0->FCR_b.TFRST = 1;  /* 0: Do not reset FTDRHL 1: Reset FTDRHL */
  272.                                  R_SCI0->FCR_b.TFRST = 0;
  273.                                  R_SCI0->FCR_b.DRES = 0;   /*Receive Data Ready Error Select Selects the interrupt requested when detecting receive data ready. 0: Receive data full interrupt (SCIn_RXI) 1: Receive error interrupt (SCIn_ERI) */
  274.                                  R_SCI0->FCR_b.TTRG = 1;   /* Transmit FIFO Data Trigger Number */
  275.          R_SCI0->FCR_b.RTRG = 1;   /* Receive FIFO Data Trigger Number */
  276.                                  R_SCI0->FCR_b.RSTRG = 0;  /* RTS Output Active Trigger Number Select */
  277.                                  
  278.                                  R_SCI0->SEMR_b.BRME =         1;
  279.                                  R_SCI0->SEMR_b.ABCS =         0;
  280.                                  R_SCI0->SEMR_b.BGDM =         0;
  281.                                  R_SCI0->SEMR_b.ABCSE =         0;
  282.                                 /*
  283.                                  * set baud
  284.                                  * PCLK/(64*2^(2*n-1))*(256/M)*B - 1 n=0  CKS[1:0]=0
  285.                                  */
  286.                                  R_SCI0->BRR = clk_get_pclka()/(32*cfg->baud) - 1;
  287.                                  R_SCI0->MDDR = 256;
  288.                                  /*
  289.                                   * enable
  290.                                   */
  291.                                  R_SCI0->SCR_b.RE = 1;
  292.                                  R_SCI0->SCR_b.TE = 1;
  293.                         break;
  294.                 case HAL_UART_4:
  295.                           /* Enable CLK */
  296.                                 R_MSTP->MSTPCRB_b.MSTPB27 = 0;  /* SCI4 */
  297.                
  298.                    /*P205 TXD4 PSEL:4
  299.                     *P206 RXD4 PSEL:4
  300.                     */
  301.                                 R_PMISC->PWPR_b.B0WI = 0;
  302.                                 R_PMISC->PWPR_b.PFSWE = 1;
  303.                
  304.                           R_PFS->PORT[2].PIN[6].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  305.                           //R_PFS->PORT[2].PIN[6].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  306.                                 R_PFS->PORT[2].PIN[6].PmnPFS_b.PDR = 0;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  307.                                 R_PFS->PORT[2].PIN[6].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  308.                     //R_PFS->PORT[2].PIN[6].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  309.                                 R_PFS->PORT[2].PIN[6].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  310.                           R_PFS->PORT[2].PIN[6].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  311.                     R_PFS->PORT[2].PIN[6].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  312.                     R_PFS->PORT[2].PIN[6].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  313.                                 R_PFS->PORT[2].PIN[6].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  314.               R_PFS->PORT[2].PIN[6].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  315.                                 R_PFS->PORT[2].PIN[6].PmnPFS_b.PSEL = 4;  /* Peripheral Select */
  316.                                
  317.                           R_PFS->PORT[2].PIN[5].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  318.                           //R_PFS->PORT[2].PIN[5].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  319.                                 R_PFS->PORT[2].PIN[5].PmnPFS_b.PDR = 1;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  320.                                 R_PFS->PORT[2].PIN[5].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  321.                     //R_PFS->PORT[2].PIN[5].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  322.                                 R_PFS->PORT[2].PIN[5].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  323.                           R_PFS->PORT[2].PIN[5].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  324.                     R_PFS->PORT[2].PIN[5].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  325.                     R_PFS->PORT[2].PIN[5].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  326.                                 R_PFS->PORT[2].PIN[5].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  327.               R_PFS->PORT[2].PIN[5].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  328.                                 R_PFS->PORT[2].PIN[5].PmnPFS_b.PSEL = 4;  /* Peripheral Select */
  329.                                
  330.                                 R_PMISC->PWPR_b.PFSWE = 0;
  331.                                 R_PMISC->PWPR_b.B0WI = 1;       
  332.                                
  333.                                 /*
  334.                                  *  set param
  335.                                  */
  336.                                  R_SCI4->SMR_b.CKS = 0; /* 00: PCLK clock (n = 0) 01: PCLK/4 clock 10: PCLK/16 clock 11: PCLK/64 clock  */
  337.                                  R_SCI4->SMR_b.MP = 0;  /*0: Disable multi-processor communications function 1: Enable multi-processor communications function */
  338.                                  R_SCI4->SMR_b.STOP = 0;  /*0: 1 stop bit 1: 2 stop bits */
  339.                                  R_SCI4->SMR_b.PM = 0;   /* 0: Even parity 1: Odd parity */
  340.                                  R_SCI4->SMR_b.PE = 0;   /* 0: Parity Disable 1: Parity Enable */
  341.                                  R_SCI4->SMR_b.CHR = 0;   /* SCMR.CHR1=0: 0-9bits 1-9bits  SCMR.CHR1=1: 0-8bits 1-7bits */
  342.                                  R_SCI4->SMR_b.CM = 0;    /* 0: Asynchronous mode or simple IIC mode 1: Clock synchronous mode or simple SPI mode*/
  343.                                  
  344.                                  R_SCI4->SCR_b.CKE = 0;   /*1 Clock Enable 0 Clock Disable*/
  345.                                  R_SCI4->SCR_b.TEIE = 0;  /* 0: Disable SCIn_TEI interrupt requests 1: Enable SCIn_TEI interrupt requests */
  346.                                  R_SCI4->SCR_b.MPIE = 0;
  347.                                  R_SCI4->SCR_b.RIE = 1;
  348.                                  R_SCI4->SCR_b.TIE = 0;
  349.                                  
  350.                                  R_SCI4->FCR_b.FM = 1;     /* 0: Non-FIFO mode. 1: FIFO mode. */
  351.                                  R_SCI4->FCR_b.RFRST = 1;  /* 0: Do not reset FRDRHL 1: Reset FRDRHL */
  352.                                  R_SCI4->FCR_b.RFRST = 0;
  353.                                  R_SCI4->FCR_b.TFRST = 1;  /* 0: Do not reset FTDRHL 1: Reset FTDRHL */
  354.                                  R_SCI4->FCR_b.TFRST = 0;
  355.                                  R_SCI4->FCR_b.DRES = 0;   /*Receive Data Ready Error Select Selects the interrupt requested when detecting receive data ready. 0: Receive data full interrupt (SCIn_RXI) 1: Receive error interrupt (SCIn_ERI) */
  356.                                  R_SCI4->FCR_b.TTRG = 1;   /* Transmit FIFO Data Trigger Number */
  357.          R_SCI4->FCR_b.RTRG = 1;   /* Receive FIFO Data Trigger Number */
  358.                                  R_SCI4->FCR_b.RSTRG = 0;  /* RTS Output Active Trigger Number Select */
  359.                                  
  360.                                  R_SCI4->SEMR_b.BRME =         1;
  361.                                  R_SCI4->SEMR_b.ABCS =         0;
  362.                                  R_SCI4->SEMR_b.BGDM =         0;
  363.                                  R_SCI4->SEMR_b.ABCSE =         0;
  364.                                 /*
  365.                                  * set baud
  366.                                  * PCLK/(64*2^(2*n-1))*(256/M)*B - 1 n=0  CKS[1:0]=0
  367.                                  */
  368.                                  R_SCI4->BRR = clk_get_pclka()/(32*cfg->baud) - 1;
  369.                                  R_SCI4->MDDR = 256;
  370.                                  /*
  371.                                   * enable
  372.                                   */
  373.                                  R_SCI4->SCR_b.RE = 1;
  374.                                  R_SCI4->SCR_b.TE = 1;
  375.                         break;
  376.                 case HAL_UART_9:
  377.                           /* Enable CLK */
  378.                                 R_MSTP->MSTPCRB_b.MSTPB22 = 0;  /* SCI9 */
  379.                
  380.                    /*P109 TXD9 PSEL:5
  381.                     *P110 RXD9 PSEL:5
  382.                     */
  383.                                 R_PMISC->PWPR_b.B0WI = 0;
  384.                                 R_PMISC->PWPR_b.PFSWE = 1;
  385.                
  386.                           R_PFS->PORT[1].PIN[10].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  387.                           //R_PFS->PORT[1].PIN[10].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  388.                                 R_PFS->PORT[1].PIN[10].PmnPFS_b.PDR = 0;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  389.                                 R_PFS->PORT[1].PIN[10].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  390.                     //R_PFS->PORT[1].PIN[10].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  391.                                 R_PFS->PORT[1].PIN[10].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  392.                           R_PFS->PORT[1].PIN[10].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  393.                     R_PFS->PORT[1].PIN[10].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  394.                     R_PFS->PORT[1].PIN[10].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  395.                                 R_PFS->PORT[1].PIN[10].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  396.               R_PFS->PORT[1].PIN[10].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  397.                                 R_PFS->PORT[1].PIN[10].PmnPFS_b.PSEL = 5;  /* Peripheral Select */
  398.                                
  399.                           R_PFS->PORT[1].PIN[9].PmnPFS_b.PODR = 1;  /*0: Low output 1: High output */
  400.                           //R_PFS->PORT[1].PIN[9].PmnPFS_b.PIDR     /*0: Low level  1: High level  */
  401.                                 R_PFS->PORT[1].PIN[9].PmnPFS_b.PDR = 1;   /*0: Input (functions as an input pin) 1: Output (functions as an output pin) */
  402.                                 R_PFS->PORT[1].PIN[9].PmnPFS_b.PCR = 1;   /*0: Disable input pull-up 1: Enable input pull-up */
  403.                     //R_PFS->PORT[1].PIN[9].PmnPFS_b.PIM      /* This bit is read as 0. The write value should be 0. */
  404.                                 R_PFS->PORT[1].PIN[9].PmnPFS_b.NCODR = 0; /* 0: CMOS output  1: NMOS open-drain output */
  405.                           R_PFS->PORT[1].PIN[9].PmnPFS_b.DSCR = 3;  /* 00: Low drive  01: Middle drive 10: Setting prohibited 11: High drive */
  406.                     R_PFS->PORT[1].PIN[9].PmnPFS_b.EOFR = 0;  /* 00: Don't care 01: Detect rising edge 01: Detect rising edge 11: Detect both edges*/
  407.                     R_PFS->PORT[1].PIN[9].PmnPFS_b.ISEL = 0;  /* 0: Not used as an IRQn input pin 1: Used as an IRQn input pin */
  408.                                 R_PFS->PORT[1].PIN[9].PmnPFS_b.ASEL = 0;  /* 0: Not used as an analog pin 1: Used as an analog pin */
  409.               R_PFS->PORT[1].PIN[9].PmnPFS_b.PMR = 1;   /* 0: Used as a general I/O pin 1: Used as an I/O port for peripheral functions */
  410.                                 R_PFS->PORT[1].PIN[9].PmnPFS_b.PSEL = 5;  /* Peripheral Select */
  411.                                
  412.                                 R_PMISC->PWPR_b.PFSWE = 0;
  413.                                 R_PMISC->PWPR_b.B0WI = 1;       
  414.                                
  415.                                 /*
  416.                                  *  set param
  417.                                  */
  418.                                  R_SCI9->SMR_b.CKS = 0; /* 00: PCLK clock (n = 0) 01: PCLK/4 clock 10: PCLK/16 clock 11: PCLK/64 clock  */
  419.                                  R_SCI9->SMR_b.MP = 0;  /*0: Disable multi-processor communications function 1: Enable multi-processor communications function */
  420.                                  R_SCI9->SMR_b.STOP = 0;  /*0: 1 stop bit 1: 2 stop bits */
  421.                                  R_SCI9->SMR_b.PM = 0;   /* 0: Even parity 1: Odd parity */
  422.                                  R_SCI9->SMR_b.PE = 0;   /* 0: Parity Disable 1: Parity Enable */
  423.                                  R_SCI9->SMR_b.CHR = 0;   /* SCMR.CHR1=0: 0-9bits 1-9bits  SCMR.CHR1=1: 0-8bits 1-7bits */
  424.                                  R_SCI9->SMR_b.CM = 0;    /* 0: Asynchronous mode or simple IIC mode 1: Clock synchronous mode or simple SPI mode*/
  425.                                  
  426.                                  R_SCI9->SCR_b.CKE = 0;   /*1 Clock Enable 0 Clock Disable*/
  427.                                  R_SCI9->SCR_b.TEIE = 0;  /* 0: Disable SCIn_TEI interrupt requests 1: Enable SCIn_TEI interrupt requests */
  428.                                  R_SCI9->SCR_b.MPIE = 0;
  429.                                  R_SCI9->SCR_b.RIE = 1;
  430.                                  R_SCI9->SCR_b.TIE = 0;
  431.                                  
  432.                                  R_SCI9->FCR_b.FM = 1;     /* 0: Non-FIFO mode. 1: FIFO mode. */
  433.                                  R_SCI9->FCR_b.RFRST = 1;  /* 0: Do not reset FRDRHL 1: Reset FRDRHL */
  434.                                  R_SCI9->FCR_b.RFRST = 0;
  435.                                  R_SCI9->FCR_b.TFRST = 1;  /* 0: Do not reset FTDRHL 1: Reset FTDRHL */
  436.                                  R_SCI9->FCR_b.TFRST = 0;
  437.                                  R_SCI9->FCR_b.DRES = 0;   /*Receive Data Ready Error Select Selects the interrupt requested when detecting receive data ready. 0: Receive data full interrupt (SCIn_RXI) 1: Receive error interrupt (SCIn_ERI) */
  438.                                  R_SCI9->FCR_b.TTRG = 1;   /* Transmit FIFO Data Trigger Number */
  439.          R_SCI9->FCR_b.RTRG = 1;   /* Receive FIFO Data Trigger Number */
  440.                                  R_SCI9->FCR_b.RSTRG = 0;  /* RTS Output Active Trigger Number Select */
  441.                                  
  442.                                  R_SCI9->SEMR_b.BRME =         1;
  443.                                  R_SCI9->SEMR_b.ABCS =         0;
  444.                                  R_SCI9->SEMR_b.BGDM =         0;
  445.                                  R_SCI9->SEMR_b.ABCSE =         0;
  446.                                 /*
  447.                                  * set baud
  448.                                  * PCLK/(64*2^(2*n-1))*(256/M)*B - 1 n=0  CKS[1:0]=0
  449.                                  */
  450.                                  R_SCI9->BRR = clk_get_pclka()/(32*cfg->baud) - 1;
  451.                                  R_SCI9->MDDR = 256;
  452.                                  /*
  453.                                   * enable
  454.                                   */
  455.                                  R_SCI9->SCR_b.RE = 1;
  456.                                  R_SCI9->SCR_b.TE = 1;
  457.                         break;
  458.                 default:
  459.                                 res = -1;
  460.                         break;
  461.         }
  462.         return res;
  463. }

  465. /**
  466. *****************************************************************************
  467. * fn          int HAL_UART_EnableTx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  468. * brief       发送使能.
  469. * note        .  
  470. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  471. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  472. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  473. * retval      0 设置成功.
  474. * retval      其他值 设置失败.
  475. *****************************************************************************
  476. */
  477. int HAL_UART_EnableTx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  478. {
  479.     return 0;
  480. }

  482. /**
  483. *****************************************************************************
  484. * fn          int HAL_UART_EnableRx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  485. * brief       接收使能.
  486. * note        .  
  487. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  488. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  489. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  490. * retval      0 设置成功.
  491. * retval      其他值 设置失败.
  492. *****************************************************************************
  493. */
  494. int HAL_UART_EnableRx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  495. {
  496.     return 0;
  497. }

  499. /**
  500. *****************************************************************************
  501. * fn          int HAL_UART_EnableRxErr(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  502. * brief       接收错误中断使能.
  503. * note        .  
  504. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  505. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  506. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  507. * retval      0 设置成功.
  508. * retval      其他值 设置失败.
  509. *****************************************************************************
  510. */
  511. int HAL_UART_EnableRxErr(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  512. {
  513.     return 0;
  514. }

  516. /**
  517. *****************************************************************************
  518. * fn          int HAL_UART_DeInit(HAL_UART_ID_e id)
  519. * brief       解除UART模块,关闭模块.
  520. * note        .
  521. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  522. * retval      0 成功.
  523. * retval      -1 失败.
  524. *****************************************************************************
  525. */
  526. int HAL_UART_DeInit(HAL_UART_ID_e id)
  527. {
  528.     return 0;
  529. }
hal_uart.h
  1. #ifndef __HAL_UART_H
  2. #define __HAL_UART_H

  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif

  8.      
  9. /** addtogroup HAL
  10. *  {
  11. */   
  12.      
  13. /** addtogroup HAL_UART 硬件抽象层(HAL)串口模块(UART)
  14. *  {
  15. */
  16. /*****************************************************************************   
  17. *                                                                           *
  18. *                             数据结构描述                                  *
  19. *                                                                          *
  20. ****************************************************************************/
  21.    

  23. /** defgroup HAL_UART_data 硬件抽象层(HAL)串口模块(UART)数据结构
  24.   * {
  25.   */
  26.      
  27.                
  28. /**
  29. * enum hal_uart_txstate
  30. * UART 发送状态.
  31. */
  32. enum hal_uart_txstate
  33. {
  34.     HAL_UART_TXIDLE=0,      /**< UART 发送空闲 */
  35.     HAL_UART_TXBUSY=1,      /**< UART 正在发送 */
  36. };

  38. typedef enum  hal_uart_txstate HAL_UART_TXSTATE_e; /**< UART 发送状态枚举定义  */

  40.    
  41. /**
  42. * enum hal_uart_enable
  43. * UART 使能枚举定义.
  44. */
  45. enum hal_uart_enable
  46. {
  47.     HAL_UART_DISABLE=0,     /**< UART 不使能 */
  48.     HAL_UART_ENABLE=1,      /**< UART 使能 */
  49. };

  51. typedef enum  hal_uart_enable HAL_UART_ENABLE_e; /**< UART 使能枚举定义  */
  52.   

  54.                
  55. /**
  56. * enum hal_uart_type
  57. * UART 处理方式枚举定义.
  58. */
  59. enum hal_uart_type
  60. {
  61.     HAL_UART_INTERRUPT=0,     /**< UART 中断方式 */
  62.     HAL_UART_CHECK=1,         /**< UART 查询方式 */
  63. };

  65. typedef enum  hal_uart_type HAL_UART_TYPE_e; /**< UART 处理方式枚举定义  */

  67.      
  68.              
  69. /**
  70. * enum hal_uart_id
  71. * UART ID枚举定义.
  72. * note id从0开始连续递增,HAL预留足够多的id号n
  73. *       实际用到的id号由BSP硬件资源实现决定.
  74. */
  75. enum hal_uart_id
  76. {
  77.     HAL_UART_0=0,           /**< UART ID0 */
  78.     HAL_UART_1=1,           /**< UART ID1 */
  79.     HAL_UART_2=2,           /**< UART ID2 */
  80.     HAL_UART_3=3,           /**< UART ID3 */
  81.     HAL_UART_4=4,           /**< UART ID4 */
  82.     HAL_UART_5=5,           /**< UART ID5 */
  83.     HAL_UART_6=6,           /**< UART ID6 */
  84.     HAL_UART_7=7,           /**< UART ID7 */
  85.     HAL_UART_8=8,           /**< UART ID8 */
  86.     HAL_UART_9=8,           /**< UART ID9 */
  87.     HAL_UART_MAX=8,         /**< UART 个数 */
  88.     HAL_UART_INV=0xFF,      /**< 无效ID */
  89. };

  91. typedef enum  hal_uart_id HAL_UART_ID_e; /**< UART ID枚举定义  */
  92.    
  93.                
  94. /**
  95. * enum hal_uart_parity
  96. * UART数据奇偶校验枚举定义.
  97. * note HAL描述了所有标准校验方式,n
  98. *       实际用到的校验由BSP硬件资源实现决定.
  99. */
  100. enum hal_uart_parity
  101. {
  102.     HAL_UART_PARITY_NONE=0,       /**< UART无检验 */
  103.     HAL_UART_PARITY_EVEN=1,       /**< UART偶校验 */
  104.     HAL_UART_PARITY_ODD=2,        /**< UART奇校验 */
  105.     HAL_UART_PARITY_HIG=3,        /**< UART校验固定1  */
  106.     HAL_UART_PARITY_LOW=4,        /**< UART校验固定0  */
  107. };

  109. typedef enum  hal_uart_parity HAL_UART_PARITY_e; /**< UART数据奇偶校验枚举定义  */

  111.       
  112. /**
  113. * enum hal_uart_datalen
  114. * UART数据长度枚举定义.
  115. * note HAL描述了所有标准数据长度,n
  116. *       实际用到的数据长度由BSP硬件资源实现决定.
  117. */
  118. enum hal_uart_datalen
  119. {
  120.     HAL_UART_DATA_9=9,       /**< UART 9位数据 */
  121.     HAL_UART_DATA_8=8,       /**< UART 8位数据 */
  122.     HAL_UART_DATA_7=7,       /**< UART 7位数据 */
  123.     HAL_UART_DATA_6=6,       /**< UART 6位数据 */
  124.     HAL_UART_DATA_5=5,       /**< UART 5位数据 */
  125. };

  127. typedef enum  hal_uart_datalen HAL_UART_DATALEN_e; /**< UART数据长度枚举定义  */
  128.           

  130.              
  131. /**
  132. * enum hal_uart_stopb
  133. * UART停止位枚举定义.
  134. * note HAL描述了所有标准停止位长度,n
  135. *       实际用到的停止位长度由BSP硬件资源实现决定.
  136. */
  137. enum hal_uart_stopb
  138. {
  139.     HAL_UART_STOPB_1P5=0,       /**< UART 1.5位停止位 */
  140.     HAL_UART_STOPB_1=1,         /**< UART 1位停止位 */
  141.     HAL_UART_STOPB_2=2,         /**< UART 2位停止位 */
  142. };

  144. typedef enum  hal_uart_stopb HAL_UART_STOPB_e; /**< UART停止位枚举定义  */
  145.    
  146.              
  147. /**
  148. * enum hal_uart_baud
  149. * UART波特率枚举定义.
  150. * note HAL描述了常见波特率,n
  151. *       实际支持的波特率由BSP硬件资源实现决定.
  152. */
  153. enum hal_uart_baud
  154. {
  155.     HAL_UART_BAUD_600=600,        /**< UART波特率600 */
  156.     HAL_UART_BAUD_1200=1200,      /**< UART波特率1200 */
  157.     HAL_UART_BAUD_2400=2400,      /**< UART波特率2400 */
  158.     HAL_UART_BAUD_4800=4800,      /**< UART波特率4800 */
  159.     HAL_UART_BAUD_9600=9600,      /**< UART波特率9600 */
  160.     HAL_UART_BAUD_19200=19200,    /**< UART波特率19200 */
  161.     HAL_UART_BAUD_38400=38400,    /**< UART波特率38400 */
  162.     HAL_UART_BAUD_57600=57600,    /**< UART波特率38400 */
  163.     HAL_UART_BAUD_115200=115200,  /**< UART波特率115200 */
  164.     HAL_UART_BAUD_256000=256000,  /**< UART波特率256000 */
  165. };

  167. typedef enum  hal_uart_baud HAL_UART_BAUD_e; /**< UART波特率枚举定义  */
  168.   
  169. typedef struct hal_uart_cfg HAL_UART_CFG_t;  /**< UART配置结构体  */

  171. /**
  172. * struct hal_uart_cfg
  173. * UART配置结构体.
  174. */
  175. struct hal_uart_cfg
  176. {
  177.     HAL_UART_ID_e       id;         /**< UART id    */
  178.     HAL_UART_DATALEN_e  datalen;    /**< UART数据长度*/  
  179.     HAL_UART_PARITY_e   parity;     /**< UART校验    */
  180.     HAL_UART_STOPB_e    stopb;      /**< UART停止位  */
  181.     HAL_UART_BAUD_e     baud;       /**< UART波特率  */   
  182. };

  184.              
  185. /**
  186. * enum hal_uart_err
  187. * UART错误类型枚举定义.
  188. */
  189. enum hal_uart_err
  190. {
  191.     HAL_UART_ERR_NONE=0,           /**< UART无错误 */
  192.     HAL_UART_ERR_PER=1,            /**< UART校验错误 */
  193.     HAL_UART_ERR_FER=2,            /**< UART帧错误 */
  194.     HAL_UART_ERR_ORER=4,           /**< UART溢出错误 */
  195. };

  197. typedef enum  hal_uart_err HAL_UART_ERR_e; /**< UART错误类型枚举定义  */
  198.    

  200. /**
  201. * typedef HAL_UART_ISRCallBack
  202. * 中断服务回调函数.
  203. * - rxerrfun输入错误回调函数时,param指向错误码字节数据,不需要返回值.
  204. * - rxfun输入缓冲满回调函数时,param指向读到的字节数据,不需要返回值.
  205. * - txfun发送缓冲空回调函数,需要往param写需要发送的字节,返回值0表示还有数据需要发送 返回其他值标志本次为最后一字节数据.
  206. * - txcmpfun发送完回调函数,需要往param写需要发送的字节,返回值0表示还有数据需要发送 返回其他值标志本次为最后一字节数据.
  207. */
  208. typedef int (*HAL_UART_ISRCallBack)(unsigned char* param) ; /**< 中断服务回调函数        */   

  210. typedef struct hal_uart_isrcallback HAL_UART_ISRCALLBACK_t;  /**< 中断服务回调函数结构体  */

  212. /**
  213. * struct hal_uart_isrcallback
  214. * UART回调函数结构体.
  215. */
  216. struct hal_uart_isrcallback
  217. {
  218.     HAL_UART_ID_e        id;         /**< UART id             */
  219.     HAL_UART_ISRCallBack rxerrfun;   /**< 输入错误回调函数     */
  220.     HAL_UART_ISRCallBack rxfun;      /**< 输入缓冲满回调函数   */
  221.     HAL_UART_ISRCallBack txfun;      /**< 发送缓冲空回调函数   */
  222.     HAL_UART_ISRCallBack txcmpfun;   /**< 发送完回调函数       */
  223. };

  225. /**
  226.   * }
  227.   */
  228. /*****************************************************************************   
  229. *                                                                           
  230. *                             接口函数描述                                   
  231. *                                                                           
  232. ****************************************************************************/

  234. /** defgroup HAL_UART_if 硬件抽象层(HAL)串口模块(UART)接口
  235.   * {
  236.   */

  238. /**
  239. *****************************************************************************
  240. * fn          int HAL_UART_Init(HAL_UART_ID_e id)
  241. * brief       初始化UART模块,完成模块相关必要的初始化配置.
  242. * note        使用UART前必须调用,所有UART按默认配置(BSP实现).
  243. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  244. * retval      0 初始化成功.
  245. * retval      -1 初始化失败.
  246. *****************************************************************************
  247. */
  248. int HAL_UART_Init(HAL_UART_ID_e id);

  250. /**
  251. *****************************************************************************
  252. * fn          int HAL_UART_CheckSend(HAL_UART_ID_e id,unsigned char byte)
  253. * brief       查询的方式发送一个字节.
  254. * note        阻塞发送,直到发送完才会返回.  
  255. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  256. * param[in]   byte 需要发送的字节.
  257. * retval      0 发送成功.
  258. * retval      其他值 发送失败(实际上没有发送完会阻塞所以不会返回其他值).
  259. *****************************************************************************
  260. */
  261. int HAL_UART_CheckSend(HAL_UART_ID_e id,unsigned char byte);

  263. /**
  264. *****************************************************************************
  265. * fn          int HAL_UART_CheckRead(HAL_UART_ID_e id,unsigned char* byte);
  266. * brief       查询的方式读一个字节.
  267. * note        阻塞读,直到有数据才会返回.  
  268. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  269. * param[in]   byte 存储读到的字节.
  270. * retval      0 读成功.
  271. * retval      其他值 读失败(实际上读不到数据会阻塞所以不会返回其他值).
  272. *****************************************************************************
  273. */
  274. int HAL_UART_CheckRead(HAL_UART_ID_e id,unsigned char* byte);

  276. /**
  277. *****************************************************************************
  278. * fn          int HAL_UART_Send(HAL_UART_ID_e id,unsigned char byte)
  279. * brief       直接发送一个字节.
  280. * note        直接发送,直接往硬件发送缓冲写字节立即返回.  
  281. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  282. * param[in]   byte 需要发送的字节.
  283. * retval      0 发送成功.
  284. * retval      其他值 发送失败(实际上不会返回其他值).
  285. *****************************************************************************
  286. */
  287. int HAL_UART_Send(HAL_UART_ID_e id,unsigned char byte);

  289. /**
  290. *****************************************************************************
  291. * fn          int HAL_UART_Read(HAL_UART_ID_e id,unsigned char* byte);
  292. * brief       直接读一个字节.
  293. * note        直接读,直接读硬件缓冲立即返回.  
  294. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  295. * param[in]   byte 存储读到的字节.
  296. * retval      0 读成功.
  297. * retval      其他值 读失败(实际上不会返回其他值).
  298. *****************************************************************************
  299. */
  300. int HAL_UART_Read(HAL_UART_ID_e id,unsigned char* byte);

  302. /**
  303. *****************************************************************************
  304. * fn          int HAL_UART_SetTxISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  305. * brief       设置发送缓冲区空中断服务回调函数.
  306. * note        .  
  307. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  308. * param[in]   callbackfun 回调函数.
  309. * retval      0 设置成功.
  310. * retval      其他值 设置失败.
  311. *****************************************************************************
  312. */
  313. int HAL_UART_SetTxISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun);

  315. /**
  316. *****************************************************************************
  317. * fn          int HAL_UART_SetTxCmpISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  318. * brief       设置发送完中断服务回调函数.
  319. * note        .  
  320. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  321. * param[in]   callbackfun 回调函数.
  322. * retval      0 设置成功.
  323. * retval      其他值 设置失败.
  324. *****************************************************************************
  325. */
  326. int HAL_UART_SetTxCmpISRCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun);

  328. /**
  329. *****************************************************************************
  330. * fn          int HAL_UART_SetRxCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  331. * brief       设置接收缓冲满中断服务回调函数.
  332. * note        .  
  333. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  334. * param[in]   callbackfun 回调函数.
  335. * retval      0 设置成功.
  336. * retval      其他值 设置失败.
  337. *****************************************************************************
  338. */
  339. int HAL_UART_SetRxCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun);

  341. /**
  342. *****************************************************************************
  343. * fn          int HAL_UART_SetRxErrCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun)
  344. * brief       设置接收错误中断服务回调函数.
  345. * note        .  
  346. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  347. * param[in]   callbackfun 回调函数.
  348. * retval      0 设置成功.
  349. * retval      其他值 设置失败.
  350. *****************************************************************************
  351. */
  352. int HAL_UART_SetRxErrCallBack(HAL_UART_ID_e id,HAL_UART_ISRCallBack callbackfun);

  354. /**
  355. *****************************************************************************
  356. * fn          int HAL_UART_SetCfg(HAL_UART_ID_e id,HAL_UART_CFG_t* cfg)
  357. * brief       配置UART参数.
  358. * note        .  
  359. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  360. * param[in]   cfg 指向配置参数结构体 ref HAL_UART_CFG_t.
  361. * retval      0 设置成功.
  362. * retval      其他值 设置失败.
  363. *****************************************************************************
  364. */
  365. int HAL_UART_SetCfg(HAL_UART_ID_e id,HAL_UART_CFG_t* cfg);

  367. /**
  368. *****************************************************************************
  369. * fn          int HAL_UART_EnableTx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  370. * brief       发送使能.
  371. * note        .  
  372. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  373. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  374. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  375. * retval      0 设置成功.
  376. * retval      其他值 设置失败.
  377. *****************************************************************************
  378. */
  379. int HAL_UART_EnableTx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable);

  381. /**
  382. *****************************************************************************
  383. * fn          int HAL_UART_EnableRx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  384. * brief       接收使能.
  385. * note        .  
  386. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  387. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  388. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  389. * retval      0 设置成功.
  390. * retval      其他值 设置失败.
  391. *****************************************************************************
  392. */
  393. int HAL_UART_EnableRx(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable);

  395. /**
  396. *****************************************************************************
  397. * fn          int HAL_UART_EnableRxErr(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable)
  398. * brief       接收错误中断使能.
  399. * note        .  
  400. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  401. * param[in]   type 处理方式 ref HAL_UART_TYPE_e.
  402. * param[in]   enable 使能或者禁能 ref HAL_UART_ENABLE_e.
  403. * retval      0 设置成功.
  404. * retval      其他值 设置失败.
  405. *****************************************************************************
  406. */
  407. int HAL_UART_EnableRxErr(HAL_UART_ID_e id,HAL_UART_TYPE_e type,HAL_UART_ENABLE_e enable);

  409. /**
  410. *****************************************************************************
  411. * fn          int HAL_UART_DeInit(HAL_UART_ID_e id)
  412. * brief       解除UART模块,关闭模块.
  413. * note        .
  414. * param[in]   id UARTid,依赖于BSP实现,ref HAL_UART_ID_e.
  415. * retval      0 成功.
  416. * retval      -1 失败.
  417. *****************************************************************************
  418. */
  419. int HAL_UART_DeInit(HAL_UART_ID_e id);

  421. /**
  422.   * }
  423.   */

  425. /**
  426.   * }
  427.   */


  430. /**
  431.   * }
  432.   */

  434. /**
  435.   * }
  436.   */

  438. #ifdef __cplusplus
  439. }
  440. #endif

  442. #endif

driver_uart.c
  1. #define DRIVER_UART_GLOBALS /**< 包含driver_uart.h中的数据将会编译*/

  3. #include "driver_uart.h"
  4. #include "osapi.h"
  5.    
  6. /*****************************************************************************   
  7. *                                                                           
  8. *                             内部数据                                   
  9. *                                                                           
  10. ****************************************************************************/


  13. /*****************************************************************************   
  14. *                                                                           
  15. *                             内部接口函数实现                                   
  16. *                                                                           
  17. ****************************************************************************/

  19. /*485方向控制回调函数:
  20.   按照一般需求最多8路串口这里实现8路,如果有更多路需求再添加即可
  21. */
  22. #if UART0_ENABLE
  23. static void uart0_txhook(void)
  24. {
  25.        /*无效电平发送*/
  26. }

  28. static void uart0_rxhook(void)
  29. {
  30.       /*有效电平接收*/
  31. }
  32. #endif


  35. #if UART4_ENABLE
  36. static void uart4_txhook(void)
  37. {
  38.      /*无效电平发送*/
  39. }

  41. static void uart4_rxhook(void)
  42. {
  43.      /*有效电平接收 */
  44. }
  45. #endif

  47. #if UART9_ENABLE
  48. static void uart9_txhook(void)
  49. {
  50.       /*无效电平发送*/
  51. }

  53. static void uart9_rxhook(void)
  54. {
  55.       /*有效电平接收 */
  56. }
  57. #endif

  59. /**
  60. *****************************************************************************
  61. * fn          static int rx_fifo_in(driver_uart_t *p, unsigned char data)
  62. * brief       写数据到接收缓冲区.
  63. * note        接收中断服务函数调用该函数写数据到接收缓冲区,缓冲区满不写入.
  64. * param[in]   p 指向uart结构体实例的指针 ref driver_uart_t
  65. * param[in]   data 指向要写到缓冲区的数据
  66. *****************************************************************************
  67. */
  68. static int rx_fifo_in(driver_uart_t *p, unsigned char data)
  69. {
  70.     if(p==0)
  71.     {
  72.         return 0;
  73.     }
  74.     /*缓冲区未满写入数据*/
  75.     if (p->rx_len < (p->rxbuf_len/sizeof(p->rx_buf[0])))
  76.     {   
  77.         p->rx_buf[p->rx_in++] = data;                   /*写入数据,写入指针递增*/
  78.         p->rx_in %= p->rxbuf_len/sizeof(p->rx_buf[0]); /*边界处理,实现圆形缓冲区*/
  79.         p->rx_len++;                                    /*数据个数递增*/
  80.         return 0;
  81.     }
  82.     else
  83.     {
  84.         return -1;
  85.     }
  86. }


  89. /**
  90. *****************************************************************************
  91. * fn          static unsigned char rx_fifo_out(driver_uart_t *p, unsigned int timeout, unsigned char *perro)
  92. * brief       从接收缓冲区读数据.
  93. * note        应用函数调用该函数从接收缓冲区读数据,可以指定超时时间.
  94. * param[in]   p 指向uart结构体实例的指针 ref driver_uart_t
  95. * param[in]   timeout 指定超时时间 0表示一直等待
  96. * param[in]   perro 错误码0表示读到了数据 1表示没有读到数据
  97. * retval      unsigned char 读到的字节数据.
  98. *****************************************************************************
  99. */
  100. static unsigned char rx_fifo_out(driver_uart_t *p, unsigned int timeout, int *perro)
  101. {
  102.     unsigned char data = 0;
  103.     if(p==0)
  104.     {
  105.         *perro = 1;
  106.         return 0;
  107.     }
  108.     OSCriticalAlloc();
  109.     /*timeout==0 表示一直等待直到有数据*/
  110.     if (timeout == 0)
  111.     {
  112.         while(p->rx_len == 0)
  113.         {
  114.             OsTimeDelay(DRIVER_UART_DELAY_CHECK);  /*延时*/
  115.         }
  116.     }
  117.     else /*timeout!=0 表示等待指定超时时间*/
  118.     {
  119.         while (timeout != 0)
  120.         {
  121.             if (p->rx_len == 0)
  122.             {
  123.                 /*如果无数据,延时指定时间间隔*/
  124.                 if (timeout >= DRIVER_UART_DELAY_CHECK)
  125.                 {
  126.                     timeout -= DRIVER_UART_DELAY_CHECK;
  127.                     OsTimeDelay(DRIVER_UART_DELAY_CHECK);
  128.                 }
  129.                 else
  130.                 {
  131.                      /*不足一个时间间隔延时剩余时间*/
  132.                     OsTimeDelay(timeout);
  133.                     timeout = 0;
  134.                 }
  135.             }
  136.             else
  137.             {
  138.                 break;
  139.             }
  140.         }
  141.     }
  142.     /*临界段处理 防止此时中断在操作缓冲区*/
  143.     OSCriticalEnter();
  144.     if (p->rx_len != 0)
  145.     {
  146.         /*从缓冲区读出数据*/
  147.         p->rx_len--;
  148.         data = p->rx_buf[p->rx_out++];
  149.         p->rx_out %= p->rxbuf_len/sizeof(p->rx_buf[0]);
  150.         *perro = 0;
  151.     }
  152.     else
  153.     {
  154.         *perro = 1;
  155.     }
  156.     OSCriticalExit();
  157.     return data;
  158. }


  161. /**
  162. *****************************************************************************
  163. * fn          static int tx_fifo_in(driver_uart_t *p, unsigned int timeout, unsigned char data,unsigned char *perro)
  164. * brief       写数据到发送缓冲区.
  165. * note        应用调用该函数调写数据到发送缓冲区,缓冲区满等待.
  166. * param[in]   p 指向uart结构体实例的指针 ref driver_uart_t
  167. * param[in]   timeout 设定超时时间 0表示一直等待
  168. * param[in]   data 指向要写到缓冲区的数据
  169. * retval      0 写成功
  170. * retval      1 写失败
  171. *****************************************************************************
  172. */
  173. static int tx_fifo_in(driver_uart_t *p, unsigned char data, unsigned int timeout)
  174. {
  175.     /*注意确保p缓冲区的读写处于临界段保护 */
  176.     int ret=0;
  177.     if(p==0)
  178.     {
  179.         return 1;
  180.     }
  181.     OSCriticalAlloc();
  182.     if (timeout == 0)
  183.     {
  184.       
  185.         while(1)
  186.         {
  187.             OSCriticalEnter();
  188.             if(p->tx_len < (p->txbuf_len/sizeof(p->tx_buf[0])))
  189.             {
  190.                 /*没有满则写入数据*/
  191.                 p->tx_buf[p->tx_in++] = data;
  192.                 p->tx_in %= p->txbuf_len/sizeof(p->tx_buf[0]);
  193.                 p->tx_len++;
  194.                 OSCriticalExit();
  195.                 break;
  196.             }
  197.             else
  198.             {
  199.                 /*满则等待*/
  200.                 OSCriticalExit();
  201.                 OsTimeDelay(DRIVER_UART_DELAY_CHECK);  /*延时*/
  202.             }
  203.         }
  204.     }
  205.     while (timeout != 0)
  206.     {
  207.         OSCriticalEnter();
  208.         if (p->tx_len < (p->txbuf_len/sizeof(p->tx_buf[0])))
  209.         {   
  210.             /*没有满则写入数据*/
  211.             p->tx_buf[p->tx_in++] = data;
  212.             p->tx_in %= p->txbuf_len/sizeof(p->tx_buf[0]);
  213.             p->tx_len++;
  214.             OSCriticalExit();
  215.             ret = 0; /*设置正确返回值*/
  216.             break;
  217.         }
  218.         else
  219.         {
  220.             OSCriticalExit();
  221.             /*如果无数据,延时指定时间间隔*/
  222.             if (timeout >= DRIVER_UART_DELAY_CHECK)
  223.             {
  224.                 timeout -= DRIVER_UART_DELAY_CHECK;
  225.                 OsTimeDelay(DRIVER_UART_DELAY_CHECK);
  226.                 ret = 1; /*设置超时错误 之前这里没设置ret=1 在timeout为DRIVER_UART_DELAY_CHECK的整数倍时总是会返回0*/
  227.             }
  228.             else
  229.             {
  230.                 /*不足一个时间间隔延时剩余时间*/
  231.                 OsTimeDelay(timeout);
  232.                 timeout = 0;
  233.                 ret = 1; /*设置超时错误*/
  234.             }
  235.         }
  236.     }
  237.     return ret;
  238. }


  241. /**
  242. *****************************************************************************
  243. * fn          static unsigned char tx_fifo_out(driver_uart_t *p, unsigned char *perro)
  244. * brief       从发送缓冲区读数据.
  245. * note        发送中断服务函数调用该函数获取发送缓冲区数据,用于发送.
  246. * param[in]   p 指向uart结构体实例的指针 ref driver_uart_t
  247. * param[out]  perro 错误码 0表示读到数据 1表示没有数据
  248. * return      unsigned char perro=0时表示读到的数据  
  249. *****************************************************************************
  250. */
  251. static unsigned char tx_fifo_out(driver_uart_t *p, int *perro)
  252. {
  253.     unsigned char data = 0;
  254.     if(p==0)
  255.     {
  256.         *perro = 1;
  257.         return 0;
  258.     }
  259.     if (p->tx_len != 0)
  260.     {
  261.         if(p->tx_hook != 0)
  262.         {
  263.             (*(p->tx_hook))();
  264.         }
  265.         p->tx_len--;
  266.         data = p->tx_buf[p->tx_out++];
  267.         p->tx_out %= p->txbuf_len/sizeof(p->tx_buf[0]);
  268.         *perro = 0;
  269.     }
  270.     else
  271.     {
  272.         *perro = 1;
  273.     }
  274.     return data;
  275. }



  279. /**
  280. *****************************************************************************
  281. * fn          static int driver_uart0_send_isr(unsigned char *pdata)
  282. * brief       发送处理.
  283. * note        发送中断服务函数调用该函数,如果缓冲区空则停止发送并调用回调函数.
  284. * param[out]  pdata 回写需要发送的数据
  285. * retval      0 pdata指向的数据有效(需要发送) 1无后续发送数据
  286. *****************************************************************************
  287. */
  288. #if UART0_ENABLE
  289. static int driver_uart0_send_isr(unsigned char *pdata)
  290. {
  291.     int erro=0;
  292.     unsigned char data;
  293.     if(driver_uart_tab[0]==0)
  294.     {
  295.         return 1;
  296.     }
  297.     data = tx_fifo_out(driver_uart_tab[0], &erro);
  298.     if (erro != 0)
  299.     {  
  300.         /*没有获取到数据,停止发送*/
  301.         HAL_UART_EnableTx(driver_uart_tab[0]->id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  302.         driver_uart_tab[0]->state = HAL_UART_TXIDLE;
  303.         if(driver_uart_tab[0]->rx_hook != 0)
  304.         {
  305.             driver_uart_tab[0]->rx_hook();
  306.         }   
  307.         return 1;
  308.     }
  309.     else
  310.     {
  311.         *pdata = data;
  312.         return 0;
  313.     }  
  314. }
  315. #endif


  318. /**
  319. *****************************************************************************
  320. * fn          static int driver_uart4_send_isr(unsigned char *pdata)
  321. * brief       发送处理.
  322. * note        发送中断服务函数调用该函数,如果缓冲区空则停止发送并调用回调函数.
  323. * param[out]  pdata 回写需要发送的数据
  324. * retval      0 pdata指向的数据有效(需要发送) 1无后续发送数据
  325. *****************************************************************************
  326. */
  327. #if UART4_ENABLE
  328. static int driver_uart4_send_isr(unsigned char *pdata)
  329. {
  330.     int erro=0;
  331.     unsigned char data;
  332.     if(driver_uart_tab[4]==0)
  333.     {
  334.         return 1;
  335.     }
  336.     data = tx_fifo_out(driver_uart_tab[4], &erro);
  337.     if (erro != 0)
  338.     {  
  339.         /*没有获取到数据,停止发送*/
  340.         HAL_UART_EnableTx(driver_uart_tab[4]->id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  341.         driver_uart_tab[4]->state = HAL_UART_TXIDLE;
  342.         if(driver_uart_tab[4]->rx_hook != 0)
  343.         {
  344.             driver_uart_tab[4]->rx_hook();
  345.         }  
  346.         return 1;
  347.     }
  348.     else
  349.     {
  350.       *pdata = data;
  351.       return 0;
  352.     }  
  353. }
  354. #endif

  356. /**
  357. *****************************************************************************
  358. * fn          static int driver_uart9_send_isr(unsigned char *pdata)
  359. * brief       发送处理.
  360. * note        发送中断服务函数调用该函数,如果缓冲区空则停止发送并调用回调函数.
  361. * param[out]  pdata 回写需要发送的数据
  362. * retval      0 pdata指向的数据有效(需要发送) 1无后续发送数据
  363. *****************************************************************************
  364. */
  365. #if UART9_ENABLE
  366. static int driver_uart9_send_isr(unsigned char *pdata)
  367. {
  368.     int erro=0;
  369.     unsigned char data;
  370.     if(driver_uart_tab[9]==0)
  371.     {
  372.         return 1;
  373.     }
  374.     data = tx_fifo_out(driver_uart_tab[9], &erro);
  375.     if (erro != 0)
  376.     {  
  377.         /*没有获取到数据,停止发送*/
  378.         HAL_UART_EnableTx(driver_uart_tab[9]->id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  379.         driver_uart_tab[9]->state = HAL_UART_TXIDLE;
  380.         if(driver_uart_tab[9]->rx_hook != 0)
  381.         {
  382.             driver_uart_tab[9]->rx_hook();
  383.         }   
  384.         return 1;
  385.     }
  386.     else
  387.     {
  388.         *pdata = data;
  389.         return 0;
  390.     }  
  391. }
  392. #endif


  395. /**
  396. *****************************************************************************
  397. * fn          static int driver_uart0_recv_isr(unsigned char* data)
  398. * brief       接收处理.
  399. * note        接收中断服务函数调用该函数,如果缓冲区满则丢弃新的数据.
  400. * param[out]  pdata 新的数据.
  401. * retval      总是返回0
  402. *****************************************************************************
  403. */
  404. #if UART0_ENABLE
  405. static int driver_uart0_recv_isr(unsigned char* data)
  406. {
  407.     if(driver_uart_tab[0]==0)
  408.     {
  409.         return 0;
  410.     }
  411.     driver_uart_tab[0]->rxhavedata =1;
  412.     return rx_fifo_in(driver_uart_tab[0], *data);
  413. }
  414. #endif


  417. /**
  418. *****************************************************************************
  419. * fn          static int driver_uart4_recv_isr(unsigned char* data)
  420. * brief       接收处理.
  421. * note        接收中断服务函数调用该函数,如果缓冲区满则丢弃新的数据.
  422. * param[out]  pdata 新的数据.
  423. * retval      总是返回0
  424. *****************************************************************************
  425. */
  426. #if UART4_ENABLE
  427. static int driver_uart4_recv_isr(unsigned char* data)
  428. {
  429.     if(driver_uart_tab[4]==0)
  430.     {
  431.         return 0;
  432.     }
  433.     driver_uart_tab[4]->rxhavedata =1;
  434.     return rx_fifo_in(driver_uart_tab[4], *data);
  435. }
  436. #endif

  438. /**
  439. *****************************************************************************
  440. * fn          static int driver_uart9_recv_isr(unsigned char* data)
  441. * brief       接收处理.
  442. * note        接收中断服务函数调用该函数,如果缓冲区满则丢弃新的数据.
  443. * param[out]  pdata 新的数据.
  444. * retval      总是返回0
  445. *****************************************************************************
  446. */
  447. #if UART9_ENABLE
  448. static int driver_uart9_recv_isr(unsigned char* data)
  449. {
  450.     if(driver_uart_tab[9]==0)
  451.     {
  452.         return 0;
  453.     }
  454.     driver_uart_tab[9]->rxhavedata =1;
  455.     return rx_fifo_in(driver_uart_tab[9], *data);
  456. }
  457. #endif



  461. /**
  462. *****************************************************************************
  463. * fn          static int driver_uart_rxerr_isr(HAL_UART_ID_e id,unsigned char *pdata)
  464. * brief       接收错误处理.
  465. * note        接收错误中断服务函数调用该函数.
  466. * param[in]   pdata 错误码
  467. * retval      0 总是返回0
  468. *****************************************************************************
  469. */
  470. static int driver_uart_rxerr_isr(HAL_UART_ID_e id,unsigned char *pdata)
  471. {
  472.     if(driver_uart_tab[id]==0)
  473.     {
  474.         return 0;
  475.     }
  476.     if(*pdata & HAL_UART_ERR_PER)
  477.     {
  478.         if((driver_uart_tab[id]->err & 0x000000FF) != 0x000000FF)
  479.         {
  480.             driver_uart_tab[id]->err = driver_uart_tab[id]->err + 1;
  481.         }
  482.         else
  483.         {
  484.             HAL_UART_EnableRxErr(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  485.             HAL_UART_EnableRx(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  486.         }
  487.     }
  488.     if(*pdata & HAL_UART_ERR_FER)
  489.     {
  490.         if((driver_uart_tab[id]->err & 0x0000FF00) != 0x0000FF00)
  491.         {
  492.             driver_uart_tab[id]->err = driver_uart_tab[id]->err + 0x100;
  493.         }
  494.         else
  495.         {
  496.             HAL_UART_EnableRxErr(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  497.             HAL_UART_EnableRx(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  498.         }
  499.     }
  500.     if(*pdata & HAL_UART_ERR_ORER)
  501.     {
  502.         if((driver_uart_tab[id]->err & 0x00FF0000) != 0x00FF0000)
  503.         {
  504.             driver_uart_tab[id]->err = driver_uart_tab[id]->err + 0x10000;
  505.         }
  506.         else
  507.         {
  508.             HAL_UART_EnableRxErr(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  509.             HAL_UART_EnableRx(id,HAL_UART_INTERRUPT,HAL_UART_DISABLE);
  510.         }
  511.     }
  512.     return 0;
  513. }

  515. /**
  516. *****************************************************************************
  517. * fn          static int driver_uart0_rxerr_isr(unsigned char *pdata)
  518. * brief       接收错误处理.
  519. * note        接收错误中断服务函数调用该函数.
  520. * param[in]   pdata 错误码
  521. * retval      0 总是返回0
  522. *****************************************************************************
  523. */
  524. #if UART0_ENABLE
  525. static int driver_uart0_rxerr_isr(unsigned char *pdata)
  526. {
  527.     return driver_uart_rxerr_isr(HAL_UART_0,pdata);
  528. }
  529. #endif

  531. /**
  532. *****************************************************************************
  533. * fn          static int driver_uart4_rxerr_isr(unsigned char *pdata)
  534. * brief       接收错误处理.
  535. * note        接收错误中断服务函数调用该函数.
  536. * param[in]   pdata 错误码
  537. * retval      0 总是返回0
  538. *****************************************************************************
  539. */
  540. #if UART4_ENABLE
  541. static int driver_uart4_rxerr_isr(unsigned char *pdata)
  542. {
  543.     return driver_uart_rxerr_isr(HAL_UART_4,pdata);
  544. }
  545. #endif

  547. /**
  548. *****************************************************************************
  549. * fn          static int driver_uart9_rxerr_isr(unsigned char *pdata)
  550. * brief       接收错误处理.
  551. * note        接收错误中断服务函数调用该函数.
  552. * param[in]   pdata 错误码
  553. * retval      0 总是返回0
  554. *****************************************************************************
  555. */
  556. #if UART9_ENABLE
  557. static int driver_uart9_rxerr_isr(unsigned char *pdata)
  558. {
  559.     return driver_uart_rxerr_isr(HAL_UART_9,pdata);
  560. }
  561. #endif


  564. /*****************************************************************************   
  565. *                                                                           
  566. *                             对外接口函数实现                                   
  567. *                                                                           
  568. ****************************************************************************/

  570. /**
  571. *****************************************************************************
  572. * fn          static int driver_uart_init(HAL_UART_ID_e id)
  573. * brief       初始化串口.
  574. * note        .
  575. * param[in]   id 串口id ref HAL_UART_ID_e
  576. * retval      0 设置成功
  577. * retval      -1参数错误
  578. *****************************************************************************
  579. */
  580. static int driver_uart_init(HAL_UART_ID_e id)
  581. {       
  582.     /*初始化端口和默认参数*/
  583.     HAL_UART_Init(id);
  584.     /*设置回调函数*/
  585.     switch(id)
  586.     {
  587. #if UART0_ENABLE
  588.     case HAL_UART_0:
  589.         HAL_UART_SetTxCmpISRCallBack(HAL_UART_0,driver_uart0_send_isr);
  590.         HAL_UART_SetRxCallBack(HAL_UART_0,driver_uart0_recv_isr);
  591.         HAL_UART_SetRxErrCallBack(HAL_UART_0,driver_uart0_rxerr_isr);
  592.         break;
  593. #endif
  594. #if UART4_ENABLE
  595.     case HAL_UART_4:
  596.         HAL_UART_SetTxCmpISRCallBack(HAL_UART_4,driver_uart4_send_isr);
  597.         HAL_UART_SetRxCallBack(HAL_UART_4,driver_uart4_recv_isr);
  598.         HAL_UART_SetRxErrCallBack(HAL_UART_4,driver_uart4_rxerr_isr);
  599.         break;
  600. #endif
  601. #if UART9_ENABLE
  602.     case HAL_UART_9:
  603.         HAL_UART_SetTxCmpISRCallBack(HAL_UART_9,driver_uart9_send_isr);
  604.         HAL_UART_SetRxCallBack(HAL_UART_9,driver_uart9_recv_isr);
  605.         HAL_UART_SetRxErrCallBack(HAL_UART_9,driver_uart9_rxerr_isr);
  606.         break;
  607. #endif
  608.     default:
  609.         return -1;
  610.         break;
  611.     }
  612.     return 0;
  613. }

  615. /**
  616. *****************************************************************************
  617. * fn          unsigned int driver_uart_getrxlen(HAL_UART_ID_e id)
  618. * brief       获取接收缓冲区有效数据长度.
  619. * note        .
  620. * param[in]   id 串口id ref HAL_UART_ID_e
  621. * return      unsigned int 接收缓冲区长度
  622. *****************************************************************************
  623. */
  624. unsigned int driver_uart_getrxlen(HAL_UART_ID_e id)
  625. {
  626.     if(driver_uart_tab[id]==0)
  627.     {
  628.         return 0;
  629.     }
  630.     return driver_uart_tab[id]->rx_len;
  631. }


  634. /**
  635. *****************************************************************************
  636. * fn          unsigned int driver_uart_flush(HAL_UART_ID_e id)
  637. * brief       清除缓冲区.
  638. * note        .
  639. * param[in]   id 串口id ref HAL_UART_ID_e
  640. * return      int 总是返回0
  641. *****************************************************************************
  642. */
  643. unsigned int driver_uart_flush(HAL_UART_ID_e id)
  644. {
  645.     if(driver_uart_tab[id]!=0)
  646.     {
  647.         driver_uart_tab[id]->rx_in  = 0;
  648.         driver_uart_tab[id]->rx_out = 0;
  649.         driver_uart_tab[id]->rx_len = 0;
  650.         driver_uart_tab[id]->tx_in  = 0;
  651.         driver_uart_tab[id]->tx_out = 0;
  652.         driver_uart_tab[id]->tx_len = 0;
  653.         driver_uart_tab[id]->err = 0x00;
  654.     }
  655.     return 0;
  656. }

  658. /**
  659. *****************************************************************************
  660. * fn          int driver_uart_set(HAL_UART_CFG_t* cfg)
  661. * brief       配置串口参数.
  662. * note        .
  663. * param[in]   cfg 配置参数
  664. * return      int ref HAL_UART_SetCfg 的返回值
  665. *****************************************************************************
  666. */
  667. int driver_uart_set(HAL_UART_CFG_t* cfg)
  668. {
  669.     int ret;
  670.     if(driver_uart_tab[cfg->id]==0)
  671.     {
  672.         return 0;
  673.     }
  674.     driver_uart_init(cfg->id);
  675.     ret = HAL_UART_SetCfg(cfg->id,cfg);
  676.     HAL_UART_EnableRx(cfg->id,HAL_UART_INTERRUPT,HAL_UART_ENABLE);
  677.     driver_uart_flush(cfg->id);
  678.     return ret;
  679. }

  681. /**
  682. *****************************************************************************
  683. * fn          unsigned int driver_uart_recv(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len, unsigned int timeout, int *perro)
  684. * brief       串口接收指定长度数据,可以设置超时时间.
  685. * note        应用调用该函数接收数据,如果缓冲区无数据就等待.
  686. * param[in]   id 指定的串口id.
  687. * param[in]   pdata 需存储接收数据的缓冲区.
  688. * param[in]   len   接收的数据长度.
  689. * param[in]   timeout 设置为0表示一直等到接收到指定长度数据,设置为其他值表示等待指定超时时间(单位mS)
  690. * param[out]  perro 错误码 0表示成功 -1表示参数错误 1表示超时
  691. * return      int 返回实际读到的数据长度
  692. *****************************************************************************
  693. */
  694. unsigned int driver_uart_recv(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len, unsigned int timeout, int *erro)
  695. {
  696.     unsigned char data=0;
  697.     unsigned int readlen=0;
  698.     unsigned int tmptimeout=0;
  699.     if (id >= HAL_UART_MAX)
  700.     {
  701.         *erro = -1;
  702.         return 0;
  703.     }
  704.     if(driver_uart_tab[id]==0)
  705.     {
  706.         *erro = -1;
  707.         return 0;
  708.     }
  709.     if(len ==0)
  710.     {
  711.         *erro = -1;
  712.         return 0;
  713.     }
  714.     tmptimeout = timeout;
  715.     while(len !=0)
  716.     {
  717.         data = rx_fifo_out(driver_uart_tab[id], tmptimeout, erro);
  718.         if (*erro == 0)
  719.         {      
  720.             tmptimeout = DRIVER_UART_DELAY_FRAME;
  721.             *pdata++ = data;   
  722.             len--;
  723.             readlen++;
  724.         }
  725.         else
  726.         {
  727.             *erro = 1;
  728.             break;
  729.         }
  730.     }
  731.     return readlen;
  732. }

  734. /**
  735. *****************************************************************************
  736. * fn          int driver_uart_send(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len,unsigned int timeout,int *perro)
  737. * brief       串口发送指定长度数据,可以设置超时时间.
  738. * note        应用调用该函数发送数据,如果缓冲区满就等待.
  739. * param[in]   id 指定的串口id.
  740. * param[in]   pdata 需要发送的数据缓冲区.
  741. * param[in]   len   需要发送的数据长度.
  742. * param[in]   timeout 设置为0表示一直等到全部写入缓冲区,设置为其他值表示等待指定超时时间(单位mS)
  743. * param[out]  perro 错误码 0表示成功 -1表示参数错误 1表示超时
  744. * return      int 返回实际发送的数据
  745. *****************************************************************************
  746. */
  747. int driver_uart_send(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len,unsigned int timeout,int *erro)
  748. {
  749.     unsigned char full=0;
  750.     driver_uart_t *p=0;
  751.     unsigned char data=0;
  752.     unsigned int sendlen=0;
  753.     OSCriticalAlloc();
  754.     if (id >= HAL_UART_MAX)
  755.     {
  756.         *erro = -1;
  757.         return 0;
  758.     }
  759.     if(driver_uart_tab[id]==0)
  760.     {
  761.         *erro = -1;
  762.         return 0;
  763.     }
  764.     if(len ==0)
  765.     {
  766.          *erro = -1;
  767.         return 0;
  768.     }
  769.     p = (driver_uart_t *)driver_uart_tab[id];
  770.     if(p->tx_hook !=0)
  771.     {
  772.         p->tx_hook();   /*调用准备发送回调函数*/
  773.     }
  774.     driver_uart_tab[id]->txhavedata =1;
  775.     if(timeout == 0)
  776.     {
  777.         while(len !=0)
  778.         {
  779.             full = tx_fifo_in(p,*pdata,DRIVER_UART_DELAY_CHECK);
  780.             if (full == 0)
  781.             {
  782.                 pdata++;
  783.                 len--;
  784.                 sendlen++;
  785.             }
  786.             else
  787.             {
  788.                 OSCriticalEnter();
  789.                 /*如果缓冲区满而且当前串口没有处于发送状态要先发送一个字节触发发送中断流*/
  790.                 if(p->state == HAL_UART_TXIDLE)
  791.                 {
  792.                     data = tx_fifo_out(p, erro);
  793.                     if(*erro == 0)
  794.                     {
  795.                         if(p->tx_hook !=0)
  796.                         {
  797.                             p->tx_hook();   /*调用准备发送回调函数*/
  798.                         }
  799.                         p->state = HAL_UART_TXBUSY; /*注意:p->state的读写需要临界保护*/
  800.                         HAL_UART_Send(p->id,data);  /*注意:必须放在使能TX前,写TDR会清除TEND标志,否则使能TE会马上产生发送完中断*/
  801.                         HAL_UART_EnableTx(id,HAL_UART_INTERRUPT,HAL_UART_ENABLE);      
  802.                     }
  803.                 }
  804.                 OSCriticalExit();
  805.                 OsTimeDelay(DRIVER_UART_DELAY_CHECK);
  806.             }
  807.         }
  808.         *erro = 0;
  809.     }
  810.     else
  811.     {
  812.         while ((len != 0) && (timeout!=0))
  813.         {
  814.             full = tx_fifo_in(p,*pdata,DRIVER_UART_DELAY_CHECK);
  815.             if (full == 0)
  816.             {
  817.                 pdata++;
  818.                 len--;
  819.                 sendlen++;
  820.             }
  821.             else
  822.             {
  823.                 OSCriticalEnter();
  824.                 /*如果缓冲区满而且当前串口没有处于发送状态要先发送一个字节触发发送中断流*/
  825.                 if(p->state == HAL_UART_TXIDLE)
  826.                 {
  827.                     data = tx_fifo_out(p, erro);
  828.                     if(*erro == 0)
  829.                     {
  830.                         if(p->tx_hook !=0)
  831.                         {
  832.                             p->tx_hook();   /*调用准备发送回调函数*/
  833.                         }
  834.                         p->state = HAL_UART_TXBUSY; /*注意:p->state的读写需要临界保护*/
  835.                         HAL_UART_Send(p->id,data);  /*注意:必须放在使能TX前,写TDR会清除TEND标志,否则使能TE会马上产生发送完中断*/
  836.                         HAL_UART_EnableTx(id,HAL_UART_INTERRUPT,HAL_UART_ENABLE);      
  837.                     }
  838.                     OSCriticalExit();
  839.                 }
  840.                 else /*如果当前处于发送状态*/
  841.                 {
  842.                     OSCriticalExit();
  843.                     /*如果缓冲区满而且串口处于发送状态则延时指定时间间隔等待中断发送完*/
  844.                     if (timeout >= DRIVER_UART_DELAY_CHECK)
  845.                     {
  846.                         timeout -= DRIVER_UART_DELAY_CHECK;
  847.                         OsTimeDelay(DRIVER_UART_DELAY_CHECK);
  848.                     }
  849.                     else
  850.                     {
  851.                         /*不足一个时间间隔延时剩余时间*/
  852.                         OsTimeDelay(timeout);
  853.                         timeout = 0;
  854.                     }
  855.                 }
  856.             }
  857.         }
  858.         /*如果没发送完设置超时错误码*/
  859.         if(len != 0)
  860.         {
  861.             *erro = 1;
  862.         }
  863.     }
  864.    

  866.     OSCriticalEnter();
  867.     /*如果缓冲区有数据而且当前串口没有处于发送状态要先发送一个字节触发发送中断流*/
  868.     if((p->state == HAL_UART_TXIDLE) && (p->tx_len!=0))
  869.     {
  870.         data = tx_fifo_out(p, erro);
  871.         if(*erro == 0)
  872.         {
  873.             if(p->tx_hook !=0)
  874.             {
  875.                 p->tx_hook();   /*调用准备发送回调函数*/
  876.             }
  877.             p->state = HAL_UART_TXBUSY; /*注意:p->state的读写需要临界保护*/
  878. #ifdef FM33A
  879.             HAL_UART_EnableTx(id,HAL_UART_INTERRUPT,HAL_UART_ENABLE);
  880.             HAL_UART_Send(p->id,data);   /*注意:必须放在使能TX后,否则使能TE会马上清除刚写如的数据,不产生中断 这里与k20等芯片不同*/
  881. #else
  882.             HAL_UART_Send(p->id,data);  /*注意:必须放在使能TX前,写TDR会清除TEND标志,否则使能TE会马上产生发送完中断*/
  883.             HAL_UART_EnableTx(id,HAL_UART_INTERRUPT,HAL_UART_ENABLE);      
  884. #endif
  885.         }
  886.     }
  887.     OSCriticalExit();
  888.     return sendlen;
  889. }

  891. /**
  892. *****************************************************************************
  893. * fn          int driver_uart_haverxdata(HAL_UART_ID_e id)
  894. * brief       读串口是否曾经接收到过数据.
  895. * note        应用调用该函数用于判断是否点亮接收指示灯.读会清除状态.
  896. * param[in]   id 指定的串口id.
  897. * retval      1 串口曾经有接收数据
  898. * retval      0 串口没有接收数据
  899. *****************************************************************************
  900. */
  901. int driver_uart_haverxdata(HAL_UART_ID_e id)
  902. {
  903.     unsigned char havedata=0;
  904.     if(driver_uart_tab[id]==0)
  905.     {
  906.         return 0;
  907.     }
  908.     havedata = driver_uart_tab[id]->rxhavedata;
  909.     driver_uart_tab[id]->rxhavedata =0;
  910.     return havedata;
  911. }

  913. /**
  914. *****************************************************************************
  915. * fn          int driver_uart_havetxdata(HAL_UART_ID_e id)
  916. * brief       读串口是否曾经发送过数据.
  917. * note        应用调用该函数用于判断是否点亮发送指示灯.读会清除状态.
  918. * param[in]   id 指定的串口id.
  919. * retval      1 串口曾经有发送数据
  920. * retval      0 串口没有发送数据
  921. *****************************************************************************
  922. */
  923. int driver_uart_havetxdata(HAL_UART_ID_e id)
  924. {
  925.     unsigned char havedata=0;
  926.     if(driver_uart_tab[id]==0)
  927.     {
  928.         return 0;
  929.     }
  930.     havedata = driver_uart_tab[id]->txhavedata;
  931.     driver_uart_tab[id]->txhavedata =0;
  932.     return havedata;
  933. }

  935. /**
  936. *****************************************************************************
  937. * fn          int driver_uart_geterr(HAL_UART_ID_e id,unsigned int* err)
  938. * brief       读串口错误状态字.
  939. * note        应用调用该函数用于判断串口是否异常,如果err的低三个字节有任意个字节为FF则表示异常需要处理.
  940. * param[in]   id 指定的串口id ref HAL_UART_ID_e .
  941. * param[out]  err 存储错误字
  942.                 0xxxxxxxFF表示校验错误  
  943.                 0xxxxxFFxx表示帧错误   
  944.                 0xxxFF00xx表示溢出错误  
  945. * retval      0 总是返回0
  946. *****************************************************************************
  947. */
  948. int driver_uart_geterr(HAL_UART_ID_e id,unsigned int* err)
  949. {
  950.     if(driver_uart_tab[id]==0)
  951.     {
  952.         return 0;
  953.     }
  954.     *err = driver_uart_tab[id]->err;
  955.     return 0;
  956. }

driver_uart.h
  1. #ifndef __DRIVER_UART_H
  2. #define __DRIVER_UART_H

  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif

  8. #include "hal_uart.h"
  9. /** addtogroup DRIVER 驱动层(DRIVER)
  10. *  {
  11. */
  12.          
  13. /** addtogroup DRIVER_UART 驱动层(DRIVER)串口模块(UART)
  14. *  {
  15. */
  16. /*****************************************************************************   
  17. *                                                                           *
  18. *                             数据结构描述                                  *
  19. *                                                                          *
  20. ****************************************************************************/
  21. /** defgroup DRIVER_UART_data 驱动层(DRIVER)串口模块(UART)数据结构
  22.   * {
  23.   */
  24.   
  25. #define UART0_ENABLE          1  /**< 通道0 使能 */
  26. #define UART4_ENABLE          1  /**< 通道4 使能 */
  27. #define UART9_ENABLE          1  /**< 通道9 使能 */

  29. #define DRIVER_UART0_TXBUF_SIZE 64       /**< UART0发送缓冲区大小  */   
  30. #define DRIVER_UART0_RXBUF_SIZE 128       /**< UART0接收缓冲区大小  */
  31. #define DRIVER_UART4_TXBUF_SIZE 64       /**< UART4发送缓冲区大小  */   
  32. #define DRIVER_UART4_RXBUF_SIZE 128       /**< UART4接收缓冲区大小  */
  33. #define DRIVER_UART9_TXBUF_SIZE 64       /**< UART9发送缓冲区大小  */   
  34. #define DRIVER_UART9_RXBUF_SIZE 128       /**< UART9接收缓冲区大小  */

  36. #define DRIVER_UART_DELAY_FIFO    (5)    /**< 缓冲区操作延时时间       */   
  37. #define DRIVER_UART_DELAY_CHECK   (1)      /**< 缓冲区延时查询时间间隔   */
  38. #define DRIVER_UART_DELAY_FRAME   (5)    /**< 字节间距大于该值认为帧结束   */
  39.          
  40. typedef void (*driver_uart_hook)(void);      /**< 发送/接收回调函数   */   

  42. /**
  43. * struct driver_uart_t
  44. * UART驱动配置结构体.
  45. */
  46. typedef struct
  47. {
  48.     HAL_UART_ID_e id;                 /**< UART id   */   
  49.     unsigned int rx_in;              /**< 接收缓冲区写入指针       */
  50.     unsigned int rx_out;             /**< 接收缓冲区读出指针       */
  51.     unsigned int rx_len;             /**< 接收缓冲区有效数据大小   */
  52.     unsigned int tx_in;              /**< 发送缓冲区写入指针       */
  53.     unsigned int tx_out;             /**< 发送缓冲区读出指针      */
  54.     unsigned int tx_len;             /**< 发送缓冲区有效数据大小   */
  55.     unsigned short rxbuf_len;        /**< 接收缓冲区大小           */   
  56.     unsigned short txbuf_len;        /**< 发送缓冲区大小          */
  57.     driver_uart_hook tx_hook;         /**< 准备发送回调函数          */
  58.     driver_uart_hook rx_hook;         /**< 发送完转接收回调函数          */
  59.     unsigned char *rx_buf;           /**< 接收缓冲区              */
  60.     unsigned char *tx_buf;           /**< 发送缓冲区                */
  61.     unsigned int bit_len;            /**< 用于发送完延时(有发送完中断不需要)    */
  62.     HAL_UART_TXSTATE_e state;         /**< 发送状态标志是否在发送                */
  63.     unsigned char rxhavedata;        /**< 是否有接收到数据                */
  64.     unsigned char txhavedata;        /**< 是否有发送数据                */
  65.     unsigned int err;                /**< 错误码计数器               */
  66. }driver_uart_t;


  69. /*****************************************************************************   
  70. *                                                                           *
  71. *                             模块数据定义                                  *
  72. *                                                                          *
  73. ****************************************************************************/

  75. #ifdef   DRIVER_UART_GLOBALS

  77. /*485方向控制回调函数:
  78.   按照一般需求最多8路串口这里实现8路,如果有更多路需求再添加即可
  79. */
  80. static void uart9_txhook(void);
  81. static void uart9_rxhook(void);
  82. static void uart4_txhook(void);
  83. static void uart4_rxhook(void);
  84. static void uart0_txhook(void);
  85. static void uart0_rxhook(void);

  87. static unsigned char driver_uart0_rxbuf[DRIVER_UART0_RXBUF_SIZE];
  88. static unsigned char driver_uart0_txbuf[DRIVER_UART0_TXBUF_SIZE];
  89. static unsigned char driver_uart4_rxbuf[DRIVER_UART4_RXBUF_SIZE];
  90. static unsigned char driver_uart4_txbuf[DRIVER_UART4_TXBUF_SIZE];
  91. static unsigned char driver_uart9_rxbuf[DRIVER_UART4_RXBUF_SIZE];
  92. static unsigned char driver_uart9_txbuf[DRIVER_UART4_TXBUF_SIZE];

  94. static driver_uart_t driver_uart0 = {HAL_UART_0, 0,0,0, 0,0,0, sizeof(driver_uart0_rxbuf), sizeof(driver_uart0_txbuf),uart0_txhook,uart0_rxhook,driver_uart0_rxbuf, driver_uart0_txbuf, 0,HAL_UART_TXIDLE,0,0};
  95. static driver_uart_t driver_uart4 = {HAL_UART_0, 0,0,0, 0,0,0, sizeof(driver_uart4_rxbuf), sizeof(driver_uart4_txbuf),uart4_txhook,uart4_rxhook,driver_uart4_rxbuf, driver_uart4_txbuf, 0,HAL_UART_TXIDLE,0,0};
  96. static driver_uart_t driver_uart9 = {HAL_UART_0, 0,0,0, 0,0,0, sizeof(driver_uart9_rxbuf), sizeof(driver_uart9_txbuf),uart9_txhook,uart9_rxhook,driver_uart9_rxbuf, driver_uart9_txbuf, 0,HAL_UART_TXIDLE,0,0};


  99. static driver_uart_t *driver_uart_tab[] = {&driver_uart0, 0, 0, 0, &driver_uart4, 0, 0, 0, 0, &driver_uart9};


  102. #endif

  104. /**
  105.   * }
  106.   */
  107. /*****************************************************************************   
  108. *                                                                           
  109. *                             接口函数描述                                   
  110. *                                                                           
  111. ****************************************************************************/

  113. /** defgroup DRIVER_UART_if 驱动层(DRIVER)串口模块(UART)接口
  114.   * {
  115.   */
  116.       
  117. /**
  118. *****************************************************************************
  119. * fn          unsigned int driver_uart_getrxlen(HAL_UART_ID_e id)
  120. * brief       获取接收缓冲区有效数据长度.
  121. * note        .
  122. * param[in]   id 串口id ref HAL_UART_ID_e
  123. * return      unsigned int 接收缓冲区长度
  124. *****************************************************************************
  125. */
  126. unsigned int driver_uart_getrxlen(HAL_UART_ID_e id);

  128. /**
  129. *****************************************************************************
  130. * fn          unsigned int driver_uart_flush(HAL_UART_ID_e id)
  131. * brief       清除缓冲区.
  132. * note        .
  133. * param[in]   id 串口id ref HAL_UART_ID_e
  134. * return      int 总是返回0
  135. *****************************************************************************
  136. */
  137. unsigned int driver_uart_flush(HAL_UART_ID_e id);

  139. /**
  140. *****************************************************************************
  141. * fn          int driver_uart_set(HAL_UART_CFG_t* cfg)
  142. * brief       配置串口参数.
  143. * note        .
  144. * param[in]   cfg 配置参数
  145. * return      int ref HAL_HWT_SetCfg() 的返回值
  146. *****************************************************************************
  147. */
  148. int driver_uart_set(HAL_UART_CFG_t* cfg);

  150. /**
  151. *****************************************************************************
  152. * fn          int driver_uart_recv(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len, unsigned int timeout, int *perro)
  153. * brief       串口接收指定长度数据,可以设置超时时间.
  154. * note        应用调用该函数接收数据,如果缓冲区无数据就等待.
  155. * param[in]   id 指定的串口id.
  156. * param[in]   pdata 需存储接收数据的缓冲区.
  157. * param[in]   len   接收的数据长度.
  158. * param[in]   timeout 设置为0表示一直等到接收到指定长度数据,设置为其他值表示等待指定超时时间(单位mS)
  159. * param[out]  perro 错误码 0表示成功 -1表示参数错误 1表示超时
  160. * return      int 返回实际读到的数据长度
  161. *****************************************************************************
  162. */
  163. unsigned int driver_uart_recv(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len, unsigned int timeout, int *erro);

  165. /**
  166. *****************************************************************************
  167. * fn          int driver_uart_send(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len,unsigned int timeout,int *perro)
  168. * brief       串口发送指定长度数据,可以设置超时时间.
  169. * note        应用调用该函数发送数据,如果缓冲区满就等待.
  170. * param[in]   id 指定的串口id.
  171. * param[in]   pdata 需要发送的数据缓冲区.
  172. * param[in]   len   需要发送的数据长度.
  173. * param[in]   timeout 设置为0表示一直等到全部写入缓冲区,设置为其他值表示等待指定超时时间(单位mS)
  174. * param[out]  perro 错误码 0表示成功 -1表示参数错误 1表示超时
  175. * return      int 返回实际发送的数据
  176. *****************************************************************************
  177. */
  178. int driver_uart_send(HAL_UART_ID_e id, unsigned char *pdata, unsigned int len,unsigned int timeout,int *erro);

  180. /**
  181. *****************************************************************************
  182. * fn          int driver_uart_haverxdata(HAL_UART_ID_e id)
  183. * brief       读串口是否曾经接收到过数据.
  184. * note        应用周期调用该函数用于判断是否点亮接收指示灯.读会清除状态.
  185. * param[in]   id 指定的串口id.
  186. * retval      1 串口曾经有接收数据
  187. * retval      0 串口没有接收数据
  188. *****************************************************************************
  189. */
  190. int driver_uart_haverxdata(HAL_UART_ID_e id);

  192. /**
  193. *****************************************************************************
  194. * fn          int driver_uart_havetxdata(HAL_UART_ID_e id)
  195. * brief       读串口是否曾经发送过数据.
  196. * note        应用周期调用该函数用于判断是否点亮发送指示灯.读会清除状态.
  197. * param[in]   id 指定的串口id.
  198. * retval      1 串口曾经有发送数据
  199. * retval      0 串口没有发送数据
  200. *****************************************************************************
  201. */
  202. int driver_uart_havetxdata(HAL_UART_ID_e id);

  204. /**
  205. *****************************************************************************
  206. * fn          int driver_uart_geterr(HAL_UART_ID_e id,unsigned int* err)
  207. * brief       读串口错误状态字.
  208. * note        应用调用该函数用于判断串口是否异常,如果err的低三个字节有任意个字节为FF则表示异常需要处理.
  209. * param[in]   id 指定的串口id ref HAL_UART_ID_e .
  210. * param[out]  err 存储错误字
  211.                 0xxxxxxxFF表示校验错误  
  212.                 0xxxxxFFxx表示帧错误   
  213.                 0xxxFF00xx表示溢出错误  
  214. * retval      0 总是返回0
  215. *****************************************************************************
  216. */
  217. int driver_uart_geterr(HAL_UART_ID_e id,unsigned int* err);
  218. /**
  219.   * }
  220.   */

  222. /**
  223.   * }
  224.   */

  226. /**
  227.   * }
  228.   */

  230. /**
  231.   * }
  232.   */

  234. #ifdef __cplusplus
  235. }
  236. #endif

  238. #endif



测试
上位机发送串口数据，板子收到后原样返回，测试是否完全一致。通过调整缓冲区大小和查询缓冲区的间隔，测试性能可以达到波特率对应的理想速度。
总结
以上介绍了串口模块，实现了比较健壮好用的串口驱动，为后续的开发打下了基础。

附件: 您需要登录才可以下载或查看附件。没有帐号？注册

更多回帖

0 0 0

相关帖子

RA4M2 RA4M2设计挑战赛
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分