【IRD-LPC1768-DEV】UART_RS232

day_day

（一）
这个板子做RS232，实际上说到底就是一个UART而已，RS232是硬件已经实现好TTL转RS232了，不需要软件端操心。


（二）接口定义




（三）端口初始化
首先设置复用：



都是第二个映射

1. 
   
2. void UartGPIOInit(void)
   
3. {
   
4.         //LPC_PINCON->PINSEL0 |= 0x00000050;
   
5.         PIN_Configure(0, 2, PIN_FUNC_1, PIN_PINMODE_PULLUP, PIN_PINMODE_PULLUP);
   
6.         PIN_Configure(0, 3, PIN_FUNC_1, PIN_PINMODE_PULLUP, PIN_PINMODE_PULLUP);
   
7. }

复制代码

我是用PIN_Configure设置，一开始打算直接操作寄存器，但想了想还是不怎么明了


（四）UART设置
UART相关寄存器：



主要是波特率设置的两个寄存器：DLL、DLM
此外还有一个配置寄存器，用于配置奇偶校核位之类的东西，还有锁住波特率设置的两个寄存器的标志位：LCR
波特率设置实际上困扰了我一阵子

1. uint16_t usFdiv = ((SystemCoreClock/4)/16)/bps;

复制代码

SystemCoreClock/4是uart0总线时钟，在时钟树上面有相关的位配置。

但为何要/16让我有些疑惑，后来才发现发送一个字节需要16个位，前8个是一个字节里面的八个位，后面是一些奇偶校核之类的，详见：
串口、波特率等概念

1. LPC_UART0->LCR = 0x83;                                        //使能访问除数锁存器,8 bits, no Parity, 1 Stop bit     */
   
2.   LPC_UART0->DLM = usFdiv / 256;        //初始化波特率                   */
   
3.   LPC_UART0->DLL = usFdiv % 256;
   
4.   LPC_UART0->LCR = 0x03;                                        //禁止访问除数锁存器，锁定波特率
   
5.         

复制代码

这样就基本可以正常通讯了，使用函数：

1. int sendchar (int ch)  {                 /* Write character to Serial Port    */
   
2. 
   
3.   while (!(LPC_UART0->LSR & 0x20));
   
4. 
   
5.   return (LPC_UART0->THR = ch);
   
6. }
   

复制代码

（四）重定向

加入头文件stdio.h

1. #pragma import(__use_no_semihosting)            
   
2. //标准库需要的支持函数                 
   
3. struct __FILE { int handle; };        /* Add whatever you need here */
   
4. FILE __stdout;
   
5. 
   
6. FILE __stdout;      
   
7. 
   
8. //定义_sys_exit()以避免使用半主机模式   
   
9. void _sys_exit(int return_code) {
   
10. label:  goto label;  /* endless loop */
    
11. }
    
12. 
    
13. //重定义fputc函数
    
14. int fputc(int ch, FILE *f) {
    
15.   return (sendchar(ch));
    
16. }
    

复制代码

（五）UART设置
以上是非常基本的UART配置，只能用于基本的阻塞通讯，要想启动中断，还需要配置IER寄存器和使能NVIC

1. LPC_UART0->FCR  = 0x00;                 //禁止FIFO
   
2.         NVIC_ClearPendingIRQ(UART0_IRQn);
   
3.         NVIC_SetPriority(UART0_IRQn, 0);
   
4.         NVIC_EnableIRQ(UART0_IRQn);              /* enable irq in nvic              */
   
5.         LPC_UART0->IER = 0x01;                  //使能接收中断

复制代码

中断相关配置：

1. void UartInit(uint32_t bps)
   
2. {
   
3.         uint16_t usFdiv = ((SystemCoreClock/4)/16)/bps;
   
4.         
   
5.         UartGPIOInit();
   
6. //        LPC_UART0->RBR;        //缓冲接收寄存器
   
7. //        LPC_UART0->THR;        //发送寄存器
   
8. //        LPC_UART0->DLL;        //波特率低位
   
9. //        LPC_UART0->DLM;        //波特率高位
   
10.         
    
11.   LPC_UART0->LCR = 0x83;                                        //使能访问除数锁存器,8 bits, no Parity, 1 Stop bit     */
    
12.   LPC_UART0->DLM = usFdiv / 256;        //初始化波特率                   */
    
13.   LPC_UART0->DLL = usFdiv % 256;
    
14.   LPC_UART0->LCR = 0x03;                                        //禁止访问除数锁存器，锁定波特率
    
15.         
    
16.         LPC_UART0->FCR  = 0x00;                 //禁止FIFO
    
17.         NVIC_ClearPendingIRQ(UART0_IRQn);
    
18. //        NVIC_SetPriority(UART0_IRQn,NVIC_EncodePriority(SYS_NVIC_GROUP,UART0_PreemptPriority,UART0_SubPriority));
    
19.         NVIC_SetPriority(UART0_IRQn, 0);
    
20.         NVIC_EnableIRQ(UART0_IRQn);              /* enable irq in nvic              */
    
21.         LPC_UART0->IER = 0x01;                  //使能接收中断
    
22. }
    
23. 
    
24. char RxBuf[50]="";
    
25. struct _usart_flag usart0_flag={0,0,0};
    
26. 
    
27. void UartRxInBuf(uint8_t str)
    
28. {
    
29.         if(usart0_flag.rec_end_flag==0)//接收未完成
    
30.     {
    
31.         if(usart0_flag.rec_middle_flag)//接收到了0x0d
    
32.         {
    
33.             if(str!=0x0a)
    
34.                                                         usart0_flag.rec_middle_flag = 0;//接收错误,重新开始
    
35.             else
    
36.                                                         usart0_flag.rec_end_flag = 1;        //接收完成了
    
37.         }
    
38.         else //还没收到0X0D
    
39.         {
    
40.             if(str==0x0d)
    
41.                                                         usart0_flag.rec_middle_flag = 1;
    
42.             else
    
43.             {
    
44.                 RxBuf[usart0_flag.size]=str ;
    
45.                 usart0_flag.size++;
    
46.                 if(usart0_flag.size>(50-1))
    
47.                                                                         memset(&usart0_flag, 0, sizeof(usart0_flag));        //接收数据错误,重新开始接收
    
48.             }
    
49.         }
    
50.     }
    
51. }
    
52. 
    
53. #define UART_IIR_RLS 3
    
54. #define UART_IIR_CTI 6
    
55. #define UART_IIR_RDA 2
    
56. 
    
57. #define UART_LSR_RDR 0x01
    
58. #define UART_LSR_OE 0x02
    
59. #define UART_LSR_PE 0x04
    
60. #define UART_LSR_FE 0x08
    
61. #define UART_LSR_THRE 0x20
    
62. #define UART_LSR_TEMT 0x40
    
63. #define UART_LSR_RXFE 0x80
    
64. 
    
65. void UART0_IRQHandler(void)
    
66. {
    
67.                 uint8_t IIRValue;
    
68.     uint8_t     LSRValue;
    
69.     uint8_t     Dummy = 0;
    
70. //    Uart_Buf *p = NULL;
    
71.     bool bFlag = true;
    
72. 
    
73. 
    
74.     while ( bFlag ) {                                 // 等待产生的所有中断处理完?
    
75.         IIRValue   = LPC_UART0->IIR;                      // 读取中断状态寄存器
    
76.         IIRValue >>= 1;                               // 屏蔽IIR中不需要的信息
    
77.         IIRValue  &= 0x07;                            // 效验1~3BIT 对中断状态识别
    
78. 
    
79.         switch (IIRValue) {                           //
    
80.         case UART_IIR_RLS :                           // --接收线状态
    
81.             LSRValue = LPC_UART0->LSR;                    // 读取线状态信息
    
82.             Dummy = UART_LSR_OE | UART_LSR_PE | UART_LSR_FE | UART_LSR_RXFE;
    
83.             if ( LSRValue & Dummy) {                  // -- 线状态 接收有关中断 只丢弃错误的成对接收RSR中字符
    
84.                 Dummy = LPC_UART0->RBR;                   // 读出成对字符 丢弃
    
85.                 break;                                // 下一个中断标志处理
    
86.             }
    
87. 
    
88.             if ( LSRValue & UART_LSR_RDR ) {          // -- 线状态 接收数据就绪
    
89.                 Dummy = LPC_UART0->RBR;                   // 读数据 时会清除中断
    
90.                 UartRxInBuf(Dummy);                // 进缓存
    
91.             }
    
92. 
    
93.             if ( ( LSRValue & UART_LSR_THRE) ||       // -- 线状态 发送保持寄存器空
    
94.                  ( LSRValue & UART_LSR_TEMT) ) {      // -- 线状态 发送器空
    
95. //                p = &UartTx[0];                       // 取对应串口发送缓存信息
    
96. //                if (p->Cnt > 0) {                     // 检查发送消息缓存区是否为空 不为空则继续发数据
    
97. //                    LPC_UART0->THR = UartTxOutBuf(0);  // 读走一个数据到发送寄存器
    
98. //                } else {
    
99. //                    UartTxFlag[0] = FALSE;            // 发送标志为0表示 可以直接发送信息
    
100. //                }
     
101.             }
     
102.             break;
     
103. 
     
104.         case UART_IIR_CTI :                           // -- 字符超时
     
105.             Dummy = LPC_UART0->RBR;                       // 读数据
     
106.             UartRxInBuf(Dummy);                    // 进接受缓存
     
107.             break;
     
108. 
     
109.         case UART_IIR_RDA :                           // -- 数据接收
     
110.             Dummy = LPC_UART0->RBR;                       // 读数据
     
111.             UartRxInBuf(Dummy);                    // 进接受缓存
     
112.             break;
     
113. 
     
114. //        case UART_IIR_THRE :                          // -- 发送空
     
115. //            p = &UartTx[0];                           // 取对应串口发送缓存信息
     
116. //            if (p->Cnt > 0) {                         // 检查发送消息缓存区是否为空 不为空则继续发数据
     
117. //                LPC_UART0->THR    = UartTxOutBuf(0);      // 读走一个数据到发送寄存器
     
118. //            } else {
     
119. //                UartTxFlag[0] = FALSE;                // 发送标志为0表示 可以直接发送信息
     
120. //            }
     
121. //            break;
     
122. 
     
123.         default :                                     // -- 默认处理 空
     
124.             bFlag = false;                            // 没有中断需要处理了
     
125.             break;
     
126.         }
     
127.     }
     
128. }
     

复制代码

阅读全文

NXP管管

支持下！