设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › M0的串口问题
返回列表 发新帖
查看: 3072|回复: 1
打印 上一主题 下一主题
收起左侧

M0的串口问题

[复制链接]
跳转到指定楼层
楼主
ID:82781 发表于 2015-6-13 16:41 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
前天拿到的芯片，端口驱动没有问题，偏偏是串口出了问题，刚开始是没有开始端口复用，而昨天一整天我都在研究为什么可以接受到数据，但是数据是错误的，一整天，就是找不到程序中哪里出了问题，昨晚上睡觉之前就在思考，终究不能知道为什么，因为他的寄存器什么的我都没时间仔细研究，心想着今天来一个一个的研究，今早却灵光一现，今天起得特别早，因为还惦记这个问题，睡不着，为什么不看看硬件呢？我就来到加了一块串口驱动板，哈哈令人兴奋。电脑瞑目上闪现的数字和我期待的是一样的，嘎嘎，证明软件的配置昨天一天都是对的，只是没想到硬件出问题！哎！加油吧，总算是搞定串口发送了。虽然微不足道，但是也足以令我兴奋十天半月！


王均伟
日照高科园，FUCK!
注意：CPU时钟和HCLK时钟是单独的，相互独立，所以得要单独开启，他不同于STM32，他只有一个外设桥，没有DMA通道，相对
的外设资源也是相对匮乏的，但是相对于8位单片机他已经非常强大了！现在感觉和STM32的操作越来越像！
加油吧！


下面是APP和部分程序
  1. E_DRVGPIO_PIN sPinNumber; //枚举引脚
  2. STR_UART_T config;
  3. uint32_t start[10];
  4. /*---------------------------------------------------------------------------------------------------------*/
  5. /* MAIN function                                                                                          */
  6. /*---------------------------------------------------------------------------------------------------------*/   
  7. int main (void)
  8. {
  9. uint8_t tab[12]={6,5,6,7,8,9};
  10. uint8_t tab1[10];


  13. while(DrvSYS_SetOscCtrl(E_SYS_XTL12M, 1)!=0);//使能外部12MHZ晶振
  14.     while( DrvSYS_SelectHCLKSource(0) !=0);//HCLK选择外部12MHZ晶振
  15. while(DrvSYS_SelectSysTickSource(0)!=0);//选择系统嘀嗒时钟源为外部12MHZ晶振
  16.     DrvSYS_SetIPClock(E_SYS_UART0_CLK,1);//使能UART0时钟

  18.      while(DrvSYS_SetClockDivider(E_SYS_HCLK_DIV, 0)!=0); //1分频UART&HCLK
  19.      while(DrvSYS_SetClockDivider(E_SYS_UART_DIV, 0)!=0); //1分频UART&HCLK
  20.    DrvSYS_SelectIPClockSource(E_SYS_UART_CLKSRC, 0);//UART选择外部12Mhz的时钟源
  21.    DrvGPIO_InitFunction(E_FUNC_UART0);//复用IO编程UART模式
  22.      /*关闭所有串口中断*/
  23.    DrvUART_DisableInt(UART_PORT0,DRVUART_WAKEUPINT|DRVUART_RLSINT|DRVUART_BUFERRINT|DRVUART_MOSINT|DRVUART_THREINT|DRVUART_RDAINT|DRVUART_TOUTINT);

  25.     /*设置串口参数*/
  26.   config.u32BaudRate=9600;  //波特率9600
  27.   config.u8cDataBits=DRVUART_DATABITS_8 ;//数据位8位
  28.   config.u8cStopBits=DRVUART_STOPBITS_1; //停止位1位
  29.   config.u8cParity=DRVUART_PARITY_NONE ; //NONE校验
  30.   config.u8cRxTriggerLevel=DRVUART_FIFO_8BYTES;//接受FIFO 8字节
  31.         DrvUART_Open(UART_PORT0, &config);//开启UART端口
  32.        /*端口模式*/
  33.     DrvGPIO_Open(E_PORT3,E_PIN6, E_IO_OUTPUT);
  34. DrvGPIO_Open(E_PORT0,E_PIN0, E_IO_INPUT);//input


  37. sPinNumber=E_PIN6;

  39. while(1)
  40. {
  41. // _DRVUART_SENDBYTE(UART_PORT0,2);  

  43.    if(DrvGPIO_GetBit(E_PORT0,E_PIN0 )==0)
  44.    {
  45. DrvUART_Write(UART_PORT0,tab,3);
  46.    
  47.     DrvGPIO_ClrBit(E_PORT3,sPinNumber);
  48.   DrvSYS_Delay(500000);
  49. DrvGPIO_SetBit(E_PORT3, E_PIN6);
  50.         DrvSYS_Delay(500000);
  51.       
  52.       
  53.       }
  54. }

  56. }

  58. static void BaudRateCalculator(uint32_t clk, uint32_t baudRate, E_UART_PORT u32Port)
  59. {
  60.    int32_t tmp;
  61. int32_t div;
  62.    UART_T * tUART;
  63. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  64.     if ((((clk / baudRate)%16) < 2)  &&  (clk>(baudRate*16*2)))  /* Source Clock mod 16 < 2 => Using Divider X =16 (MODE#0) */
  65. {         
  66.   tUART->BAUD.DIV_X_EN = 0;
  67.      tUART->BAUD.DIV_X_ONE   = 0;
  68.   tmp = clk / baudRate/16  -2;
  69. }
  70. else         /* Source Clock mod 16 >2 => Up 5% Error BaudRate */
  71. {   
  72.      tUART->BAUD.DIV_X_EN = 1;     /* Try to Set Divider X = 1 (MODE#2)*/
  73.      tUART->BAUD.DIV_X_ONE   = 1;
  74.   tmp = clk / baudRate  -2;
  75.   if(tmp > 0xFFFF)     /* If Divider > Range  */
  76.   {
  77.    tUART->BAUD.DIV_X_EN = 1;    /* Try to Set Divider X up 10 (MODE#1) */
  78.    tUART->BAUD.DIV_X_ONE   = 0;
  79.    for(div = 8; div <16;div++)
  80.    {
  81.     if(((clk / baudRate)%(div+1))<3)
  82.     {
  83.      tUART->BAUD.DIVIDER_X   = div;
  84.      tmp = clk / baudRate / (div+1) -2;
  85.      break;
  86.     }
  87.    }
  88.   }
  89. }
  90. tUART->BAUD.BRD = tmp;
  91. }

  93. /*---------------------------------------------------------------------------------------------------------*/
  94. /* Function:     GetUartClk                                                                            */
  95. /*                                                                                                         */
  96. /* Parameter:                                */
  97. /*              clk            -[in] Uart Source Clock                                                */
  98. /*              baudRate       -[in] User seting BaudRate                                             */
  99. /*              UART_BAUD_T *baud  -[in] Get User Settings                                                */
  100. /* Returns:                                                                                                */
  101. /*               Current Uart Clock  (Hz)                                                                  */
  102. /* Description:                                                                                            */
  103. /*               The function is used to get Uart clock                                                    */
  104. /*---------------------------------------------------------------------------------------------------------*/
  105. static uint32_t GetUartClock(void)
  106. {
  107.     uint32_t clk =0 , div;
  108.     div = SYSCLK->CLKDIV.UART_N;                    /* According PLL Clock and UART_Divider to get clock */                                                
  109.                                                    
  110.                                                     /* Check UART Clock Source Setting */
  111.     if(SYSCLK->CLKSEL1.UART_S == 0)        
  112.     {
  113.         clk = DrvSYS_GetExtClockFreq()/ (div+1);;   /* Get External Clock From DrvSYS Setting */
  114.     }
  115.     else if(SYSCLK->CLKSEL1.UART_S == 1)
  116.     {
  117.         clk = DrvSYS_GetPLLClockFreq()/ (div+1);
  118.     }
  119.     else
  120.         clk = __IRC22M/ (div+1);                    /* Clock 22Mhz  */
  121.     return clk;
  122. }

  124. /*---------------------------------------------------------------------------------------------------------*/
  125. /* Function:     DrvUART_SetRTS                                                                   */
  126. /*                                                                                                         */
  127. /* Parameter:                                */
  128. /*     u32Port   -[in]   UART Channel:  UART_PORT0 / UART_PORT1                             */
  129. /*               uint8_t     -[in]   RTS Value                                 */
  130. /*                           Set 0: Drive RTS pin to logic 1 (If the LEV_RTS set to low level triggered).  */
  131. /*                                  Drive RTS pin to logic 0 (If the LEV_RTS set to high level triggered)  */
  132. /*                           Set 1: Drive RTS pin to logic 0 (If the LEV_RTS set to low level triggered)   */
  133. /*                                   Drive RTS pin to logic 1 (If the LEV_RTS set to high level triggered) */
  134. /*                           Note. Lev_RTS is RTS Trigger Level. 0 is low level and 1 is high level        */
  135. /*                                                                                                         */
  136. /*               u16TriggerLevel - [in]   RTS Trigger Level :DRVUART_FIFO_1BYTES to DRVUART_FIFO_62BYTES   */
  137. /* Returns:                                                                                                */
  138. /*               None                                                                                      */
  139. /*                                                                                                         */
  140. /* Description:                                                                                            */
  141. /*               The function is used to set RTS information                                            */
  142. /*---------------------------------------------------------------------------------------------------------*/
  143. void DrvUART_SetRTS(E_UART_PORT u32Port,uint8_t u8Value,uint16_t u16TriggerLevel)
  144. {

  146. UART_T * tUART;
  147. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  148. tUART->MCR.RTS = u8Value;
  149. tUART->FCR.RTS_TRI_LEV = u16TriggerLevel;
  150. }


  153. /*---------------------------------------------------------------------------------------------------------*/
  154. /* Function:     DrvUART_Open                                                                            */
  155. /*                                                                                                         */
  156. /* Parameter:                                */
  157. /*     u32Port -[in] UART Channel:  UART_PORT0 / UART_PORT1                                */
  158. /*               sParam  -[in] the struct parameter to configure UART                                      */
  159. /*                         include of                                                                      */
  160. /*                           * u32BaudRate - Baud rate                 */               
  161. /*                           * u8cParity   - DRVUART_PARITY_NONE / DRVUART_PARITY_EVEN / DRVUART_PARITY_ODD*/
  162. /*                           * u8cDataBits - DRVUART_DATA_BITS_5 / DRVUART_DATA_BITS_6         */
  163. /*               DRVUART_DATA_BITS_7 / DRVUART_DATA_BITS_8              */
  164. /*                           * u8cStopBits - DRVUART_STOPBITS_1 / STOPBITS_1_5 / STOPBITS_2         */
  165. /*                           * u8cRxTriggerLevel   - LEVEL_1_BYTE to LEVEL_62_BYTES                        */
  166. /*                           * u8TimeOut - Time out value                                           */
  167. /*                                                                                                         */
  168. /*                                                                                                         */
  169. /* Returns:                                                                                                */
  170. /*               E_DRVUART_ERR_PORT_INVALID                            */
  171. /*               E_DRVUART_ERR_PARITY_INVALID                                 */
  172. /*               E_DRVUART_ERR_DATA_BITS_INVALID                             */
  173. /*               E_DRVUART_ERR_STOP_BITS_INVALID                             */
  174. /*               E_DRVUART_ERR_TRIGGERLEVEL_INVALID                     */
  175. /*               E_DRVUART_ERR_ALLOC_MEMORY_FAIL                              */
  176. /*               E_SUCCESS                                                                              */
  177. /*                                                                                                         */
  178. /* Description:                                                                                            */
  179. /*               The function is used to initialize UART. It consists of baud-rate, parity, data-bits,     */
  180. /*               stop-bits, rx-trigger-level and timeout interval settings.                                */
  181. /*                                                                                                         */
  182. /*---------------------------------------------------------------------------------------------------------*/
  183. int32_t DrvUART_Open(E_UART_PORT u32Port, STR_UART_T *sParam)
  184. {
  185. UART_T * tUART;
  186.   
  187.     /*-----------------------------------------------------------------------------------------------------*/
  188.     /* Check UART port                                                                                     */
  189.     /*-----------------------------------------------------------------------------------------------------*/
  190.     if ((u32Port != UART_PORT0) &&
  191.         (u32Port != UART_PORT1))
  192.     {
  193.   return E_DRVUART_ERR_PORT_INVALID;
  194.     }

  196.     /*-----------------------------------------------------------------------------------------------------*/
  197.     /* Check the supplied parity                                                                           */
  198.     /*-----------------------------------------------------------------------------------------------------*/
  199.     if ((sParam->u8cParity != DRVUART_PARITY_NONE) &&
  200.         (sParam->u8cParity != DRVUART_PARITY_EVEN) &&
  201.         (sParam->u8cParity != DRVUART_PARITY_ODD)  &&
  202.         (sParam->u8cParity != DRVUART_PARITY_MARK) &&
  203.         (sParam->u8cParity != DRVUART_PARITY_SPACE))
  204.     {
  205.    return E_DRVUART_ERR_PARITY_INVALID;  
  206.     }
  207.     /*-----------------------------------------------------------------------------------------------------*/
  208.     /* Check the supplied number of data bits                                                              */
  209.     /*-----------------------------------------------------------------------------------------------------*/
  210.     else if ((sParam->u8cDataBits != DRVUART_DATABITS_5) &&
  211.              (sParam->u8cDataBits != DRVUART_DATABITS_6) &&
  212.              (sParam->u8cDataBits != DRVUART_DATABITS_7) &&
  213.              (sParam->u8cDataBits != DRVUART_DATABITS_8))
  214.     {
  215.    return E_DRVUART_ERR_DATA_BITS_INVALID;
  216.     }
  217.     /*-----------------------------------------------------------------------------------------------------*/
  218.     /* Check the supplied number of stop bits                                                              */
  219.     /*-----------------------------------------------------------------------------------------------------*/
  220.     else if ((sParam->u8cStopBits != DRVUART_STOPBITS_1) &&
  221.              (sParam->u8cStopBits != DRVUART_STOPBITS_2) &&
  222.              (sParam->u8cStopBits != DRVUART_STOPBITS_1_5)
  223.              )
  224.     {
  225.        return E_DRVUART_ERR_STOP_BITS_INVALID;
  226.     }

  228.     /*-----------------------------------------------------------------------------------------------------*/
  229.     /* Check the supplied nember of trigger level bytes                                                    */
  230.     /*-----------------------------------------------------------------------------------------------------*/
  231.     else if ((sParam->u8cRxTriggerLevel != DRVUART_FIFO_1BYTES) &&
  232.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_4BYTES) &&
  233.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_8BYTES) &&
  234.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_14BYTES)&&
  235.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_30BYTES)&&
  236.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_46BYTES)&&
  237.              (sParam->u8cRxTriggerLevel != DRVUART_FIFO_62BYTES))
  238.     {
  239.   return E_DRVUART_ERR_TRIGGERLEVEL_INVALID;  
  240.     }   
  241. if(u32Port == UART_PORT0)
  242. {
  243.   /* Reset IP */
  244.   SYS->IPRSTC2.UART0_RST = 1;
  245.   SYS->IPRSTC2.UART0_RST = 0;
  246.   
  247.   /* Enable UART clock */
  248.      SYSCLK->APBCLK.UART0_EN = 1;
  249. }
  250. else
  251. {
  252.   /* Reset IP */
  253.   SYS->IPRSTC2.UART1_RST = 1;
  254.   SYS->IPRSTC2.UART1_RST = 0;
  255.   
  256.   /* Enable UART clock */
  257.      SYSCLK->APBCLK.UART1_EN = 1;
  258. }
  259. tUART = (UART_T *)((uint32_t)UART0 + u32Port);

  261. /* Tx FIFO Reset & Rx FIFO Reset & FIFO Mode Enable */
  262.    tUART->FCR.TFR =1;
  263.    tUART->FCR.RFR =1;
  264. /* Set Rx Trigger Level */
  265. tUART->FCR.RFITL = sParam->u8cRxTriggerLevel;

  267. /* Set Parity & Data bits & Stop bits */
  268. tUART->LCR.SPE =((sParam->u8cParity)&0x4)?1:0;
  269. tUART->LCR.EPE =((sParam->u8cParity)&0x2)?1:0;
  270. tUART->LCR.PBE =((sParam->u8cParity)&0x1)?1:0;
  271.   
  272. tUART->LCR.WLS =sParam->u8cDataBits;
  273. tUART->LCR.NSB =sParam->u8cStopBits;
  274.   
  275. /* Set Time-Out */
  276. tUART->TOR.TOIC =sParam->u8TimeOut;
  277.     /* Check Clock Source */
  278.     if(SYSCLK->PWRCON.XTL12M_EN)
  279.         SYSCLK->CLKSEL1.UART_S = 0;
  280.     else
  281.     {
  282.         if(SYSCLK->PLLCON.PD==0)
  283.             SYSCLK->CLKSEL1.UART_S = 1;
  284.         else
  285.             if(SYSCLK->PWRCON.OSC22M_EN)
  286.                 SYSCLK->CLKSEL1.UART_S = 3;
  287.             else
  288.                 return E_DRVUART_ERR_OPEN;
  289.     }
  290. /* Set BaudRate */
  291. BaudRateCalculator(GetUartClock(), sParam->u32BaudRate, u32Port);
  292. return E_SUCCESS;
  293. }

  295. /*---------------------------------------------------------------------------------------------------------*/
  296. /* Function:        DrvUART_Close                                                                          */
  297. /*                                                                                                         */
  298. /* Parameters:                                                                                             */
  299. /*      u32Port   -[in] UART Channel:  UART_PORT0 / UART_PORT1                              */
  300. /* RETURN                                                                                                  */
  301. /*                  None                                                                                   */
  302. /* Description:                                                                                            */
  303. /*                  The function is used to disable UART clock, disable ISR and clear callback       */
  304. /*                  function pointer after checking the TX empty.                                          */
  305. /*---------------------------------------------------------------------------------------------------------*/
  306. void DrvUART_Close(E_UART_PORT u32Port)
  307. {
  308. if(u32Port == UART_PORT1)
  309. {
  310.   while(!UART1->FSR.TE_FLAG);
  311.   SYSCLK->APBCLK.UART1_EN = 0;
  312.   g_pfnUART1callback = NULL;
  313.          NVIC_DisableIRQ (UART1_IRQn);
  314. }
  315. else
  316. {
  317.   while(!UART0->FSR.TE_FLAG);
  318.   SYSCLK->APBCLK.UART0_EN = 0;
  319.   g_pfnUART0callback = NULL;
  320.         NVIC_DisableIRQ(UART0_IRQn);     
  321. }
  322. }

  324. /*---------------------------------------------------------------------------------------------------------*/
  325. /* Function:     DrvUART_EnableInt                                                                         */
  326. /*                                                                                                         */
  327. /* Parameter:                                                                                              */
  328. /*     u32Port    -[in] UART Channel:  UART_PORT0 / UART_PORT1                             */
  329. /*               u32InterruptFlag -[in] DRVUART_WAKEUPINT/DRVUART_RLSINT/DRVUART_BUFERRINT                 */
  330. /*          DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT      */
  331. /*               pfncallback      -[in] A function pointer for callback function                           */
  332. /* Returns:                                                                                                */
  333. /*               None                                                                                      */
  334. /* Description:                                                                                            */
  335. /*               The function is used to enable specified UART interrupt, install the callback             */
  336. /*               function and enable NVIC UART IRQ                                                         */
  337. /* Remark:                                                                                                 */
  338. /*               When enable DRVUART_THREINT interrupt source, the interrup will happen continouly if      */
  339. /*               TX_FIFO is empty. Remind you thant be careful to use it.                                  */
  340. /*               Please reference TRM to get more information.                                             */
  341. /*---------------------------------------------------------------------------------------------------------*/
  342. void
  343. DrvUART_EnableInt(
  344. E_UART_PORT   u32Port,
  345. uint32_t  u32InterruptFlag,
  346. PFN_DRVUART_CALLBACK pfncallback
  347. )
  348. {
  349. UART_T * tUART;
  350.    
  351. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  352. tUART->IER.RDA_IEN  =(u32InterruptFlag & DRVUART_RDAINT)?1:0 ;
  353. tUART->IER.THRE_IEN  =(u32InterruptFlag & DRVUART_THREINT)?1:0;
  354. tUART->IER.RLS_IEN  =(u32InterruptFlag & DRVUART_RLSINT)?1:0;
  355. tUART->IER.MODEM_IEN =(u32InterruptFlag & DRVUART_MOSINT)?1:0;
  356.   
  357. tUART->IER.TIME_OUT_EN =(u32InterruptFlag & DRVUART_TOUTINT)?1:0;    /* Time-out count enable */
  358. tUART->IER.RTO_IEN  =(u32InterruptFlag & DRVUART_TOUTINT)?1:0;  /* Time-out INT enable */
  359. tUART->IER.BUF_ERR_IEN =(u32InterruptFlag & DRVUART_BUFERRINT)?1:0;
  360. tUART->IER.WAKE_EN  =(u32InterruptFlag & DRVUART_WAKEUPINT)?1:0;
  361.     if(u32Port == UART_PORT0)               /* Install Callback function */
  362.     {
  363.   g_pfnUART0callback = pfncallback;      
  364.   NVIC_SetPriority(UART0_IRQn, (1<<__NVIC_PRIO_BITS) - 2);
  365.   NVIC_EnableIRQ(UART0_IRQn);
  366.     }
  367. else
  368. {
  369.   g_pfnUART1callback = pfncallback;
  370.   NVIC_SetPriority(UART1_IRQn, (1<<__NVIC_PRIO_BITS) - 2);
  371.   NVIC_EnableIRQ(UART1_IRQn);
  372. }
  373. }
  374.                  
  375. /*---------------------------------------------------------------------------------------------------------*/
  376. /* Function:     DrvUART_IsIntEnabled                                                                     */
  377. /*                                                                                                         */
  378. /* Parameter:                                                                                              */
  379. /*     u32Port       -[in] UART Channel:  UART_PORT0 / UART_PORT1                             */
  380. /*               u32InterruptFlag -[in] DRVUART_WAKEUPINT/DRVUART_RLSINT/DRVUART_BUFERRINT                 */
  381. /*          DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT      */
  382. /* Returns:                                                                                                */
  383. /*               Specified Interrupt Flag Set or clear                                                     */
  384. /* Description:                                                                                            */
  385. /*               The function is used to get the "interrupt enable" status           */
  386. /*---------------------------------------------------------------------------------------------------------*/
  387. uint32_t DrvUART_IsIntEnabled(E_UART_PORT u32Port,uint32_t u32InterruptFlag)
  388. {
  389. if(u32Port == UART_PORT0)     /* Read IER Register and check specified flag is enable */
  390.   return ((inpw(&UART0->IER) &
  391.    (u32InterruptFlag & (DRVUART_WAKEUPINT |DRVUART_BUFERRINT|
  392.      DRVUART_TOUTINT | DRVUART_MOSINT | DRVUART_RLSINT| DRVUART_THREINT | DRVUART_RDAINT))))?1:0;
  393. else
  394.   return ((inpw(&UART1->IER) &
  395.   (u32InterruptFlag & ( DRVUART_WAKEUPINT |DRVUART_BUFERRINT|
  396.      DRVUART_TOUTINT | DRVUART_MOSINT | DRVUART_RLSINT | DRVUART_THREINT | DRVUART_RDAINT))))?1:0;
  397. }

  399. /*---------------------------------------------------------------------------------------------------------*/
  400. /* Function:     DrvUART_DisableInt                                                                       */
  401. /*                                                                                                         */
  402. /* Parameter:                                                                                              */
  403. /*     u32Port       -[in] UART Channel:  UART_PORT0 / UART_PORT1                             */
  404. /*               u32InterruptFlag -[in] DRVUART_WAKEUPINT/DRVUART_RLSINT/DRVUART_BUFERRINT                 */
  405. /*          DRVUART_MOSINT/DRVUART_THREINT/DRVUART_RDAINT/DRVUART_TOUTINT      */
  406. /* Returns:                                                                                                */
  407. /*               None                                                                                      */
  408. /* Description:                                                                                            */
  409. /*               The function is used to disable UART specified interrupt, uninstall the call back         */
  410. /*               function and disable NVIC UART IRQ                                                        */
  411. /*---------------------------------------------------------------------------------------------------------*/
  412. void DrvUART_DisableInt(E_UART_PORT u32Port,uint32_t u32InterruptFlag)
  413. {
  414. if(u32Port == UART_PORT0)     
  415. {
  416.   outpw(&UART0->IER + u32Port,inpw(&UART0->IER + u32Port) &~u32InterruptFlag);    /* Disable INT  */
  417. }

  419. if(u32InterruptFlag & DRVUART_TOUTINT)             /* Disable Counter Enable */
  420. {
  421.   if(u32Port == UART_PORT0)
  422.    UART0->IER.RTO_IEN = 0;
  423.   else
  424.    UART1->IER.RTO_IEN = 0;
  425. }

  427. switch (u32Port)                /* Disable Callback function and NVIC */
  428.     {
  429.         case UART_PORT0:
  430.    g_pfnUART0callback = NULL;
  431.             NVIC_DisableIRQ(UART0_IRQn);  
  432.             break;
  433.         case UART_PORT1:
  434.    g_pfnUART1callback = NULL;
  435.             NVIC_DisableIRQ(UART1_IRQn);   
  436.             break;
  437.       
  438.         default:
  439.             break;
  440.     }
  441. }

  443. /*---------------------------------------------------------------------------------------------------------*/
  444. /* Function:     DrvUART_ClearIntFlag                                                                      */
  445. /*                                                                                                         */
  446. /* Parameter:                                                                                              */
  447. /*               u32Port              -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  448. /*               u32InterruptFlag     -[in]   Interrupt Flag : DRVUART_RLSINT_FLAG/DRVUART_MOSINT_FLAG     */
  449. /*                                                             DRVUART_BUFERRINT_FLAG                      */
  450. /* Returns:                                                                                                */
  451. /*               E_SUCCESS      Successful                                                                 */
  452. /* Description:                                                                                            */
  453. /*               The function is used to clear UART specified interrupt flag                               */
  454. /*                                                                                                         */
  455. /*---------------------------------------------------------------------------------------------------------*/
  456. uint32_t DrvUART_ClearIntFlag(E_UART_PORT u32Port,uint32_t u32InterruptFlag)
  457. {
  458.     UART_T * tUART;
  459.     tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  460.     if((u32InterruptFlag & DRVUART_RDAINT_FLAG)  ||
  461.        (u32InterruptFlag & DRVUART_THREINT_FLAG) ||
  462.        (u32InterruptFlag & DRVUART_TOUTINT_FLAG) )
  463.     {
  464.         return E_DRVUART_ARGUMENT;
  465.     }
  466.     if(u32InterruptFlag & DRVUART_RLSINT_FLAG)          /* clear Receive Line Status Interrupt */     
  467.     {
  468.         tUART->FSR.BIF = 1;
  469.         tUART->FSR.FEF = 1;
  470.         tUART->FSR.PEF = 1;
  471.     }
  472.     if(u32InterruptFlag & DRVUART_MOSINT_FLAG)          /* clear Modem Interrupt */   
  473.         tUART->MSR.DCTSF = 1;

  475.     if(u32InterruptFlag & DRVUART_BUFERRINT_FLAG)       /* clear Buffer ErrorInterrupt */     
  476.     {
  477.         tUART->FSR.TX_OVER_IF = 1;
  478.         tUART->FSR.RX_OVER_IF = 1;
  479.     }
  480.     return E_SUCCESS;
  481. }

  483. /*---------------------------------------------------------------------------------------------------------*/
  484. /* Function:     DrvUART_GetIntStatus                                                                     */
  485. /*                                                                                                         */
  486. /* Parameter:                                                                                              */
  487. /*     u32Port          -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  488. /*               u32InterruptFlag     -[in]   DRVUART_LININT_FLAG / DRVUART_BUFERRINT_FLAG           */
  489. /*             DRVUART_TOUTINT_FLAG/DRVUART_MOSINT_FLAG                     */
  490. /*                                            DRVUART_RLSINT_FLAG/DRVUART_THREINT_FLAG/DRVUART_RDAINT_FLAG */
  491. /*                                                                                                         */
  492. /* Returns:                                                                                                */
  493. /*               0: The specified interrupt is not happened.                                               */
  494. /*               1: The specified interrupt is happened.                                                   */
  495. /*               E_DRVUART_ARGUMENT: Error Parameter                                                       */
  496. /* Description:                                                                                            */
  497. /*               The function is used to get the interrupt status             */
  498. /*---------------------------------------------------------------------------------------------------------*/
  499. int32_t DrvUART_GetIntStatus(E_UART_PORT u32Port,uint32_t u32InterruptFlag)
  500. {
  501. UART_T * tUART;
  502. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  503.   
  504.     return (tUART->u32ISR & u32InterruptFlag)>>u32InterruptFlag ;
  505. }

  507. /*---------------------------------------------------------------------------------------------------------*/
  508. /* Function:     DrvUART_GetCTSInfo                                                               */
  509. /*                                                                                                         */
  510. /* Parameter:                                */
  511. /*     u32Port          -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  512. /*               pu8CTSValue       -[out]   Buffer to store the CTS Value                          */
  513. /*                                             return current CTS pin state                                */
  514. /*     pu8CTSChangeState   -[out]   Buffer to store the CTS Change State                        */
  515. /*                                             return CTS pin status is changed or not 1:Changed 0:Not yet */
  516. /* Returns:                                                                                                */
  517. /*               None                                                                                      */
  518. /* Description:                                                                                            */
  519. /*               The function is used to get CTS pin value and detect CTS change state                     */
  520. /*---------------------------------------------------------------------------------------------------------*/
  521. void DrvUART_GetCTS(E_UART_PORT u32Port,uint8_t *pu8CTSValue, uint8_t *pu8CTSChangeState)
  522. {
  523. UART_T * tUART;
  524. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  525.   *pu8CTSValue   = tUART->MSR.CTS_ST;
  526. *pu8CTSChangeState  = tUART->MSR.DCTSF;
  527. }

  529. /*---------------------------------------------------------------------------------------------------------*/
  530. /* Function:     DrvUART_Read                                                                              */
  531. /*                                                                                                         */
  532. /* Parameter:                                                                                              */
  533. /*     u32Port             -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  534. /*               pu8RxBuf       -[in]   Specify the buffer to receive the data of receive FIFO       */
  535. /*               u32ReadBytes      -[in]   Specify the bytes number of data.                      */
  536. /* Returns:                                                                                                */
  537. /*               E_SUCCESS                                                                              */
  538. /* Description:                                                                                            */
  539. /*               The function is used to read Rx data from RX FIFO and the data will be stored in pu8RxBuf */
  540. /*---------------------------------------------------------------------------------------------------------*/
  541. int32_t DrvUART_Read(E_UART_PORT u32Port,uint8_t *pu8RxBuf, uint32_t u32ReadBytes)
  542. {
  543.     uint32_t  u32Count, u32delayno;
  544. UART_T * tUART;
  545. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  546.     for (u32Count=0; u32Count < u32ReadBytes; u32Count++)
  547.     {
  548.    u32delayno = 0;
  549.       while (tUART->FSR.RX_EMPTY ==1)         /* Check RX empty => failed */   
  550.       {
  551.        u32delayno++;      
  552.          if ( u32delayno >= 0x40000000 )      
  553.           return E_DRVUART_ERR_TIMEOUT;              
  554.          }
  555.          pu8RxBuf[u32Count] = tUART->DATA;         /* Get Data from UART RX  */
  556.     }
  557.     return E_SUCCESS;

  559. }

  561. /*---------------------------------------------------------------------------------------------------------*/
  562. /* Function:     DrvUART_Write                                                                            */
  563. /*                                                                                                         */
  564. /* Parameter:                                                                                              */
  565. /*     u32Port             -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  566. /*               pu8RxBuf       -[in]   Specify the buffer to send the data to transmission FIFO.    */
  567. /*               u32ReadBytes      -[in]   Specify the byte number of data.                          */
  568. /* Returns:                                                                                                */
  569. /*               E_SUCCESS                                                                              */
  570. /*                                                                                                         */
  571. /* Description:                                                                                            */
  572. /*               TThe function is to write data to TX buffer to transmit data by UART                      */
  573. /* Note:                                                                                                   */
  574. /*               In IrDA Mode, the BAUD RATE configure MUST to use MODE # 0                                */
  575. /*---------------------------------------------------------------------------------------------------------*/
  576. int32_t DrvUART_Write(E_UART_PORT u32Port,uint8_t *pu8TxBuf,  uint32_t u32WriteBytes)
  577. {
  578.     uint32_t  u32Count, u32delayno;
  579. UART_T * tUART;
  580. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  581.     for (u32Count=0; u32Count<u32WriteBytes; u32Count++)
  582.     {
  583.        u32delayno = 0;
  584.     while (tUART->FSR.TE_FLAG !=1)           /* Wait Tx empty and Time-out manner */
  585.        {
  586.             u32delayno++;
  587.             if ( u32delayno >= 0x40000000 )         
  588.                return E_DRVUART_ERR_TIMEOUT;            
  589.       
  590.        }
  591.     tUART->DATA =pu8TxBuf[u32Count];      /* Send UART Data from buffer */
  592.     }
  593.     return E_SUCCESS;


  596. }

  598. /*---------------------------------------------------------------------------------------------------------*/
  599. /* Function:     DrvUART_SetFnIRDA                                                                         */
  600. /*                                                                                                         */
  601. /* Parameter:                                                                                              */
  602. /*     u32Port          -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  603. /*               STR_IRCR_T       -[in]   Ther stucture of IRCR                                */
  604. /*                                            It includes of                                               */
  605. /*                                               u8cTXSelect: 1: Enable Irda transmit function.(TX mode)   */
  606. /*                                                            0: Disable Irda transmit function.(RX mode)  */
  607. /*                                               u8cInvTX: Inverse TX signal                               */
  608. /*                                               u8cInvRX: Inverse RX signal                               */
  609. /*                                                                                                         */
  610. /* Returns:                                                                                                */
  611. /*               None                                                                                    */
  612. /*                                                                                                         */
  613. /* Description:                                                                                            */
  614. /*               The function is used to configure IRDA relative settings.                                 */
  615. /*               It consists of TX or RX mode and Inverse TX or RX signals.                                */
  616. /*---------------------------------------------------------------------------------------------------------*/
  617. void DrvUART_SetFnIRDA(E_UART_PORT u32Port,STR_IRCR_T *str_IRCR )
  618. {
  619. UART_T * tUART;
  620. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  621. tUART->FUNSEL.FUN_SEL  = FUN_IRCR;           /* Enable IrDA function and configure */
  622. tUART->IRCR.TX_SELECT = (str_IRCR->u8cTXSelect) ?1:0;
  623. tUART->IRCR.INV_TX  = str_IRCR->u8cInvTX ;
  624. tUART->IRCR.INV_RX  = str_IRCR->u8cInvRX ;
  625. }

  627. /*---------------------------------------------------------------------------------------------------------*/
  628. /* Function:     DrvUART_SetFnRS485                                                                        */
  629. /*                                                                                                         */
  630. /* Parameter:                                                                                              */
  631. /*     u32Port             -[in]   UART Channel:  UART_PORT0 / UART_PORT1                       */
  632. /*               STR_RS485_T       -[in]   Ther stucture of RS485                                */
  633. /*                                            It includes of                                               */
  634. /*                                               u8cModeSelect: MODE_RS485_AUD / MODE_RS485_AAD            */
  635. /*                                                              MODE_RS485_NMM                             */
  636. /*                                               u8cAddrEnable: Enable or Disable RS-485 Address Detection */
  637. /*                                               u8cAddrValue:  Match Address Value                        */
  638. /*                                               u8cDelayTime:  Set transmit delay time value              */
  639. /*                                               u8cRxDisable:  Enable or Disable receiver function        */
  640. /* Returns:                                                                                                */
  641. /*               None                                                                                   */
  642. /*                                                                                                         */
  643. /* Description:                                                                                            */
  644. /*               The function is to Set RS485 Control Register                                             */
  645. /*---------------------------------------------------------------------------------------------------------*/
  646. void DrvUART_SetFnRS485(E_UART_PORT u32Port,STR_RS485_T *str_RS485)
  647. {

  649. UART_T * tUART;
  650. tUART = (UART_T *)((uint32_t)UART0 + u32Port);
  651. tUART->FUNSEL.FUN_SEL    = FUN_RS485;     /* Enable RS485 function and configure */
  652. tUART->ALTCON.RS485_ADD_EN     =  str_RS485-> u8cAddrEnable ?1:0;
  653. tUART->ALTCON.ADDR_MATCH  =  str_RS485-> u8cAddrValue ;
  654. tUART->ALTCON.RS485_NMM      = (str_RS485-> u8cModeSelect & MODE_RS485_NMM)?1:0;
  655. tUART->ALTCON.RS485_AAD      = (str_RS485-> u8cModeSelect & MODE_RS485_AAD)?1:0;
  656. tUART->ALTCON.RS485_AUD      = (str_RS485-> u8cModeSelect & MODE_RS485_AUD)?1:0;
  657. tUART->TOR.DLY                  =  str_RS485-> u8cDelayTime;
  658. tUART->FCR.RX_DIS               =  str_RS485-> u8cRxDisable;
  659. tUART->MCR.LEV_RTS = 0;

  661. }
  662. /*---------------------------------------------------------------------------------------------------------*/
  663. /* Function:     DrvUART_GetVersion                                                                        */
  664. /*                                                                                                         */
  665. /* Parameter:                                */
  666. /*              None                                                                                     */
  667. /* Returns:                                                                                                */
  668. /*               Version Number                                                                            */
  669. /* Side effects:                                                                                           */
  670. /*                                                                                                         */
  671. /* Description:                                                                                            */
  672. /*               The function is used to get  DrvUART Version Number                                       */
  673. /*---------------------------------------------------------------------------------------------------------*/
  674. int32_t DrvUART_GetVersion(void)
  675. {
  676. return DRVUART_VERSION_NUM;

  678. }
复制代码




分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:82781 发表于 2015-6-13 16:41 | 只看该作者
使用串口终端的时候，开启端口之后，必须开启端口之后才可以安装IRQ和回调函数。回调函数包含一个状态码，在函数中只要判断这个状态不等于NULL，就可以进行处理。最好设置一个全局标志位，标志接受的数据是否完成，每次接受都会进入，系统自动清除，要认清他的这个特性，确保中断的有效性！总之，又中断就用，尽量保证实时性！
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表