//frame=START_BYTE + CMD_ID + LENGTH_BYTE + payload (LSB first)
void UartRFIntHandler()
{
static uint8_t msgRF[20];
static uint32_t msgRFLen=0;
static uint32_t numBytes=0;
uint32_t status = ROM_UARTIntStatus(UART_RF,true);
ROM_UARTIntClear(UART_RF,status);
while (ROM_UARTCharsAvail(UART_RF))
{
char temp=ROM_UARTCharGetNonBlocking(UART_RF);
if (numBytes==0)
{
if (temp==START_BYTE)
{
msgRF[numBytes++]=temp;
}
continue;
}
msgRF[numBytes++]=temp;
if (numBytes==3)
msgRFLen = msgRF[2] + 3;
if ((numBytes==msgRFLen) && (msgRFLen!=0))
{
processRFMsg(msgRF);
numBytes=0;
msgRFLen=0;
}
}
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
void
UARTIntHandler(void)
{
uint32_t ui32Status;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
//
// Clear the asserted interrupts.
//
ROM_UARTIntClear(UART0_BASE, ui32Status);
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read the next character from the UART and write it back to the UART.
//
ROM_UARTCharPutNonBlocking(UART0_BASE,
ROM_UARTCharGetNonBlocking(UART0_BASE));
}
}
/*
* 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);
}
// Receive data from the UART
void
UART4Receive(uint8_t *pui8Buffer, uint32_t ui32Count)
{
int i = 0;
int j = 0;
//
// Loop while there are more data expected.
//
while(ui32Count)
{
//
// Read the next character from the UART and write it back to the UART.
//
if (ROM_UARTCharsAvail(UART4_BASE)) {
pui8Buffer[i++] = ROM_UARTCharGetNonBlocking(UART4_BASE);
ui32Count--;
j = 0;
}
j++;
if (j > RETRY_NUM) {
break;
}
}
}
/**
* The UART interrupt handler.
*/
void isr_uart0(void)
{
unsigned long ulStatus;
ulStatus = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, ulStatus);
/* Are we interrupted due to TX done */
if(ulStatus & UART_INT_TX)
{
if (config[UART_0].tx_cb(config[UART_0].arg) == 0){
UART0_IM_R &= ~UART_IM_TXIM;
}
}
/* Are we interrupted due to a recieved character */
if(ulStatus & (UART_INT_RX | UART_INT_RT))
{
while(ROM_UARTCharsAvail(UART0_BASE))
{
char cChar;
long lChar;
lChar = ROM_UARTCharGetNonBlocking(UART0_BASE);
cChar = (unsigned char)(lChar & 0xFF);
config[UART_0].rx_cb(config[UART_0].arg, cChar);
}
}
if (sched_context_switch_request) {
thread_yield();
}
}
void UART1IntHandler(void)
{
uint32_t ui32Status;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART1_BASE, true);
//
// Clear the asserted interrupts.
//
ROM_UARTIntClear(UART1_BASE, ui32Status);
PRINTF("INT:\n");
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART1_BASE)) {
//
// Read the next character from the UART and write it back to the UART.
//
uart1buffer[RX_PTR1]=ROM_UARTCharGetNonBlocking(UART1_BASE);
/// echo
ROM_UARTCharPutNonBlocking(UART0_BASE, uart1buffer[RX_PTR1]);
RX_PTR1++;
RX_PTR1 &= DIM_READ_BUFF - 1;
//UARTCharPutNonBlocking(UART1_BASE,
// dato);
}
}
//*****************************************************************************
//
// Read as many characters from the UART FIFO as possible and move them into
// the CDC transmit buffer.
//
// \return Returns UART error flags read during data reception.
//
//*****************************************************************************
static long
ReadUARTData(void)
{
long lChar, lErrors;
unsigned char ucChar;
unsigned long ulSpace;
//
// Clear the error indicator.
//
lErrors = 0;
//
// How much space is available in the buffer?
//
ulSpace = USBBufferSpaceAvailable(&g_sTxBuffer);
//
// Read data from the UART FIFO until there is none left or there is no
// more space in the receive buffer.
//
while(ulSpace && ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read a character from the UART FIFO into the ring buffer if no
// errors are reported.
//
lChar = ROM_UARTCharGetNonBlocking(UART0_BASE);
//
// If the character did not contain any error notifications,
// copy it to the output buffer.
//
if(!(lChar & ~0xFF))
{
ucChar = (unsigned char)(lChar & 0xFF);
USBBufferWrite(&g_sTxBuffer, &ucChar, 1);
//
// Decrement the number of bytes the buffer can accept.
//
ulSpace--;
}
else
{
//
// Update the error accumulator.
//
lErrors |= lChar;
}
}
//
// Pass back the accumulated error indicators.
//
return(lErrors);
}
void
UARTIntHandler(void) //This is triggered when the pc sends data - it is the virtual serial port interrupt.
{
ROM_UARTIntClear(UART0_BASE, ROM_UARTIntStatus(UART0_BASE, true));
while(ROM_UARTCharsAvail(UART0_BASE))
{
ROM_UARTCharPutNonBlocking(UART3_BASE,ROM_UARTCharGetNonBlocking(UART0_BASE));
}
}
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 UARTIntHandler(void){
uint32_t ui32Status;
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, ui32Status);
while(ROM_UARTCharsAvail(UART0_BASE)){
ROM_UARTCharPutNonBlocking(UART0_BASE, ROM_UARTCharGetNonBlocking(UART0_BASE));
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
SysCtlDelay(SysCtlClockGet() / (1000 * 3));
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
}
}
/*---------------------------------------------------------------------------*/
void UART0IntHandler(void)
{
unsigned long ulStatus;
ulStatus = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, ulStatus);
while(ROM_UARTCharsAvail(UART0_BASE))
{
uart0_input_handler(ROM_UARTCharGetNonBlocking(UART0_BASE));
}
}
void
UART3IntHandler(void) //This is triggered when the UART3 gets data - PC6/7
{
unsigned long ulStatus;
char character;
ulStatus = ROM_UARTIntStatus(UART3_BASE, true);
ROM_UARTIntClear(UART3_BASE, ulStatus);
while(ROM_UARTCharsAvail(UART3_BASE))
{
ROM_UARTCharPutNonBlocking(UART0_BASE,ROM_UARTCharGetNonBlocking(UART3_BASE));
}
}
/*
* This is the UART3RX interrupt handler for the Optode
* The handler simply writes characters out to the desktop.
*/
void UART3IntHandler(void)
{
unsigned long ulStatus;
// Get the interrupt status.
ulStatus = ROM_UARTIntStatus(UART3_BASE, true);
// Clear the asserted interrupts.
ROM_UARTIntClear(UART3_BASE, ulStatus);
// Loop while there are characters in the receive FIFO
while(ROM_UARTCharsAvail(UART3_BASE))
{
// Read the next character from the UART and write it to desktop.
ROM_UARTCharPutNonBlocking(UART1_BASE, ROM_UARTCharGetNonBlocking(UART3_BASE));
}
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
void
UARTIntHandler(void)
{
uint32_t ui32Status;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
//
// Clear the asserted interrupts.
//
ROM_UARTIntClear(UART0_BASE, ui32Status);
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read the next character from the UART and write it back to the UART.
//
ROM_UARTCharPutNonBlocking(UART0_BASE,
ROM_UARTCharGetNonBlocking(UART0_BASE));
//
// Blink the LED to show a character transfer is occuring.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
//
// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.
//
SysCtlDelay(SysCtlClockGet() / (1000 * 3));
//
// Turn off the LED
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
}
}
void UartGPSIntHandler()
{
uint32_t status = ROM_UARTIntStatus(UART_GPS,true);
static uint32_t numBytes=0;
ROM_UARTIntClear(UART_GPS,status);
while (ROM_UARTCharsAvail(UART_GPS))
{
if ((MsgBuf[numBytes++]=ROM_UARTCharGetNonBlocking(UART_GPS))=='\n')
{
HandleGPSMsg(MsgBuf);
flagNewGPSMsg=true;
msgLen=numBytes;
numBytes = 0;
}
if (numBytes==MAX_GPS_MSG_BYTE)
numBytes=0;
}
}
/**
* The UART interrupt handler.
*/
void isr_uart0(void)
{
unsigned long ulStatus;
ulStatus = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, ulStatus);
/* Are we interrupted due to a recieved character */
if(ulStatus & (UART_INT_RX | UART_INT_RT))
{
while(ROM_UARTCharsAvail(UART0_BASE))
{
long lchar = ROM_UARTCharGetNonBlocking(UART0_BASE);
config[UART_0].rx_cb(config[UART_0].arg, (uint8_t)lchar);
}
}
if (sched_context_switch_request) {
thread_yield();
}
}
void
UARTIntHandler(void)
{
uint32_t ui32Status;
ui32Status = ROM_UARTIntStatus(UART7_BASE, true);
ROM_UARTIntClear(UART7_BASE, ui32Status);
while(ROM_UARTCharsAvail(UART7_BASE))
{
// ROM_UARTCharPutNonBlocking(UART7_BASE,ROM_UARTCharGetNonBlocking(UART7_BASE));
UARTLed(LED1);
message[ptr] = ROM_UARTCharGetNonBlocking(UART7_BASE);
if(message[ptr] == '\n')
{
if(ptr == 32) /* hard coded message size ;-) */
{
/* answer first, then display */
transform_message(message);
for(uint8_t i = 0; i < ptr; ++i)
{
UARTSend(&message[i],1);
}
UARTSend((const uint8_t*) '\n',1);
}
ptr = 0;
}
else
{
++ptr;
if(ptr >= 64)
{
ptr = 0;
}
}
}
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
void UARTIntHandler(void)
{
uint32_t ui32Status;
char data;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
UARTIntClear(UART0_BASE, ui32Status);
if ((ui32Status&UART_INT_RX) == UART_INT_RX)
{
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read the next character from the UART and write it back to the UART.
//
data = (char)ROM_UARTCharGetNonBlocking(UART0_BASE);
OSQueuePost(qUART, data);
}
}
if ((ui32Status&UART_INT_TX) == UART_INT_TX)
{
ROM_UARTIntDisable(UART0_BASE, UART_INT_TX);
// Call the keyboard analysis task
OSSemPost(sUART);
}
// ************************
// Interrupt Exit
// ************************
OS_INT_EXIT_EXT();
// ************************
}
//*****************************************************************************
// UART interrupt handler.
//*****************************************************************************
void UART0_IntHandler(void)
{
uint32_t status = ROM_UARTIntStatus(UART0_BASE, true);
ROM_UARTIntClear(UART0_BASE, status);
// drain rx FIFO
while(ROM_UARTCharsAvail(UART0_BASE))
{
char ch = ROM_UARTCharGetNonBlocking(UART0_BASE);
if(inputRB.nbytes < DBG_IN_BUFFER_SIZE)
{
RB_Push(dbg_inputBuffer, inputRB, ch, DBG_IN_BUFFER_SIZE);
if(ch == '\r')
++newlines;
}
else
{
// Attempt to report overflow and clear buffer
// Must do this to avoid condition where buffer is full and code
// is waiting for a newline that can not fit in the buffer.
dbg_putstr_nb("\rRXOVF\r\n");
RB_Clear(inputRB);
newlines = 0;
}
}
// feed tx FIFO
// Echo received characters
while(ROM_UARTSpaceAvail(UART0_BASE) && echoPtr != inputRB.wp)
{
ROM_UARTCharPutNonBlocking(UART0_BASE, dbg_inputBuffer[echoPtr]);
echoPtr = (echoPtr + 1) % DBG_IN_BUFFER_SIZE;
}
// Write pending characters
while(ROM_UARTSpaceAvail(UART0_BASE) && outputRB.nbytes > 0)
{
ROM_UARTCharPutNonBlocking(UART0_BASE, RB_Front(dbg_outputBuffer, outputRB));
RB_Pop(outputRB, DBG_OUT_BUFFER_SIZE);
}
} // UART0_IntHandler()
//*****************************************************************************
//
// The UART1 interrupt handler.
// Get response from XBee (UART1), print to terminal (UART0)
//
//*****************************************************************************
void
UART1IntHandler(void)
{
unsigned char x;
uint32_t ui32Status;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART1_BASE, true);
//
// Clear the asserted interrupts.
//
ROM_UARTIntClear(UART1_BASE, ui32Status);
UARTprintf("Response:'");
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART1_BASE))
{
//
// Read the next character from the UART and write it back to the UART.
// if special character print out the integer for it
//
x=ROM_UARTCharGetNonBlocking(UART1_BASE);
if(x<' ' | x>'~')
{
UARTprintf("/%d",(int)x);
//ROM_UARTCharPutNonBlocking(UART0_BASE,x);
}
else
{
ROM_UARTCharPutNonBlocking(UART0_BASE,x);
}
}
UARTprintf("'\n");
}
void
UARTBridge(uint32_t SOURCE, uint32_t DESTINATION)
{
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(SOURCE))
{
//
// Read the next character from the UART and write it back to the UART.
//
ROM_UARTCharPutNonBlocking(DESTINATION,
ROM_UARTCharGetNonBlocking(SOURCE));
}
//
// Blink the LED to show a character transfer is occuring.
//
if (SOURCE == UART0_BASE)
GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE, LED_BLUE);
else
GPIOPinWrite(GPIO_PORTF_BASE, LED_GREEN, LED_GREEN);
GPIOPinWrite(GPIO_PORTF_BASE, LED_BLUE|LED_GREEN, 0);
}
static inline void irq_handler(uart_t uartnum, unsigned long ulBase, unsigned long ulRxInt)
{
unsigned long ulStatus;
ulStatus = ROM_UARTIntStatus(ulBase, true);
ROM_UARTIntClear(ulBase, ulStatus);
/* Are we interrupted due to a recieved character */
if(ulStatus & (UART_INT_RX | UART_INT_RT))
{
while(ROM_UARTCharsAvail(ulBase))
{
char cChar;
long lChar;
lChar = ROM_UARTCharGetNonBlocking(ulBase);
cChar = (unsigned char)(lChar & 0xFF);
config[uartnum].rx_cb(config[uartnum].arg, cChar);
}
}
if (sched_context_switch_request) {
thread_yield();
}
}
void UpstreamUARTIntHandler(void) {
uint32_t ui32Status;
uint8_t data;
static luxframe_t* lframe;
static uint8_t lbuffer[LUX_MAX_FRAME_SIZE + 8];
// Get the interrrupt status.
ui32Status = ROM_UARTIntStatus(UART1_BASE, true);
// Clear the asserted interrupts.
ROM_UARTIntClear(UART1_BASE, ui32Status);
// Loop while there are characters in the receive FIFO.
while(ROM_UARTCharsAvail(UART1_BASE)){
data = ROM_UARTCharGetNonBlocking(UART1_BASE);
// Read the next character from the UART and write it back to the UART.
//ROM_UARTCharPutNonBlocking(UART1_BASE, data);
// Update lux framing
lframe = lux_usart_poll(data);
if(lframe){
lux_calculate_crc(lframe);
lux_serialize(lframe, lbuffer);
//UARTSend(UART0_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART1_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART2_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART3_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART4_BASE, lbuffer, lframe->length + 6);
UARTSend(UART5_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART6_BASE, lbuffer, lframe->length + 6);
//UARTSend(UART7_BASE, lbuffer, lframe->length + 6);
}
// Blink the LED to show a character transfer is occuring.
GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_6, GPIO_PIN_6);
// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.
SysCtlDelay(SysCtlClockGet() / (1000 * 3));
// Turn off the LED
GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_6, 0);
}
}
void UART3IntHandler(void)
{
ROM_UARTIntClear(UART3_BASE, ROM_UARTIntStatus(UART3_BASE, true));
while(ROM_UARTCharsAvail(UART3_BASE))
{
char character;
character = ROM_UARTCharGetNonBlocking(UART3_BASE);
switch ( nmea_state ) // evaluate expression
{
case ( 1 ): // wait for 'G'
if ( character == 0x47) nmea_state++;
break;
case ( 2 ): // wait for 'G'
if ( character == 0x47)
nmea_state++;
else
nmea_state=1;
break;
case ( 3 ): // wait for 'A'
if ( character == 0x41)
nmea_state++;
else
nmea_state=1;
break;
case ( 4 ): // wait for ',' //First comma
if ( character == 0x2c) nmea_state++;
break;
case ( 5 ): // wait for ',' //comma after time
if ( character == 0x2c) nmea_state++;
break;
case ( 6 ):
if ( character == 0x2c) nmea_state=1; //don't have a fix
else {nmea_state++; latitude[0] = character;}
break;
case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17: case 18:
if (character == 0x2c) {nmea_state = 19;}
else {latitude[nmea_state - 6] = character; nmea_state++;}
break;
case ( 19 ):
if (character == 'S') {neglat=true;}
nmea_state++;
break;
case ( 20 ): //after latitude n/s
if ( character == 0x2c) nmea_state++;
break;
case ( 21 ):
nmea_state++;
longitude[0] = character;
break;
case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 29: case 30: case 31: case 32: case 33:
if (character == 0x2c) {nmea_state = 34;}
else {longitude[nmea_state - 21] = character; nmea_state++;}
break;
case 34:
if (character == 'W') {neglong=true;}
nmea_state++;
break;
case 35:
haveFix= true;
nmea_state=1;
break;
default:
nmea_state = 1; // we'll never and up here, but in case of a brownout make sure we start at the beginning
break;
}
}
}
//*****************************************************************************
//
// Read as many characters from the UART FIFO as we can and move them into
// the CDC transmit buffer.
//
// \return Returns UART error flags read during data reception.
//
//*****************************************************************************
static int32_t
ReadUARTData(void)
{
int32_t i32Char, i32Errors;
uint8_t ui8Char;
uint32_t ui32Space;
//
// Clear our error indicator.
//
i32Errors = 0;
//
// How much space do we have in the buffer?
//
ui32Space = USBBufferSpaceAvailable((tUSBBuffer *)&g_sTxBuffer);
//
// Read data from the UART FIFO until there is none left or we run
// out of space in our receive buffer.
//
while(ui32Space && ROM_UARTCharsAvail(USB_UART_BASE))
{
//
// Read a character from the UART FIFO into the ring buffer if no
// errors are reported.
//
i32Char = ROM_UARTCharGetNonBlocking(USB_UART_BASE);
//
// If the character did not contain any error notifications,
// copy it to the output buffer.
//
if(!(i32Char & ~0xFF))
{
ui8Char = (uint8_t)(i32Char & 0xFF);
USBBufferWrite((tUSBBuffer *)&g_sTxBuffer,
(uint8_t *)&ui8Char, 1);
//
// Decrement the number of bytes we know the buffer can accept.
//
ui32Space--;
}
else
{
#ifdef DEBUG
//
// Increment our receive error counter.
//
g_ui32UARTRxErrors++;
#endif
//
// Update our error accumulator.
//
i32Errors |= i32Char;
}
//
// Update our count of bytes received via the UART.
//
g_ui32UARTRxCount++;
}
//
// Pass back the accumulated error indicators.
//
return(i32Errors);
}
// main routine
int main(void) {
// enable lazy stacking
ROM_FPUEnable();
ROM_FPULazyStackingEnable();
// run from crystal, 80 MHz
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
// enable peripherals
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
// set UART pins
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
// init PORTB
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIO_PORTB_DIR_R = 0x00;
GPIO_PORTB_DEN_R = 0xff;
// configure uart
ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
// Enable interrupts to the processor. - not sure if this is needed...
ROM_IntMasterEnable();
// main loop
while (1) {
if (ROM_UARTCharsAvail(UART0_BASE)) {
unsigned char cmd;
cmd = ROM_UARTCharGetNonBlocking(UART0_BASE);
switch (cmd) {
case SUMP_RESET:
break;
case SUMP_ARM:
doticksampling();
break;
case SUMP_QUERY:
uart_puts("1ALS");
break;
case SUMP_GET_METADATA:
// device name
uart_putch(0x01);
uart_puts(VERSION);
uart_putch(0x00);
// amount of sample memory available (bytes)
sump_sendmeta_uint32(0x21, BUFFERSIZE);
// maximum sample rate (hz)
sump_sendmeta_uint32(0x23, MAX_SAMPLERATE);
// number of usable probes (short)
sump_sendmeta_uint8(0x40, 0x08);
// protocol version (short)
sump_sendmeta_uint8(0x41, 0x02);
// end of meta data
uart_putch(0x00);
break;
case SUMP_SET_DIVIDER: {
/*
Set Divider (80h)
When x is written, the sampling frequency is set to f = clock / (x + 1)
*/
unsigned long clock = 100000000; //no idea where this comes from...
//these three bytes are our clock divider - lsb first
unsigned char b0 = ROM_UARTCharGet(UART0_BASE);
unsigned char b1 = ROM_UARTCharGet(UART0_BASE);
unsigned char b2 = ROM_UARTCharGet(UART0_BASE);
ROM_UARTCharGet(UART0_BASE); //eat last byte
unsigned long rate = b0 | (b1 << 8) | (b2 << 16);
rate = clock / (rate+1);
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / rate);
break;
}
// long commands.. consume bytes from uart
case 0xC0:
case 0xC4:
case 0xC8:
case 0xCC:
case 0xC1:
case 0xC5:
case 0xC9:
case 0xCD:
case 0xC2:
case 0xC6:
case 0xCA:
case 0xCE:
case 0x81:
case 0x82:
ROM_UARTCharGet(UART0_BASE);
ROM_UARTCharGet(UART0_BASE);
ROM_UARTCharGet(UART0_BASE);
ROM_UARTCharGet(UART0_BASE);
break;
}
}
}
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
void
UARTIntHandler(void)
{
uint32_t ui32Status;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
//
// Clear the asserted interrupts.
//
ROM_UARTIntClear(UART0_BASE, ui32Status);
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.
//
SysCtlDelay(g_ui32SysClock / (1000 * 3));
buffer[location] = ROM_UARTCharGetNonBlocking(UART0_BASE); //Place next character into the buffer array
if (location == 0 && (buffer[0] == 27 || buffer[0] == '\r')) //Check for the <ESC> or <ENTER> character
{
UARTPrompt(); //Prompt the user again
} else {
location = location + 1; //Increase the array index
ROM_UARTCharPut(UART0_BASE, buffer[location-1]); //Echo last character on screen
if (buffer[location - 1] == 27 || buffer[location - 1] == '\r') //Check for the <ESC> or <ENTER> character
{
buffer[location - 1] = '\0'; //Replace last character with a null char
UARTSend("\033[2J\033[12;30H", 12); //Clear screen and move cursor to middle-ish
UARTSend(buffer, location); //Use UARTSend() to print contents of buffer
location = 0; //Reset array index
}
}
//
// Blink the LED to show a character transfer is occuring.
//
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);
//
// Delay for 1 millisecond. Each SysCtlDelay is about 3 clocks.
//
SysCtlDelay(g_ui32SysClock / (1000 * 3));
//
// Turn off the LED
//
GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);
}
}
//*****************************************************************************
//
// Set up the system, initialize the UART, Graphics, and CAN. Then poll the
// UART for data. If there is any data send it, if there is any thing received
// print it out to the UART. If there are errors call the error handling
// function.
//
//*****************************************************************************
int
main(void)
{
//
// 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_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |
SYSCTL_OSC_MAIN);
//
// Initialize the UART
//
ConfigureUART();
//
// Initialize the graphical display
//
InitGraphics();
//
// Initialize CAN0
//
InitCAN0();
//
// Print welcome message
//
UARTprintf("\nCAN Example App\n");
UARTprintf("Type something to see it show up on the other terminal: \n\n");
//
// Poll UART for data, transmit across CAN when something is entered
//
while(1)
{
//
// If the flag is set, that means that the RX interrupt occurred and
// there is a message ready to be read from the CAN
//
if(g_bRXFlag)
{
//
// Reuse the same message object that was used earlier to configure
// the CAN for receiving messages. A buffer for storing the
// received data must also be provided, so set the buffer pointer
// within the message object.
//
g_sCAN0RxMessage.pui8MsgData = (uint8_t *) &g_ui8RXMsgData;
//
// Read the message from the CAN. Message object RXOBJECT is used
// (which is not the same thing as CAN ID). The interrupt clearing
// flag is not set because this interrupt was already cleared in
// the interrupt handler.
//
CANMessageGet(CAN0_BASE, RXOBJECT, &g_sCAN0RxMessage, 0);
//
// Clear the pending message flag so that the interrupt handler can
// set it again when the next message arrives.
//
g_bRXFlag = 0;
//
// Check to see if there is an indication that some messages were
// lost.
//
if(g_sCAN0RxMessage.ui32Flags & MSG_OBJ_DATA_LOST)
{
UARTprintf("\nCAN message loss detected\n");
}
//
// Print the received character to the UART terminal
//
UARTprintf("%c", g_ui8RXMsgData);
//
// Print the received character to the display,
// clear line with spaces
//
GrStringDrawCentered(&g_sContext, "RX Data", -1,
GrContextDpyWidthGet(&g_sContext) / 2,
SCREENLINE2, 0);
GrStringDrawCentered(&g_sContext, (const char *) &g_ui8RXMsgData,
1, GrContextDpyWidthGet(&g_sContext) / 2,
SCREENLINE3, true);
GrFlush(&g_sContext);
}
else
{
//
// Error Handling
//
if(g_ui32ErrFlag != 0)
{
CANErrorHandler();
}
//
// See if there is something new to transmit
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read the next character from the UART terminal
//
g_ui8TXMsgData = ROM_UARTCharGetNonBlocking(UART0_BASE);
//
// Write the character to the display
// clear line with spaces
//
GrStringDrawCentered(&g_sContext, "TX Data", -1,
GrContextDpyWidthGet(&g_sContext) / 2,
SCREENLINE4, true);
GrStringDrawCentered(&g_sContext,
(const char *)&g_ui8TXMsgData, 1,
GrContextDpyWidthGet(&g_sContext) / 2,
SCREENLINE5, true);
GrFlush(&g_sContext);
//
// Send the CAN message using object number TXOBJECT (not the
// same thing as CAN ID, which is also TXOBJECT in this
// example). This function will cause the message to be
// transmitted right away.
//
CANMessageSet(CAN0_BASE, TXOBJECT, &g_sCAN0TxMessage,
MSG_OBJ_TYPE_TX);
}
}
}
}