开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
LPC_Uart.c
资源名称：LPC2148_IAR_LPC2148.zip　[点击查看]
上传用户：sourcesun
上传日期：2013-09-23
资源大小：362k
文件大小：14k
源码类别：

DNA

开发平台：

Asm

LPC_Uart.c：源码内容
  1. /*************************************************************************
  2.  *
  3.  *    Used with ICCARM and AARM.
  4.  *
  5.  *    (c) Copyright IAR Systems 2003
  6.  *
  7.  *    File name   : LPC_Uart.c
  8.  *    Description : Define API for UART
  9.  *
  10.  *    History :
  11.  *    1. Data: July 13, 2004                                              
  12.  *       Author: Shawn Zhang                                                    
  13.  *       Description: Create the basic function    
  14.  *
  15.  *    2. Data: August 09, 2004                                              
  16.  *       Author: Shawn Zhang                                                    
  17.  *       Description: Integrate two method :- by polling and by interrupt, user 
  18.  *          could select it.
  19.  *
  20.  *    3. Data: August 17, 2004                                              
  21.  *       Author: Shawn Zhang                                                    
  22.  *       Description:  1) Repair the bug about Tx ring buffer.
  23.  *           2) Repair the bug about ReadTxBuf function and ISR.
  24.  *
  25.  *    4. Data        : Oct 9, 2004 
  26.  *       Author      : Stanimir Bonev
  27.  *       Description : Modify some function and interface  
  28.  *
  29.  *    $Revision: 1.1 $
  30.  **************************************************************************/
  32. #include "LPC_Uart.h"
  34. // Define globe variable
  35. LPC_Uart_Config_t Uart0Config = {BD9600, WordLength8, false, false, ParitySelOdd, 
  36.           false, true, FIFORXLEV2, IER_RBR | IER_RLS,
  37.           INTERRUPT_MODE,};
  38.               
  39. LPC_Uart_Config_t Uart1Config = {BD9600, WordLength8, false, false, ParitySelOdd, 
  40.           false, true, FIFORXLEV2, IER_RBR | IER_RLS,
  41.           INTERRUPT_MODE,};
  43. /*************************************************************************
  44.  * Function Name: UART_InitUartBuf
  45.  * Parameters: LPC_Uart_Buffer_t *pUartBuf
  46.  * Return: void
  47.  *
  48.  * Description: Initialize Rx & Tx buffer, which is used when adopting interrupt method
  49.  *  
  50.  *************************************************************************/
  51. void UART_InitUartBuf (LPC_Uart_Buffer_t *pUartBuf)
  52. {
  53.   pUartBuf->RxHeadPoint=0;
  54.   pUartBuf->RxTailPoint=0;
  55.   
  56.   pUartBuf->TxHeadPoint=0;
  57.   pUartBuf->TxTailPoint=0;
  59.   pUartBuf->RxCount=0;
  60.   pUartBuf->TxCount=0;
  62.   pUartBuf->RxFlag=0;
  63. }
  64.               
  65. /*************************************************************************
  66.  * Function Name: UART_Init
  67.  * Parameters: LPC_UartChanel_t DevNum
  68.  *      
  69.  * Return: int 
  70.  *              0: sucess
  71.  *    1: fail
  72.  * Description: Initialize Uart, configure baut rate, frame format and FIFO
  73.  *  
  74.  *************************************************************************/
  75. int UART_Init (LPC_UartChanel_t DevNum)
  76. {
  77. unsigned long Divisor, Frame, FIFO;
  78. LPC_Uart_Config_t *pConfig;
  80.   if ( DevNum == UART0 )
  81.     pConfig = &Uart0Config;
  82.   else
  83.     pConfig = &Uart1Config;
  85.   if ((pConfig->BaudRate == 0) || (pConfig->BaudRate > BD115200))
  86.     return 0;
  88.   // baut rate
  89.   Divisor = (SYS_GetFpclk() >>4) / pConfig->BaudRate; // Divisor = pclk / (16*bautrate)
  91.   // frame format
  92.   Frame = pConfig->WordLenth;
  93.   if ( pConfig->TwoStopBitsSelect )
  94.     Frame |= ( 1<<LCR_STOPBITSEL_BIT );
  95.   if ( pConfig->ParityEnable )
  96.   {
  97.     Frame |= ( 1<<LCR_PARITYENBALE_BIT );
  98.     Frame |= ( pConfig->ParitySelect<<LCR_PARITYSEL_BIT );
  99.   }
  100.   if ( pConfig->BreakEnable )
  101.     Frame |= ( 1<<LCR_BREAKCONTROL_BIT );
  103.   // FIFO
  104.   if ( pConfig->FIFOEnable )
  105.     FIFO = ((pConfig->FIFORxTriggerLevel & 0x3)<<6) | 0x1;
  107.   // Method Mode
  108.   if ( pConfig->MethodMode == INTERRUPT_MODE )
  109.     UART_InitUartBuf (&pConfig->UartBuffer);
  110.   if ( DevNum == UART0 )
  111.   {
  112.     // Set baut rate
  113.     U0LCR_bit.DLAB = true;  // DLAB = 1
  114.     U0DLM = Divisor >> 8;
  115.     U0DLL = Divisor;
  117.     // Set frame format
  118.     U0LCR = Frame;          // DLAB = 0
  120.     // Set FIFO
  121.     U0FCR = FIFO;
  123.     // Set Interrupt Enable Register
  124.     U0IER = pConfig->InterruptEnable & 0x5;
  126.     // Enable TxD0 and RxD0, bit 0~3=0101
  127. //    PINSEL0 |= 0x05;
  128.     PINSEL0_bit.P0_0 = 0x1;
  129.     PINSEL0_bit.P0_1 = 0x1;
  130.   }
  131.   else if ( DevNum == UART1 )
  132.   {
  133.     // Set baut rate
  134.     U1LCR_bit.DLAB = true;      // DLAB = 1
  135.     U1DLM = Divisor>>8;
  136.     U1DLL = Divisor & 0xff;
  138.     // Set frame format
  139.     U1LCR = Frame;              // DLAB =0
  141.     /* Set FIFO */
  142.     U1FCR = FIFO;
  144.     // Set Interrupt Enable Register
  145.     U1IER = pConfig->InterruptEnable & 0x5;
  147.     // Enable TxD0 and RxD0, bit 16~19=0101
  148. //    PINSEL0 |= 0x50000;
  149.     PINSEL0_bit.P0_8 = 0x1;
  150.     PINSEL0_bit.P0_9 = 0x1;
  151.   }
  152.   else
  153.     return 1;
  154.   return 0;
  155. }
  158. /*************************************************************************
  159.  * Function Name: UART_PutCharByPolling
  160.  * Parameters: LPC_UartChanel_t DevNum
  161.  *         char ch
  162.  * Return: void
  163.  *
  164.  *
  165.  * Description: Send character by polling LSR register
  166.  *  
  167.  *************************************************************************/
  168. void UART_PutCharByPolling (LPC_UartChanel_t DevNum, char ch)
  169. {
  170.   if ( DevNum == UART0 )
  171.   {
  172.     while(!U0LSR_bit.THRE);
  173.     U0THR = ch;
  174.   }
  175.   else
  176.   {
  177.     while(!U1LSR_bit.THRE);
  178.     U1THR = ch;
  179.   }
  180. }
  182. /*************************************************************************
  183.  * Function Name: UART_PutStringByPolling
  184.  * Parameters: LPC_UartChanel_t DevNum
  185.  *         char *Buf
  186.  * Return: int : send character count
  187.  *
  188.  *
  189.  * Description: Send a string by using polling method 
  190.  *  
  191.  *************************************************************************/
  192. int UART_PutStringByPolling(LPC_UartChanel_t DevNum, char *Buf)
  193. {
  194. char *pBuf = Buf ;
  195. int SendCount = 0;
  196.   while (*pBuf)
  197.   {
  198.     UART_PutCharByPolling(DevNum, *pBuf++);
  199.     ++SendCount;
  200.   }
  201.   return (SendCount);
  202. }
  204. /*************************************************************************
  205.  * Function Name: UART_GetCharByPolling
  206.  * Parameters: LPC_UartChanel_t DevNum
  207.  * Return: char 
  208.  *
  209.  * Description: Receive a character from Uart by polling LSR register
  210.  *  
  211.  *************************************************************************/
  212. char UART_GetCharByPolling (LPC_UartChanel_t DevNum)
  213. {
  214.   if ( DevNum == UART0 )
  215.   {
  216.     while (!U0LSR_bit.DR);
  217.     return (U0RBR);
  218.   }
  219.   while (!U1LSR_bit.DR);
  220.   return (U1RBR);
  221. }
  223. /*************************************************************************
  224.  * Function Name: UART_PutStringByInterrupt
  225.  * Parameters: LPC_UartChanel_t DevNum
  226.  *         char *Buf
  227.  * Return: int : send character count
  228.  *
  229.  * Description: Send a string into Uart Buffer. 
  230.  *    Then Uart will send buffer data in its IRQ subroutine.
  231.  *  
  232.  *************************************************************************/
  233. int UART_PutStringByInterrupt (LPC_UartChanel_t DevNum, char *Buf)
  234. {
  235. char *pBuf = Buf, ch;
  236. LPC_Uart_Buffer_t *pUartBuf;
  237. int SendCount = 0;
  238. unsigned long IntFlagsHold;
  240.   if ( DevNum == UART0 )
  241.     pUartBuf = &Uart0Config.UartBuffer;
  242.   else
  243.     pUartBuf = &Uart1Config.UartBuffer;
  244.   while (*pBuf)
  245.   {
  246.     // if FIFO is full pending here, wait for send characters
  247.     if (pUartBuf->TxCount >= TXBUFSIZE)
  248.     {
  249.       break;
  250.     }
  251.     ch = *pBuf & 0xff;    
  252.     pUartBuf->TxBuf[pUartBuf->TxTailPoint] = ch;
  253.     pUartBuf->TxTailPoint = (pUartBuf->TxTailPoint+1)%TXBUFSIZE;
  254.     IntFlagsHold = disable_IRQ();
  255.     pUartBuf->TxCount++;
  256.     restore_IRQ(IntFlagsHold);
  257.     SendCount++;
  258.     pBuf++;
  259.   }
  260.   if (DevNum == UART0)
  261.     U0IER |= IER_THRE;
  262.   else
  263.     U1IER |= IER_THRE;
  264.   return SendCount;
  265. }
  267. /*************************************************************************
  268.  * Function Name: UART_GetCharByInterrupt
  269.  * Parameters:  LPC_UartChanel_t DevNum, char *ch
  270.  * Return:  0 -  Rx FIFO is empty 
  271.  *          1 - valid char
  272.  * Description: Get character from Uart Port by making use of interrupt. At same time,
  273.  *    the received data will be stored into its buffer.
  274.  *  
  275.  *************************************************************************/
  276. char UART_GetCharByInterrupt (LPC_UartChanel_t DevNum, char* Buf)
  277. {
  278. LPC_Uart_Buffer_t *pUartBuf;
  279. unsigned long IntFlagsHold;
  280.   if (DevNum == UART0)
  281.   {
  282.     pUartBuf = &Uart0Config.UartBuffer;
  283.   }
  284.   else
  285.   {
  286.     pUartBuf = &Uart1Config.UartBuffer;
  287.   }
  288.   if (pUartBuf->RxCount == 0)
  289.     return 0;
  290.   *Buf = pUartBuf->RxBuf[pUartBuf->RxHeadPoint];
  291.   pUartBuf->RxHeadPoint = (pUartBuf->RxHeadPoint+1)%RXBUFSIZE;
  292.   IntFlagsHold = disable_IRQ();
  293.   pUartBuf->RxCount--;
  294.   restore_IRQ(IntFlagsHold);
  295.   return 1;
  296. }
  298. /*************************************************************************
  299.  * Function Name: UART_PutString
  300.  * Parameters: LPC_UartChanel_t DevNum
  301.  *         char *Buf
  302.  * Return: int : send character count
  303.  *
  304.  *
  305.  * Description: Send a string 
  306.  *  
  307.  *************************************************************************/
  308. int UART_PutString(LPC_UartChanel_t DevNum, char *Buf)
  309. {
  310. LPC_Uart_MethodMode_t MethodMode;
  311.   if ( DevNum == UART0 )
  312.     MethodMode = Uart0Config.MethodMode;
  313.   else
  314.     MethodMode = Uart1Config.MethodMode;
  316.   if (MethodMode)
  317.     // interrupt method
  318.     return(UART_PutStringByInterrupt(DevNum, Buf));
  319.   // Polling method
  320.   return(UART_PutStringByPolling(DevNum, Buf));
  321. }
  323. /*************************************************************************
  324.  * Function Name: UART_GetChar
  325.  * Parameters: LPC_UartChanel_t DevNum
  326.  *
  327.  * Return: char 
  328.  *
  329.  * Description: Receive a character from Uart.
  330.  *  
  331.  *************************************************************************/
  332. char UART_GetChar(LPC_UartChanel_t DevNum)
  333. {
  334. LPC_Uart_MethodMode_t MethodMode;
  335. char ch;
  336.   if ( DevNum == UART0 )
  337.     MethodMode = Uart0Config.MethodMode;
  338.   else
  339.     MethodMode = Uart1Config.MethodMode;
  341.   if (MethodMode)
  342.   {
  343.     // interrupt method
  344.     while(!UART_GetCharByInterrupt(DevNum,&ch));
  345.     return(ch);
  346.   }
  347.   // Polling method
  348.   return(UART_GetCharByPolling(DevNum));
  349. }
  351. /*************************************************************************
  352.  * Function Name: UART_ReadTxBuf
  353.  * Parameters: LPC_Uart_Buffer_t *pUartBuf
  354.  *         char *ch
  355.  * Return: int : 1 one character or more
  356.  *     0 no character in buffer, means current Txcount = 0
  357.  *
  358.  * Description: Read a character from to Uart Buffer, which is only used by IRQ subroutine.
  359.  *  
  360.  *************************************************************************/
  361. #pragma inline
  362. static int UART_ReadTxBuf (LPC_Uart_Buffer_t *pUartBuf, char *ch)
  363. {
  364.   if (pUartBuf->TxCount == 0)
  365.     return 0;
  366.   *ch = pUartBuf->TxBuf[pUartBuf->TxHeadPoint];
  367.   pUartBuf->TxHeadPoint = (pUartBuf->TxHeadPoint+1)%TXBUFSIZE;
  368.   pUartBuf->TxCount--;
  369.   return 1;
  370. }
  372. /*************************************************************************
  373.  * Function Name: UART0_ISR
  374.  * Parameters: void
  375.  * Return: void
  376.  *
  377.  * Description: Uart0 interrupt subroutine
  378.  *  
  379.  *************************************************************************/
  380. void UART0_ISR (void)
  381. {
  382. int i;
  383. char temp;
  384. LPC_Uart_Buffer_t *pUartBuf = &Uart0Config.UartBuffer;
  385.   switch((U0IIR>>1)&0x7)
  386.   {
  387.   case IIR_THRE:  // continue sending data
  388.     // Check for Transmitter FIFO enable
  389.     if (Uart0Config.FIFOEnable) 
  390.       // when FIFO is enable load FIFODEEP bytes
  391.       i = FIFODEEP;
  392.     else
  393.       // when FIFO is disable load 1 byte
  394.       i = 1;
  395.     do
  396.     {
  397.       // Check for software FIFO state and load data into transmitter hold register
  398.       // disable interups imediatly aftre write when FIFO is empty
  399.       if(!UART_ReadTxBuf(pUartBuf, (char*)&U0THR) || (pUartBuf->TxCount == 0))
  400.       {
  401.         // Disable interrup when FIFO is empty
  402.         U0IER_bit.THREIE = false;
  403.         break;
  404.       }
  405.     }
  406.     while(--i);
  407.     break;
  408.   case IIR_RSL: // error manage
  409.     temp = U0LSR;
  410.     pUartBuf->RxFlag |= temp & 0x9E;
  411.     break;
  412.   case IIR_RDA: // receive data
  413.   case IIR_CTI: // time out
  414.     pUartBuf->RxBuf[pUartBuf->RxTailPoint] = U0RBR;
  415.     pUartBuf->RxTailPoint = (pUartBuf->RxTailPoint+1)%RXBUFSIZE;
  416.     // overflow
  417.     if (++pUartBuf->RxCount > RXBUFSIZE)
  418.     {
  419.       pUartBuf->RxHeadPoint = pUartBuf->RxTailPoint;
  420.       pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;
  421.     }
  422.     break;
  423.   default:
  424.     break;
  425.   }
  426.   VICVectAddr = 0;    // Clear interrupt in VIC.
  427. }
  429. /*************************************************************************
  430.  * Function Name: UART1_ISR
  431.  * Parameters: void
  432.  * Return: void
  433.  *
  434.  * Description: Uart1 interrupt subroutine
  435.  *  
  436.  *************************************************************************/
  437. void UART1_ISR (void)
  438. {
  439. int i;
  440. char temp;
  441. LPC_Uart_Buffer_t *pUartBuf = &Uart1Config.UartBuffer;
  442.   switch((U1IIR>>1)&0x7)
  443.   {
  444.   case IIR_THRE:  // continue sending data
  445.     // Check for Transmitter FIFO enable
  446.     if (Uart1Config.FIFOEnable) 
  447.       // when FIFO is enable load FIFODEEP bytes
  448.       i = FIFODEEP;
  449.     else
  450.       // when FIFO is disable load 1 byte
  451.       i = 1;
  452.     do
  453.     {
  454.       // Check for software FIFO state and load data into transmitter hold register
  455.       // disable interups imediatly aftre write when FIFO is empty
  456.       if(!UART_ReadTxBuf(pUartBuf, (char*)&U1THR) || (pUartBuf->TxCount == 0))
  457.       {
  458.         // Disable interrup when FIFO is empty
  459.         U1IER_bit.THREIE = false;
  460.         break;
  461.       }
  462.     }
  463.     while(--i);
  464.     break;
  465.   case IIR_RSL: // error manage
  466.     temp = U1LSR;
  467.     pUartBuf->RxFlag |= temp & 0x9E;
  468.     break;
  469.   case IIR_RDA: // receive data
  470.   case IIR_CTI: // time out
  471.     pUartBuf->RxBuf[pUartBuf->RxTailPoint] = U1RBR;
  472.     if (++pUartBuf->RxCount > RXBUFSIZE)
  473.     {
  474.       pUartBuf->RxFlag |= RC_FIFO_OVERRUN_ERR;
  475.     }
  476.     pUartBuf->RxTailPoint = (pUartBuf->RxTailPoint+1)%RXBUFSIZE;
  477.     break;
  478.   default:
  479.     break;
  480.   }
  481.   VICVectAddr = 0;    // Clear interrupt in VIC.
  482. }