void midiSetChannelVolume(uint8_t chan, uint8_t vol) {
if (chan > 15) return;
if (vol > 127) return;
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_CHAN_MSG | chan);
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_CHAN_VOLUME);
ROM_UARTCharPutNonBlocking(UART1_BASE, vol);
}
void midiSetChannelBank(uint8_t chan, uint8_t bank) {
if (chan > 15) return;
if (bank > 127) return;
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_CHAN_MSG | chan);
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_CHAN_BANK);
ROM_UARTCharPutNonBlocking(UART1_BASE, bank);
}
//*****************************************************************************
// MIDI method for VS1053 Chip
//*****************************************************************************
void midiSetInstrument(uint8_t chan, uint8_t inst){
if (chan > 15) return;
inst --;
if (inst > 127) return;
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_CHAN_PROGRAM | chan);
ROM_UARTCharPutNonBlocking(UART1_BASE, inst);
}
void midiNoteOn(uint8_t chan, uint8_t n, uint8_t vel) {
if (chan > 15) return;
if (n > 127) return;
if (vel > 127) return;
ROM_UARTCharPutNonBlocking(UART1_BASE, MIDI_NOTE_ON | chan);
ROM_UARTCharPutNonBlocking(UART1_BASE, n);
ROM_UARTCharPutNonBlocking(UART1_BASE, vel);
}
void send_dash (void) /* Send a dash and a space. */
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);
//SysCtlDelay(SysCtlClockGet() / (1000 * 3));
SysCtlDelay(1000000);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
SysCtlDelay(500000);
//note_on (FREQUENCY) ;
//pause (UNIT_TIME * 3) ;
//note_off () ;
ROM_UARTCharPutNonBlocking(UART0_BASE,'_');
ROM_UARTCharPutNonBlocking(UART0_BASE,' ');
pause (UNIT_TIME) ;
}
void
HardwareSerial::primeTransmit(unsigned long ulBase)
{
//
// Do we have any data to transmit?
//
if(!TX_BUFFER_EMPTY)
{
//
// Disable the UART interrupt. If we don't do this there is a race
// condition which can cause the read index to be corrupted.
//
ROM_IntDisable(g_ulUARTInt[uartModule]);
//
// Yes - take some characters out of the transmit buffer and feed
// them to the UART transmit FIFO.
//
while(!TX_BUFFER_EMPTY)
{
while(ROM_UARTSpaceAvail(ulBase) && !TX_BUFFER_EMPTY) {
ROM_UARTCharPutNonBlocking(ulBase,
txBuffer[txReadIndex]);
txReadIndex = (txReadIndex + 1) % SERIAL_BUFFER_SIZE;
}
}
//
// Reenable the UART interrupt.
//
ROM_IntEnable(g_ulUARTInt[uartModule]);
}
}
//*****************************************************************************
//
// 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));
}
}
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);
}
}
void UARTSend(uint32_t uBase, const uint8_t *pui8Buffer, uint32_t ui32Count) {
// Loop while there are more characters to send.
while(ui32Count--)
{
// Write the next character to the UART.
ROM_UARTCharPutNonBlocking(uBase, *pui8Buffer++);
}
}
//*****************************************************************************
//
// Send a string to the UART.
//
//*****************************************************************************
static void
UARTSend(const uint8_t *pui8Buffer, uint32_t ui32Count)
{
while(ui32Count--)
{
ROM_UARTCharPutNonBlocking(UART7_BASE, *pui8Buffer++);
UARTLed(LED2);
}
}
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 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);
}
}
//*****************************************************************************
// 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()
int dbg_putc_nb(char ch, void * userdata)
{
if(ROM_UARTSpaceAvail(UART0_BASE) && outputRB.nbytes == 0)
{
ROM_UARTCharPutNonBlocking(UART0_BASE, ch);
}
else
{
if(!RB_Full(outputRB, DBG_OUT_BUFFER_SIZE))
RB_Push(dbg_outputBuffer, outputRB, ch, DBG_OUT_BUFFER_SIZE);
}
return 0;
}
//*****************************************************************************
//
// Send a string to the UART.
//
//*****************************************************************************
void
UART0Send(const uint8_t *pui8Buffer, uint32_t ui32Count)
{
//
// Loop while there are more characters to send.
//
while(ui32Count--)
{
//
// Write the next character to the UART.
//
ROM_UARTCharPutNonBlocking(UART0_BASE, *pui8Buffer++);
}
}
//*****************************************************************************
//
// Take as many bytes from the transmit buffer as we have space for and move
// them into the USB UART's transmit FIFO.
//
//*****************************************************************************
static void
USBUARTPrimeTransmit(uint32_t ui32Base)
{
uint32_t ui32Read;
uint8_t ui8Char;
//
// If we are currently sending a break condition, don't receive any
// more data. We will resume transmission once the break is turned off.
//
if(g_bSendingBreak)
{
return;
}
//
// If there is space in the UART FIFO, try to read some characters
// from the receive buffer to fill it again.
//
while(ROM_UARTSpaceAvail(ui32Base))
{
//
// Get a character from the buffer.
//
ui32Read = USBBufferRead((tUSBBuffer *)&g_sRxBuffer, &ui8Char, 1);
//
// Did we get a character?
//
if(ui32Read)
{
//
// Place the character in the UART transmit FIFO.
//
ROM_UARTCharPutNonBlocking(ui32Base, ui8Char);
//
// Update our count of bytes transmitted via the UART.
//
g_ui32UARTTxCount++;
}
else
{
//
// We ran out of characters so exit the function.
//
return;
}
}
}
//*****************************************************************************
//
// Send a string to the UART.
//
//*****************************************************************************
void
UARTSend(const unsigned char *pucBuffer, unsigned long ulCount)
{
//
// Loop while there are more characters to send.
//
while(ulCount--)
{
//
// Write the next character to the UART.
//
ROM_UARTCharPutNonBlocking(UART0_BASE, *pucBuffer++);
}
}
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));
}
}
void morse (unsigned char ch)
{ /*--- MORSE CODE FUNCTION ---*/
unsigned int c ;
static unsigned int codes [64] = {
SPACE_MASK, /* Entry 0 = space (0x20) */
0, 0, 0, 0, 0, 0, 0, 0, /* ! " # $ % & " ( */
0, 0, 0, 115, 49, 106, 41, /* ) * + , - . / */
63, 62, 60, 56, 48, 32, 33, 35, /* 0 1 2 3 4 5 6 7 */
39, 47, 0, 0, 0, 0, 0, 76, /* 8 9 : ; < = > ? */
0, 6, 17, 21, 9, 2, 20, 11, /* @ A B C D E F G */
16, 4, 30, 13, 18, 7, 5, 15, /* H I J K L M N O */
22, 27, 10, 8, 3, 12, 24, 14, /* P Q R S T U V W */
25, 29, 19 /* X Y Z */
} ;
pause (0) ; /* Calibrate pause() function. */
c = toupper (ch) ; /* No lower-case Morse characters. */
ROM_UARTCharPutNonBlocking(UART0_BASE,c);
c -= ' ' ; /* Adjust for zero-based table. */
if (c > 58) /* If out of range, ignore it. */
return;
c = codes[c] ; /* Look up Morse pattern from table. */
if (c & SPACE_MASK) /* If the space bit is set.. */
{ /* ..send a word space and go on. */
word_space () ;
return;
}
while (c & BIT_MASK) /* Transmit one character. */
{ /*--- TRANSMIT EACH BIT ---*/
if (c & 1)
send_dash () ;
else
send_dot () ;
c >>= 1 ;
} /*--- TRANSMIT EACH BIT ---*/
ltr_space () ; /* Send a space following character. */
/*--- TRANSMIT COMPLETE STRING ---*/
} /*--- MORSE CODE FUNCTION ---*/
//*****************************************************************************
//
// Take as many bytes from the transmit buffer as there is space for and move
// them into the USB UART's transmit FIFO.
//
//*****************************************************************************
static void
USBUARTPrimeTransmit(void)
{
unsigned long ulRead;
unsigned char ucChar;
//
// If a break condition is currently being sent, don't receive any more
// data. Transmission will resume once the break is turned off.
//
if(g_bSendingBreak)
{
return;
}
//
// If there is space in the UART FIFO, try to read some characters
// from the receive buffer to fill it again.
//
while(ROM_UARTSpaceAvail(UART0_BASE))
{
//
// Get a character from the buffer.
//
ulRead = USBBufferRead(&g_sRxBuffer, &ucChar, 1);
//
// Was a character read?
//
if(ulRead)
{
//
// Place the character in the UART transmit FIFO.
//
ROM_UARTCharPutNonBlocking(UART0_BASE, ucChar);
}
else
{
//
// There are no more characters so exit the function.
//
return;
}
}
}
/*
* 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);
}
}
//*****************************************************************************
//
// 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);
}
void ltr_space (void) /* Produce a letter space. */
{
ROM_UARTCharPutNonBlocking(UART0_BASE,0x0A);
ROM_UARTCharPutNonBlocking(UART0_BASE,0x0D);
pause (UNIT_TIME * 2) ;
}
int uart_write(uart_t uart, char data)
{
int ret=ROM_UARTCharPutNonBlocking(UART0_BASE, data);
return ret;
}