LPC1768 serial port UART0

Then the pin selection is set to serial port mode.

Then set the serial port transmission data format.

Baud rate setting, (note that the baud rate is different when there are decimal places and when there are no decimal places. If there are decimal places, DIVADDL and MULVAL need to be set).

The baud rate is then latched.

Settings control the operation of UARTn RX and TX FIFO.

Finally, turn on the interrupt of UART0 in the system and enable the receive interrupt.

See the code for details, which is commented in detail.

1.   
2.   
3. #include LPC17XX.h  
4.   
5.   
6. #define  FOSC                         12000000                              
7. #define  FCCLK                       (FOSC   *  8)                            
8.                                                                                        
9. #define  FCCO                        (FCCLK  *  3)                            
10.                                                                                        
11. #define  FPCLK                       (FCCLK  /  4)                             
12.                                                                                         
13.   
14. int  Uart0RecvBuf;                    //  UART0  RX  DATA  
15.   
16. void  Uart0Init(uint32_t  bps)   
17. {  
18.     LPC_SC->PCONP  |=  (1<<3);                          //Turn on UART0 power and clock control bits  
19.   
20.     LPC_PINCON->PINSEL0  =  0X00000050;         //P0.2  P0.3 are set to serial port  
21.   
22.     LPC_UART0->LCR  =  0x83;                          //Set the serial port data format, 8-bit character length, 1 stop bit, no checksum,  
23.                                                                    // Enable access to the divisor latch  and set the baud rate  
24.     LPC_UART0->DLM  =  ((FPCLK/16)/bps)  /  256;  //The divisor has eight high bits   ,  no decimals  
25.     LPC_UART0->DLL  =  ((FPCLK/16)/bps)  %  256; //The eighth digit of the divisor  
26.   
27.     LPC_UART0->LCR  =  0x03;                          //Disable access to the divisor latch and lock the baud rate  
28.   
29.     LPC_UART0->FCR   =  0x07;                        //Control the operation of UARTn  RX and TX  FIFO. Receive one byte of data to trigger an interrupt  
30.   
31.     NVIC_EnableIRQ(UART0_IRQn);                   
32.     LPC_UART0->IER  =  0x01;                        //Enable receive interrupt  
33. }  
34.   
35. int  Uart0RecvByte(void)    //Query method  
36. {  
37.     //When UnRBR contains unread characters, UnLSR[0] will be set; when UARTn  RBR  FIFO is empty, UnLSR[0] will be cleared  
38.     //0   -   UnRBR is empty  
39.     //1   -   UnRBR contains valid data  
40.     while(!((LPC_UART0->LSR)  &  0x01));        //Wait to determine whether LSR[0] is 1. If it is 1, it means that data has been received in RBR        
41.       
42.     return(LPC_UART0->RBR);                    //Read received data  
43. }  
44.   
45. int  Uart0SendByte(int  buf)  
46. {  
47.     //When UARTn THR is detected  to be empty, THRE will be set immediately. Writing UnTHR will clear THRE  
48.     //0   -   UnTHR contains valid characters  
49.     //1   -   UnTHR is empty  
50.     while(!((LPC_UART0->LSR)  &  0x01));        //Wait to determine whether LSR[5] (THRE) is 1. If it is 1, it means THR is empty.        
51.       
52.     LPC_UART0->THR  =  buf;                      //Send data  
53.   
54.     return  0;  
55. }  
56.   
57. void  UART0_IRQHandler(void)  
58. {  
59.     Uart0RecvBuf  =  LPC_UART0->RBR;        //Read received data      
60.   
61.     Uart0SendByte(Uart0RecvBuf);            //Send received data  
62. }  
63.   
64.   
65. int  main(void)  
66. {  
67.     int  temp;  
68.   
69.     SystemInit();  
70.     Uart0Init(115200);  
71.   
72.     while(1)  
73.     {  
74.                       
75.     //   temp  =  Uart0RecvByte();          //Query received data  
76.     //   Uart0SendByte(temp);             //Send data  
77.   
78.     }  
79.   
80. }