[bsp] modify the uart_driver to fit the new rt-thread serial device driver framework. Modify the template.uvproj for auto generate MDK project.

Author: ArdaFu

bsp/tm4c129x/applications/application.c

@@ -20,8 +20,9 @@
 void rt_init_thread_entry(void *parameter)
 {
     /* Initialization RT-Thread Components */
-#ifdef RT_USING_COMPONENTS_INIT
     rt_components_init();
+#ifdef RT_USING_FINSH
+    finsh_set_device(RT_CONSOLE_DEVICE_NAME);
 #endif
 }
 

bsp/tm4c129x/applications/board.c

@@ -15,14 +15,14 @@
 
 #include <rthw.h>
 #include <rtthread.h>
-#include <components.h>
 
 #include "board.h"
 #include "drv_uart.h"
-#include "interrupt.h"
-#include "sysctl.h"
-#include "systick.h"
-#include "fpu.h"
+
+#include "driverlib/interrupt.h"
+#include "driverlib/sysctl.h"
+#include "driverlib/systick.h"
+#include "driverlib/fpu.h"
 #include "driverlib/rom_map.h"
 
 #define SYS_CLOCK_DEFAULT 120000000
@@ -56,16 +56,15 @@ void SysTick_Handler(void)
 extern void PendSV_Handler(void);
 extern void HardFault_Handler(void);
 
-
 /**
  * This function will initial LPC40xx board.
  */
 void rt_hw_board_init()
 {
     IntRegister(FAULT_HARD, HardFault_Handler);	
-		IntRegister(FAULT_PENDSV, PendSV_Handler);
-		IntRegister(FAULT_SYSTICK, SysTick_Handler);
-	
+    IntRegister(FAULT_PENDSV, PendSV_Handler);
+    IntRegister(FAULT_SYSTICK, SysTick_Handler);
+    
 	  //
     // Enable lazy stacking for interrupt handlers.  This allows floating-point
     // instructions to be used within interrupt handlers, but at the expense of
@@ -78,23 +77,24 @@ void rt_hw_board_init()
     // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the
     // crystal on your board.
     //
-    SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480),
-                                            SYS_CLOCK_DEFAULT);
+    SysClock = MAP_SysCtlClockFreqSet(
+                (SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480),
+                SYS_CLOCK_DEFAULT);
 
-	MAP_SysTickDisable();
+    MAP_SysTickDisable();
     MAP_SysTickPeriodSet(SysClock/ RT_TICK_PER_SECOND - 1);
     MAP_SysTickIntEnable();
     MAP_SysTickEnable();	
 
-
     /* set pend exception priority */
-    //IntPrioritySet(FAULT_PENDSV, (1 << __NVIC_PRIO_BITS) - 1);
-    /*init uart device*/
-		
+    IntPrioritySet(FAULT_PENDSV, (1 << 5) - 1);
+    
+    /*init uart device*/		
     rt_hw_uart_init();
+		//redirect RTT stdio to CONSOLE device
     rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
     //
     // Enable interrupts to the processor.
     //
-	MAP_IntMasterEnable();
+	  MAP_IntMasterEnable();
 }

bsp/tm4c129x/drivers/drv_uart.c

@@ -20,41 +20,83 @@
 #include "board.h"
 //#include <components.h>
 
-#include "sysctl.h"
-#include "gpio.h"
-#include "uart.h"
-#include "hw_memmap.h"
-#include "pin_map.h"
-#include "interrupt.h"
-#include "rom.h"
-#include "rom_map.h"
+#include "inc/hw_memmap.h"
+#include "driverlib/sysctl.h"
+#include "driverlib/gpio.h"
+#include "driverlib/uart.h"
+#include "driverlib/pin_map.h"
+#include "driverlib/interrupt.h"
+#include "driverlib/rom_map.h"
 typedef struct hw_uart_device
 {
     uint32_t hw_base; // base address
 }hw_uart_t;
 
-#define GetHwUartPtr(serial) ((hw_uart_t*)(serial->parent.user_data))
+#define mUartGetHwPtr(serial) ((hw_uart_t*)(serial->parent.user_data))
 
 static rt_err_t hw_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
 {	
+	uint32_t config;
 	hw_uart_t* uart;
     RT_ASSERT(serial != RT_NULL);
-    uart = GetHwUartPtr(serial);
+    uart = mUartGetHwPtr(serial);
+
 	MAP_UARTDisable(uart->hw_base);
-    /* Initialize UART Configuration parameter structure to default state:
-     * Baudrate = 115200 bps
-     * 8 data bit
-     * 1 Stop bit
-     * None parity
-     */
-    // Initialize UART0 peripheral with given to corresponding parameter
-    MAP_UARTConfigSetExpClk(uart->hw_base, SysClock, cfg->baud_rate,
-													(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
-		MAP_UARTFIFOEnable(uart->hw_base);
-
-  //
+	// build UART Configuration parameter structure
+    switch(cfg->data_bits)
+	{
+	case DATA_BITS_9:
+		// enable 9bit address mode and set DATA_BIT_8
+		MAP_UART9BitEnable(uart->hw_base);
+	case DATA_BITS_8:
+		config |= UART_CONFIG_WLEN_8;
+		break;
+	case DATA_BITS_7:
+		config |= UART_CONFIG_WLEN_7;
+		break;
+	case DATA_BITS_6:
+		config |= UART_CONFIG_WLEN_6;
+		break;
+	case DATA_BITS_5:
+		config |= UART_CONFIG_WLEN_5;
+		break;
+	default:
+		RT_ASSERT(0);
+		break;
+	}
+	switch(cfg->parity)
+	{
+	case PARITY_ODD:
+		config |= UART_CONFIG_PAR_ODD;
+		break;
+	case PARITY_EVEN:
+		config |= UART_CONFIG_PAR_EVEN;
+		break;
+	case PARITY_NONE:
+		config |= UART_CONFIG_PAR_NONE;
+		break;
+	default:
+		RT_ASSERT(0);
+		break;
+	}
+	switch(cfg->stop_bits)
+	{
+	case STOP_BITS_1:
+		config |= UART_CONFIG_STOP_ONE;
+		break;
+	case STOP_BITS_2:
+		config |= UART_CONFIG_STOP_TWO;
+		break;
+	default:
+		RT_ASSERT(0);
+		break;
+	}
+	
+	// Initialize UART0 peripheral with given to corresponding parameter
+    MAP_UARTConfigSetExpClk(uart->hw_base, SysClock, cfg->baud_rate, config);
+	MAP_UARTFIFOEnable(uart->hw_base);
+
 	// Enable the UART.
-	//
 	MAP_UARTEnable(uart->hw_base);
     return RT_EOK;
 }
@@ -63,7 +105,7 @@ static rt_err_t hw_control(struct rt_serial_device *serial, int cmd, void *arg)
 {
 	hw_uart_t* uart;
     RT_ASSERT(serial != RT_NULL);
-    uart = GetHwUartPtr(serial);
+    uart = mUartGetHwPtr(serial);
 
     switch (cmd)
     {
@@ -84,7 +126,7 @@ static int hw_putc(struct rt_serial_device *serial, char c)
 {
 	hw_uart_t* uart;
     RT_ASSERT(serial != RT_NULL);
-    uart = GetHwUartPtr(serial);
+    uart = mUartGetHwPtr(serial);
 
     MAP_UARTCharPut(uart->hw_base, *((uint8_t *)&c));
     return 1;
@@ -94,7 +136,7 @@ static int hw_getc(struct rt_serial_device *serial)
 {
 	hw_uart_t* uart;
     RT_ASSERT(serial != RT_NULL);
-    uart = GetHwUartPtr(serial);
+    uart = mUartGetHwPtr(serial);
 
 	return MAP_UARTCharGetNonBlocking(uart->hw_base);
 }
@@ -110,29 +152,27 @@ static const struct rt_uart_ops hw_uart_ops =
 #if defined(RT_USING_UART0)
 /* UART0 device driver structure */
 struct rt_serial_device serial0;
-struct serial_ringbuffer uart0_int_rx_buf;
 hw_uart_t uart0 =
 {
     UART0_BASE,
 };
 
 void UART0_IRQHandler(void)
 {
-	  uint32_t intsrc;
+	uint32_t intsrc;
     hw_uart_t *uart = &uart0;
 
     /* enter interrupt */
     rt_interrupt_enter();
 
     /* Determine the interrupt source */
-    intsrc = UARTIntStatus(uart->hw_base, true);
+    intsrc = MAP_UARTIntStatus(uart->hw_base, true);
 
     // Receive Data Available or Character time-out
     if (intsrc & (UART_INT_RX | UART_INT_RT))
     {
-						UARTIntClear(UART0_BASE, intsrc);
-        rt_hw_serial_isr(&serial0);
-
+        MAP_UARTIntClear(uart->hw_base, intsrc);
+        rt_hw_serial_isr(&serial0, RT_SERIAL_EVENT_RX_IND);
     }
 
     /* leave interrupt */
@@ -144,57 +184,38 @@ int rt_hw_uart_init(void)
 {
     hw_uart_t* uart;
     struct serial_configure config;
-	
-#ifdef RT_USING_UART0
-    uart = &uart0;
+
     config.baud_rate = BAUD_RATE_115200;
     config.bit_order = BIT_ORDER_LSB;
     config.data_bits = DATA_BITS_8;
     config.parity    = PARITY_NONE;
     config.stop_bits = STOP_BITS_1;
     config.invert    = NRZ_NORMAL;
-
+    config.bufsz     = RT_SERIAL_RB_BUFSZ;
+	
+#ifdef RT_USING_UART0
+    uart = &uart0;
     serial0.ops    = &hw_uart_ops;
-    serial0.int_rx = &uart0_int_rx_buf;
     serial0.config = config;
 
-    //
-    // Enable the peripherals used by this example.
-    // The UART itself needs to be enabled, as well as the GPIO port
-    // containing the pins that will be used.
-    //
-
     MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
-
-    //
-    // Configure the GPIO pin muxing for the UART function.
-    // This is only necessary if your part supports GPIO pin function muxing.
-    // Study the data sheet to see which functions are allocated per pin.
-    // TODO: change this to select the port/pin you are using
-    //
     MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
     MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
-
-    //
-    // Since GPIO A0 and A1 are used for the UART function, they must be
-    // configured for use as a peripheral function (instead of GPIO).
-    // TODO: change this to match the port/pin you are using
-    //
+	
     MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
-
     MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
 
     /* preemption = 1, sub-priority = 1 */
-    //IntPrioritySet(INT_UART0, ((0x01 << 3) | 0x01));
+    IntPrioritySet(INT_UART0, ((0x01 << 5) | 0x01));
 
     /* Enable Interrupt for UART channel */
-	UARTIntRegister(uart->hw_base, UART0_IRQHandler);
-	MAP_IntEnable(INT_UART0);
-	MAP_UARTEnable(uart->hw_base);
+	  UARTIntRegister(uart->hw_base, UART0_IRQHandler);
+	  MAP_IntEnable(INT_UART0);
+	  MAP_UARTEnable(uart->hw_base);
 
     /* register UART0 device */
     rt_hw_serial_register(&serial0, "uart0",
-                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                           uart);
 #endif
 	return 0;