/*
* UART3 is used to communicate with the Optode. Set UART3
* to 9600 baud, 8, N, 1. Also, set up and enable the RX FIFO interrupt
* to receive data.
*/
void UART3Init(void)
{
// set up UART3 to the optode
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
ROM_GPIOPinConfigure(GPIO_PC6_U3RX); //set up the pins
ROM_GPIOPinConfigure(GPIO_PC7_U3TX);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7);
//9600 baud, 8, N, 1
ROM_UARTConfigSetExpClk(UART3_BASE, ROM_SysCtlClockGet(), 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// Enable the UART.
ROM_UARTEnable(UART3_BASE);
//RX interrupt will occur when FIFO is 1/8 full
ROM_UARTFIFOLevelSet(UART3_BASE, UART_FIFO_TX7_8, UART_FIFO_RX1_8);
//enable the interrupt
ROM_IntEnable(INT_UART3);
//flush the RX fifo before enabling the RX interrupt to get rid of residual data
while(ROM_UARTCharsAvail(UART3_BASE))
{
ROM_UARTCharGetNonBlocking(UART3_BASE);
}
//Enable the UART peripheral interrupt...receive
ROM_UARTIntEnable(UART3_BASE, UART_INT_RX);
}
void UART_setup_gps(void)
{
//
// Enable the peripherals used by gps.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//
// Set GPIO B0 and B1 as UART pins for the gps.
//
ROM_GPIOPinConfigure(GPIO_PB0_U1RX);
ROM_GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the GPS for 9600, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART1_BASE, ROM_SysCtlClockGet(), 9600,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART1);
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
}
/**
* Initalize the RS232 port.
*
*/
void
uart0_init(unsigned long ubr)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pins for the LED (PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
ROM_IntMasterEnable();
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
}
BOOL xMBTCPPortInit(USHORT port)
{
ROM_SysCtlPeripheralEnable(WIZ610_GPIO_PERIPH);
ROM_GPIODirModeSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE ,GPIO_DIR_MODE_OUT);
ROM_GPIOPadConfigSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,GPIO_STRENGTH_8MA,GPIO_PIN_TYPE_STD_WPU);
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE);
// uart setup
ROM_SysCtlPeripheralEnable(WIZ610_UART_PERIPH);
ROM_GPIOPinConfigure(GPIO_PB0_U1RX);
ROM_GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(WIZ610_GPIO_BASE, WIZ610_GPIO_PIN_RX | WIZ610_GPIO_PIN_TX);
ROM_UARTConfigSetExpClk(WIZ610_UART_BASE, ROM_SysCtlClockGet(), 38400,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE);
ROM_UARTFIFOLevelSet(WIZ610_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX1_8);
ROM_IntEnable(INT_UART1);
ROM_UARTEnable(WIZ610_UART_BASE);
ROM_UARTDMAEnable(WIZ610_UART_BASE, UART_DMA_TX);
ROM_UARTIntEnable(WIZ610_UART_BASE, UART_INT_RX);
ROM_IntEnable(INT_UDMA);
WIZ610Transfer();
cmd_modbus_switch=0;
g_ulRxBufACount=0;
modbus_tcp_rab=MODBUS_TCP_IDLE;
return TRUE;
}
void CC3100_InterruptEnable()
{
GPIOIntEnable(CC3100_IRQBASE,CC3100_IRQPIN);
#ifdef SL_IF_TYPE_UART
ROM_UARTIntEnable(CC3100_UARTBASE, UART_INT_RX);
#endif
}
//*****************************************************************************
//
// PoC2Repeater
//
//*****************************************************************************
int
main(void)
{
// Set the clocking to run directly from the crystal at 120MHz.
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
// Enable the peripherals
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
// Enable the GPIO pins for the LEDs (PN0 and PN1).
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4);
// ButtonsInit
ROM_GPIODirModeSet(GPIO_PORTJ_BASE, ALL_BUTTONS, GPIO_DIR_MODE_IN);
MAP_GPIOPadConfigSet(GPIO_PORTJ_BASE, ALL_BUTTONS,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Enable processor interrupts.
ROM_IntMasterEnable();
// Set GPIO PC4 and PC5 as UART pins.
GPIOPinConfigure(GPIO_PC4_U7RX);
GPIOPinConfigure(GPIO_PC5_U7TX);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
// Configure the UART for 115,200, 8-N-1 operation.
ROM_UARTConfigSetExpClk(UART7_BASE, g_ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
// Enable the UART interrupt.
ROM_IntEnable(INT_UART7);
ROM_UARTIntEnable(UART7_BASE, UART_INT_RX | UART_INT_RT);
// Reset message info
for(uint8_t i = 0; i < MSG; i++)
message[i] = 0;
// Loop forever echoing data through the UART.
while(1)
{
}
}
void HardwareSerial::UARTIntHandler(void){
unsigned long ulInts;
long lChar;
// Get and clear the current interrupt source(s)
//
ulInts = ROM_UARTIntStatus(UART_BASE, true);
ROM_UARTIntClear(UART_BASE, ulInts);
// Are we being interrupted because the TX FIFO has space available?
//
if(ulInts & UART_INT_TX)
{
//
// Move as many bytes as we can into the transmit FIFO.
//
primeTransmit(UART_BASE);
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(TX_BUFFER_EMPTY)
{
ROM_UARTIntDisable(UART_BASE, UART_INT_TX);
}
}
if(ulInts & (UART_INT_RX | UART_INT_RT))
{
while(ROM_UARTCharsAvail(UART_BASE))
{
//
// Read a character
//
lChar = ROM_UARTCharGetNonBlocking(UART_BASE);
//
// If there is space in the receive buffer, put the character
// there, otherwise throw it away.
//
uint8_t volatile full = RX_BUFFER_FULL;
if(full) break;
rxBuffer[rxWriteIndex] =
(unsigned char)(lChar & 0xFF);
rxWriteIndex = ((rxWriteIndex) + 1) % rxBufferSize;
//
// If we wrote anything to the transmit buffer, make sure it actually
// gets transmitted.
//
}
primeTransmit(UART_BASE);
ROM_UARTIntEnable(UART_BASE, UART_INT_TX);
}
}
void setup()
{
//--------------------- GENERAL ---------------------
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
ROM_FPUEnable();
ROM_FPULazyStackingEnable();
// Set the clocking to run directly from the crystal.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
ROM_IntMasterEnable();
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6);
//--------------------- UART ---------------------
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// Configure the UART for 115,200, 8-N-1 operation.
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
// Enable the UART interrupt.
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//--------------------- SSI ---------------------
SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
GPIOPinConfigure(GPIO_PA2_SSI0CLK);
GPIOPinConfigure(GPIO_PA3_SSI0FSS);
GPIOPinConfigure(GPIO_PA4_SSI0RX);
GPIOPinConfigure(GPIO_PA5_SSI0TX);
GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 | GPIO_PIN_2);
SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 10000, 8);
SSIEnable(SSI0_BASE);
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO A0 and A1 as UART pins.
//
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//
// Prompt for text to be entered.
//
UARTSend((unsigned char *)"\033[2JEnter text: ", 16);
//
// Loop forever echoing data through the UART.
//
while(1)
{
}
}
int uart_Read(Fd_t fd, unsigned char *pBuff, int len)
{
int i = 0;
ROM_UARTIntDisable(UART1_BASE, UART_INT_RX);
for(i=0; i< len; i++)
{
pBuff[i] = (unsigned char)UARTCharGet(UART1_BASE);
}
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX);
return len;
}
size_t HardwareSerial::write(uint8_t c)
{
unsigned int numTransmit = 0;
//
// Check for valid arguments.
//
ASSERT(c != 0);
/*
//this is not necessary: https://github.com/energia/Energia/issues/225
//
// If the character to the UART is \n, then add a \r before it so that
// \n is translated to \n\r in the output.
//
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
if(c == '\n')
{
while (TX_BUFFER_FULL);
txBuffer[txWriteIndex] = '\r';
txWriteIndex = (txWriteIndex + 1) % txBufferSize;
numTransmit ++;
}
*/
//
// Send the character to the UART output.
//
while (TX_BUFFER_FULL);
txBuffer[txWriteIndex] = c;
txWriteIndex = (txWriteIndex + 1) % txBufferSize;
numTransmit ++;
//
// If we have anything in the buffer, make sure that the UART is set
// up to transmit it.
//
if(!TX_BUFFER_EMPTY)
{
primeTransmit(UART_BASE);
ROM_UARTIntEnable(UART_BASE, UART_INT_TX);
}
//
// Return the number of characters written.
//
return(numTransmit);
}
void UARTPutChar(uint32_t ui32Base, char ucData)
{
OSMutexAcquire(mutexTx,0);
//
// Send the char.
//
HWREG(ui32Base + UART_O_DR) = ucData;
//
// Wait until space is available.
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX);
// Wait indefinitely for a UART interrupt
OSSemPend(sUART,0);
OSMutexRelease(mutexTx);
}
size_t HardwareSerial::write(uint8_t c)
{
unsigned int numTransmit = 0;
//
// Check for valid arguments.
//
ASSERT(c != 0);
//
// If the character to the UART is \n, then add a \r before it so that
// \n is translated to \n\r in the output.
//
// If the output buffer is full, there's nothing for it other than to
// wait for the interrupt handler to empty it a bit
if(c == '\n')
{
while (TX_BUFFER_FULL);
txBuffer[txWriteIndex] = '\r';
txWriteIndex = (txWriteIndex + 1) % SERIAL_BUFFER_SIZE;
numTransmit ++;
}
//
// Send the character to the UART output.
//
while (TX_BUFFER_FULL);
txBuffer[txWriteIndex] = c;
txWriteIndex = (txWriteIndex + 1) % SERIAL_BUFFER_SIZE;
numTransmit ++;
//
// If we have anything in the buffer, make sure that the UART is set
// up to transmit it.
//
if(!TX_BUFFER_EMPTY)
{
primeTransmit(g_ulUARTBase[uartModule]);
ROM_UARTIntEnable(g_ulUARTBase[uartModule], UART_INT_TX);
}
//
// Return the number of characters written.
//
return(numTransmit);
}
char UARTgetc(uint8_t UART)
{
if (!rxQSize(UART))
{
// Disable interrupt to avoid possible race condition
ROM_UARTIntDisable(UARTBASE[UART], UART_INT_RX);
// Wait for data if the buffer is empty
while (!rxQSize(UART)) flushReadFIFO(UART);
// Return to the previous state
ROM_UARTIntEnable(UARTBASE[UART], UART_INT_RX);
}
return (char)rxDequeue(UART);
}
char UARTpeekBlocking(uint8_t UART)
{
// If there is data in the buffer return that
if (rxQSize(UART)) return rxBuff[UART][rxBufferTail[UART]];
// Disable interrupt to avoid possible race condition
ROM_UARTIntDisable(UARTBASE[UART], UART_INT_RX);
// Wait for data if the buffer is empty
while (!rxQSize(UART)) flushReadFIFO(UART);
// Return to the previous state
ROM_UARTIntEnable(UARTBASE[UART], UART_INT_RX);
// Return what was read without popping it from the queue
return rxBuff[UART][rxBufferTail[UART]];
}
void
HardwareSerial::begin(unsigned long baud)
{
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(g_ulUARTInt[uartModule]);
//TODO:Add functionality for PinConfigure with variable uartModule
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Only allow a single instance to be opened.
//
ASSERT(g_ulUARTBase[uartModule] == 0);
//
// Check to make sure the UART peripheral is present.
//
if(!ROM_SysCtlPeripheralPresent(g_ulUARTPeriph[uartModule]))
{
return;
}
ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uartModule]);
ROM_UARTConfigSetExpClk(g_ulUARTBase[uartModule], ROM_SysCtlClockGet(), baud,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Set the UART to interrupt whenever the TX FIFO is almost empty or
// when any character is received.
//
ROM_UARTFIFOLevelSet(g_ulUARTBase[uartModule], UART_FIFO_TX1_8, UART_FIFO_RX1_8);
flushAll();
ROM_UARTIntDisable(g_ulUARTBase[uartModule], 0xFFFFFFFF);
ROM_UARTIntEnable(g_ulUARTBase[uartModule], UART_INT_RX | UART_INT_RT);
ROM_IntMasterEnable();
ROM_IntEnable(g_ulUARTInt[uartModule]);
//
// Enable the UART operation.
//
ROM_UARTEnable(g_ulUARTBase[uartModule]);
}
void DBG_Init(void)
{
newlines = 0;
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), DBG_BAUD, UART_CFG_8N1);
ROM_UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX1_8, UART_FIFO_RX7_8);
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX | UART_INT_RX | UART_INT_RT);
} // DBG_Init()
int UARTpeek(uint8_t UART)
{
// If there is data in the buffer return that
if (rxQSize(UART)) return rxBuff[UART][rxBufferTail[UART]];
// Disable interrupt to avoid possible race condition
ROM_UARTIntDisable(UARTBASE[UART], UART_INT_RX);
// Try flushing the hardware FIFO and see if we can get data from there
flushReadFIFO(UART);
if (rxQSize(UART)) return rxBuff[UART][rxBufferTail[UART]];
// Return to the previous state
ROM_UARTIntEnable(UARTBASE[UART], UART_INT_RX);
// No data was found
return -255;
}
void
HardwareSerial::begin(unsigned long baud)
{
baudRate = baud;
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uartModule]);
//TODO:Add functionality for PinConfigure with variable uartModule
ROM_GPIOPinConfigure(g_ulUARTConfig[uartModule][0]);
ROM_GPIOPinConfigure(g_ulUARTConfig[uartModule][1]);
ROM_GPIOPinTypeUART(g_ulUARTPort[uartModule], g_ulUARTPins[uartModule]);
ROM_UARTConfigSetExpClk(UART_BASE, F_CPU, baudRate,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Set the UART to interrupt whenever the TX FIFO is almost empty or
// when any character is received.
//
ROM_UARTFIFOLevelSet(UART_BASE, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
flushAll();
ROM_UARTIntDisable(UART_BASE, 0xFFFFFFFF);
ROM_UARTIntEnable(UART_BASE, UART_INT_RX | UART_INT_RT);
ROM_IntEnable(g_ulUARTInt[uartModule]);
//
// Enable the UART operation.
//
ROM_UARTEnable(UART_BASE);
// Allocate TX & RX buffers
if (txBuffer != (unsigned char *)0xFFFFFFFF) // Catch attempts to re-init this Serial instance by freeing old buffer first
free(txBuffer);
if (rxBuffer != (unsigned char *)0xFFFFFFFF) // Catch attempts to re-init this Serial instance by freeing old buffer first
free(rxBuffer);
txBuffer = (unsigned char *) malloc(txBufferSize);
rxBuffer = (unsigned char *) malloc(rxBufferSize);
SysCtlDelay(100);
}
void UARTPutString(uint32_t ui32Base, char *string)
{
OSMutexAcquire(mutexTx,0);
while(*string)
{
//
// Send the char.
//
HWREG(ui32Base + UART_O_DR) = 0x72;// *string;
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX);
// Wait indefinitely for a UART interrupt
OSSemPend(sUART,0);
string++;
}
OSMutexRelease(mutexTx);
}
void wiz610_init(void)
{
ROM_SysCtlPeripheralEnable(WIZ610_GPIO_PERIPH);
ROM_GPIODirModeSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE ,GPIO_DIR_MODE_OUT);
ROM_GPIOPadConfigSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,GPIO_STRENGTH_8MA,GPIO_PIN_TYPE_STD_WPU);
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE);
// uart setup
ROM_SysCtlPeripheralEnable(WIZ610_UART_PERIPH);
ROM_GPIOPinConfigure(GPIO_PB0_U1RX);
ROM_GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(WIZ610_GPIO_BASE, WIZ610_GPIO_PIN_RX | WIZ610_GPIO_PIN_TX);
ROM_UARTConfigSetExpClk(WIZ610_UART_BASE, ROM_SysCtlClockGet(), 38400,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,0);
ROM_UARTFIFOLevelSet(WIZ610_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX1_8);
ROM_IntEnable(INT_UART1);
ROM_UARTEnable(WIZ610_UART_BASE);
ROM_UARTDMAEnable(WIZ610_UART_BASE, UART_DMA_TX);
ROM_UARTIntEnable(WIZ610_UART_BASE, UART_INT_RX);
ROM_IntEnable(INT_UDMA);
cmd_modbus_switch=1;
}
void enableUART(uint8_t UART, unsigned long baudRate)
{
// We must unlock PD7 to use UART2
if (UART == 2)
{
// GPIO Port D Lock Register is at 0x40007520
HWREG(0x40007520) = GPIO_LOCK_KEY;
// GPIO Port D Control Register is at 0x40007524
HWREG(0x40007524) = 0x80;
}
// Enable the UART peripheral in SysCtl
ROM_SysCtlPeripheralEnable(SysCtlGPIOs[UARTPins[UART][0] / 8]);
ROM_SysCtlPeripheralSleepEnable(SysCtlGPIOs[UARTPins[UART][0] / 8]);
ROM_SysCtlPeripheralEnable(SysCtlUARTs[UART]);
ROM_SysCtlPeripheralSleepEnable(SysCtlUARTs[UART]);
// Configure the associated GPIO pins for UART
ROM_GPIOPinConfigure(UARTPins[UART][2]);
ROM_GPIOPinConfigure(UARTPins[UART][3]);
ROM_GPIOPinTypeUART(GPIO[UARTPins[UART][0] / 8],
bit8[UARTPins[UART][0] % 8] | bit8[UARTPins[UART][1] % 8]);
// Configure the UART
ROM_UARTConfigSetExpClk(UARTBASE[UART], ROM_SysCtlClockGet(), baudRate,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
ROM_UARTFIFOEnable(UARTBASE[UART]);
// Configure the UART receive (rx) interrupt
ROM_UARTIntEnable(UARTBASE[UART], UART_INT_RX);
UARTFIFOLevelSet(UARTBASE[UART], UART_FIFO_TX4_8, UART_FIFO_RX4_8);
UARTIntRegister(UARTBASE[UART], rxInterrupts[UART]);
ROM_IntPrioritySet(UART_INTs[UART], 0x00);
// Enable the UART
ROM_UARTEnable(UARTBASE[UART]);
}
void uartBt_init(unsigned long baudrate) {
ROM_SysCtlPeripheralEnable(UARTBT_PORTENABLE);
ROM_SysCtlPeripheralEnable(UARTBT_PERIPHENABLE);
if(UARTBT_PORT == GPIO_PORTD_BASE) {
// Enable port PD7 for UART2-TX by opening the lock and selecting the bits we want to modify in the GPIO commit register.
HWREG(UARTBT_PORT + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(UARTBT_PORT + GPIO_O_CR) = 0x80;
}
ROM_GPIOPinConfigure(UARTBT_PINMAP_TX);
ROM_GPIOPinConfigure(UARTBT_PINMAP_RX);
ROM_GPIOPinTypeUART(UARTBT_PORT, UARTBT_PIN_RX | UARTBT_PIN_TX);
// Configure the UART for the specified baud rate, 8-N-1 operation.
ROM_UARTConfigSetExpClk(UARTBT_BASE, ROM_SysCtlClockGet(), baudrate, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
ROM_UARTFIFODisable(UARTBT_BASE); // FIFO disabled so that short commands come through immediately
// ROM_UARTFIFOEnable(UARTBT_BASE);
// ROM_UARTFIFOLevelSet(UARTBT_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
UARTIntRegister(UARTBT_BASE, ISR_uartBt);
ROM_IntEnable(UARTBT_INTERRUPT);
ROM_UARTIntEnable(UARTBT_BASE, UART_INT_RX);
}
//*****************************************************************************
//
// Initializes the UART and prepares it to be used as a control interface.
//
//*****************************************************************************
void
UARTIFInit(void)
{
//
// Configure the UART pins.
//
#if UART_RX_PORT == UART_TX_PORT
ROM_GPIOPinTypeUART(UART_RX_PORT, UART_RX_PIN | UART_TX_PIN);
#else
ROM_GPIOPinTypeUART(UART_RX_PORT, UART_RX_PIN);
ROM_GPIOPinTypeUART(UART_TX_PORT, UART_TX_PIN);
#endif
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, SYSCLK, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupts.
//
ROM_UARTIntEnable(UART0_BASE, UART_INT_TX | UART_INT_RX | UART_INT_RT);
ROM_IntEnable(INT_UART0);
//
// Send an enumeration response message to the UART to indicate that the
// firmware has just started.
//
if(g_sParameters.ucDeviceNumber != 0)
{
UARTIFSendMessage(CAN_MSGID_API_ENUMERATE |
g_sParameters.ucDeviceNumber, 0, 0);
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
tContext sContext;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sCFAL96x64x16);
//
// Fill the top part of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1;
sRect.i16YMax = 9;
GrContextForegroundSet(&sContext, ClrDarkBlue);
GrRectFill(&sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&sContext, ClrWhite);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&sContext, g_psFontFixed6x8);
GrStringDrawCentered(&sContext, "uart-echo", -1,
GrContextDpyWidthGet(&sContext) / 2, 4, 0);
//
// Initialize the display and write some instructions.
//
GrStringDrawCentered(&sContext, "Connect a", -1,
GrContextDpyWidthGet(&sContext) / 2, 20, false);
GrStringDrawCentered(&sContext, "terminal", -1,
GrContextDpyWidthGet(&sContext) / 2, 30, false);
GrStringDrawCentered(&sContext, "to UART0.", -1,
GrContextDpyWidthGet(&sContext) / 2, 40, false);
GrStringDrawCentered(&sContext, "115000,N,8,1", -1,
GrContextDpyWidthGet(&sContext) / 2, 50, false);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO A0 and A1 as UART pins.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
//
// Prompt for text to be entered.
//
UARTSend((uint8_t *)"Enter text: ", 12);
//
// Loop forever echoing data through the UART.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32TxCount;
uint32_t ui32RxCount;
tRectangle sRect;
char pcBuffer[16];
uint32_t ui32Fullness;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Configure the required pins for USB operation.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Erratum workaround for silicon revision A1. VBUS must have pull-down.
//
if(CLASS_IS_BLIZZARD && REVISION_IS_A1)
{
HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;
}
//
// Not configured initially.
//
g_bUSBConfigured = false;
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = 9;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb-dev-serial", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);
//
// Show the various static text elements on the color STN display.
//
GrStringDraw(&g_sContext, "Tx #",-1, 0, 12, false);
GrStringDraw(&g_sContext, "Tx buf", -1, 0, 22, false);
GrStringDraw(&g_sContext, "Rx #", -1, 0, 32, false);
GrStringDraw(&g_sContext, "Rx buf", -1, 0, 42, false);
DrawBufferMeter(&g_sContext, 40, 22);
DrawBufferMeter(&g_sContext, 40, 42);
//
// Enable the UART that we will be redirecting.
//
ROM_SysCtlPeripheralEnable(USB_UART_PERIPH);
//
// Enable and configure the UART RX and TX pins
//
ROM_SysCtlPeripheralEnable(TX_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(RX_GPIO_PERIPH);
ROM_GPIOPinTypeUART(TX_GPIO_BASE, TX_GPIO_PIN);
ROM_GPIOPinTypeUART(RX_GPIO_BASE, RX_GPIO_PIN);
//
// TODO: Add code to configure handshake GPIOs if required.
//
//
// Set the default UART configuration.
//
ROM_UARTConfigSetExpClk(USB_UART_BASE, ROM_SysCtlClockGet(),
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
ROM_UARTFIFOLevelSet(USB_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
//
// Configure and enable UART interrupts.
//
ROM_UARTIntClear(USB_UART_BASE, ROM_UARTIntStatus(USB_UART_BASE, false));
ROM_UARTIntEnable(USB_UART_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
//
// Enable the system tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDCDCInit(0, &g_sCDCDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
//
// Enable interrupts now that the application is ready to start.
//
ROM_IntEnable(USB_UART_INT);
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ui32Flags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
ROM_IntMasterDisable();
g_ui32Flags &= ~COMMAND_STATUS_UPDATE;
ROM_IntMasterEnable();
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32UARTTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32UARTTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 12, true);
//
// Update the RX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's receive buffer is the UART's
// transmit buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 22);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32UARTRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 32, true);
//
// Update the TX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's transmit buffer is the UART's
// receive buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 42);
}
}
}
//*****************************************************************************
//
// Handles CDC driver notifications related to the receive channel (data from
// the USB host).
//
// \param pvCBData is the client-supplied callback data value for this channel.
// \param ui32Event identifies the event we are being notified about.
// \param ui32MsgValue is an event-specific value.
// \param pvMsgData is an event-specific pointer.
//
// This function is called by the CDC driver to notify us of any events
// related to operation of the receive data channel (the OUT channel carrying
// data from the USB host).
//
// \return The return value is event-specific.
//
//*****************************************************************************
uint32_t
RxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
void *pvMsgData)
{
uint32_t ui32Count;
//
// Which event are we being sent?
//
switch(ui32Event)
{
//
// A new packet has been received.
//
case USB_EVENT_RX_AVAILABLE:
{
//
// Feed some characters into the UART TX FIFO and enable the
// interrupt so we are told when there is more space.
//
USBUARTPrimeTransmit(USB_UART_BASE);
ROM_UARTIntEnable(USB_UART_BASE, UART_INT_TX);
break;
}
//
// We are being asked how much unprocessed data we have still to
// process. We return 0 if the UART is currently idle or 1 if it is
// in the process of transmitting something. The actual number of
// bytes in the UART FIFO is not important here, merely whether or
// not everything previously sent to us has been transmitted.
//
case USB_EVENT_DATA_REMAINING:
{
//
// Get the number of bytes in the buffer and add 1 if some data
// still has to clear the transmitter.
//
ui32Count = ROM_UARTBusy(USB_UART_BASE) ? 1 : 0;
return(ui32Count);
}
//
// We are being asked to provide a buffer into which the next packet
// can be read. We do not support this mode of receiving data so let
// the driver know by returning 0. The CDC driver should not be sending
// this message but this is included just for illustration and
// completeness.
//
case USB_EVENT_REQUEST_BUFFER:
{
return(0);
}
//
// We don't expect to receive any other events. Ignore any that show
// up in a release build or hang in a debug build.
//
default:
#ifdef DEBUG
while(1);
#else
break;
#endif
}
return(0);
}
int
main(void)
{
//
// Set the clocking to run directly from the crystal at 16MHz.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
g_ui32SysClock = SysCtlClockGet();
//
// Enable the GPIO port that is used for the on-board LED.
// Enable the GPIO pins for the LED (PN0).
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_BLUE|LED_GREEN);
GPIOPinWrite(GPIO_PORTF_BASE, LED_GREEN, LED_GREEN);
DELAY(500);
GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE|LED_GREEN, 0);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO A0 and A1 as UART pins.
//
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Set GPIO B0 and B1 as UART pins.
//
GPIOPinConfigure(GPIO_PB0_U1RX);
GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, g_ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
ROM_UARTConfigSetExpClk(UART1_BASE, g_ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
ROM_IntEnable(INT_UART1);
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
ROM_UARTFIFODisable(UART0_BASE);
ROM_UARTFIFODisable(UART1_BASE);
//
// Loop forever echoing data through the UART.
//
while(1);
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32TxCount, ui32RxCount, ui32Fullness, ui32SysClock, ui32PLLRate;
tRectangle sRect;
char pcBuffer[16];
#ifdef USE_ULPI
uint32_t ui32Setting;
#endif
//
// Set the system clock to run at 120MHz from the PLL.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
#ifdef USE_ULPI
//
// Switch the USB ULPI Pins over.
//
USBULPIPinoutSet();
//
// Enable USB ULPI with high speed support.
//
ui32Setting = USBLIB_FEATURE_ULPI_HS;
USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);
//
// Setting the PLL frequency to zero tells the USB library to use the
// external USB clock.
//
ui32PLLRate = 0;
#else
//
// Save the PLL rate used by this application.
//
ui32PLLRate = 480000000;
#endif
//
// Enable the system tick.
//
ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Not configured initially.
//
g_ui32Flags = 0;
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "usb-dev-serial");
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = 23;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Show the various static text elements on the color STN display.
//
GrContextFontSet(&g_sContext, TEXT_FONT);
GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 80, false);
GrStringDraw(&g_sContext, "Tx buffer:", -1, 8, 105, false);
GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 160, false);
GrStringDraw(&g_sContext, "Rx buffer:", -1, 8, 185, false);
DrawBufferMeter(&g_sContext, 150, 105);
DrawBufferMeter(&g_sContext, 150, 185);
//
// Enable the UART that we will be redirecting.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Change the UART clock to the 16 MHz PIOSC.
//
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
//
// Set the default UART configuration.
//
ROM_UARTConfigSetExpClk(UART0_BASE, UART_CLOCK,
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
ROM_UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
//
// Configure and enable UART interrupts.
//
ROM_UARTIntClear(UART0_BASE, ROM_UARTIntStatus(UART0_BASE, false));
ROM_UARTIntEnable(UART0_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring USB... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Tell the USB library the CPU clock and the PLL frequency. This is a
// new requirement for TM4C129 devices.
//
USBDCDFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
USBDCDFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDCDCInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, " Waiting for host... ");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
g_ui32UARTTxCount = 0;
g_ui32UARTRxCount = 0;
#ifdef DEBUG
g_ui32UARTRxErrors = 0;
#endif
//
// Enable interrupts now that the application is ready to start.
//
ROM_IntEnable(INT_UART0);
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE))
{
//
// Clear the command flag
//
HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 0;
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32UARTTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32UARTTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 150, 80, true);
//
// Update the RX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's receive buffer is the UART's
// transmit buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 105);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32UARTRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 150, 160, true);
//
// Update the TX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's transmit buffer is the UART's
// receive buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 185);
}
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
tContext sContext;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "ble-btool");
//
// PJ0, 1, 4, 5 are used for UART3.
//
ROM_GPIOPinConfigure(GPIO_PJ0_U3RX);
ROM_GPIOPinConfigure(GPIO_PJ1_U3TX);
ROM_GPIOPinConfigure(GPIO_PJ4_U3RTS);
ROM_GPIOPinConfigure(GPIO_PJ5_U3CTS);
ROM_GPIOPinTypeUART(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5);
//
// Display UART configuration on the display.
//
GrStringDraw(&sContext, "Use BTool on PC", -1, 70, 40, 0);
GrStringDraw(&sContext, "Port:", -1, 70, 70, 0);
GrStringDraw(&sContext, "Baud:", -1, 70, 95, 0);
GrStringDraw(&sContext, "Data:", -1, 70, 120, 0);
GrStringDraw(&sContext, "Parity:", -1, 70, 145, 0);
GrStringDraw(&sContext, "Stop:", -1, 70, 170, 0);
GrStringDraw(&sContext, "Flow:", -1, 70, 195, 0);
GrStringDraw(&sContext, "Uart 0", -1, 150, 70, 0);
GrStringDraw(&sContext, "115,200 bps", -1, 150, 95, 0);
GrStringDraw(&sContext, "8 Bit", -1, 150, 120, 0);
GrStringDraw(&sContext, "None", -1, 150, 145, 0);
GrStringDraw(&sContext, "1 Bit", -1, 150, 170, 0);
GrStringDraw(&sContext, "CTS/RTS", -1, 150, 195, 0);
//
// Enable the (non-GPIO) peripherals used by this example. PinoutSet()
// already enabled GPIO Port A.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Configure the UART0 for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Configure the UART3 for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART3_BASE, ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Configure the UART3 with flow control.
//
UARTFlowControlSet(UART3_BASE, UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX);
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_IntEnable(INT_UART3);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
ROM_UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT);
//
// Loop forever passing data between UART0 and UART3.
//
while(1)
{
}
}
