void isr_uart_for_keyboard(unsigned int intNum){
unsigned int baseaddr = modulelist[intNum].baseAddr;
if(UARTIntPendingStatusGet(baseaddr) == UART_N0_INT_PENDING)
return;
unsigned int intval = UARTIntIdentityGet(baseaddr);
if (intval == UART_INTID_RX_THRES_REACH) {
for (int i=0;i<8;i++) {
volatile unsigned char tempval = HWREGB(baseaddr+UART_RHR);
((unsigned char *)&keyTouchpadMsg)[i] = tempval;
//UARTPutc(tempval);
}
if (isKeyTouchEvent(&keyTouchpadMsg)) {
if(keyTouchpadMsg.type & MSG_TYPE_KEY){
g_keycode = keyCode(keyTouchpadMsg.keycode);
atomicSet(&g_keyPushed);
if(keyhandler!=NULL)
keyhandler(g_keycode);
}
if (keyTouchpadMsg.type & MSG_TYPE_TOUCH) {
g_ts.x = g_tsRaw.x = keyTouchpadMsg.tscval & 0xffff;
g_ts.y = g_tsRaw.y = keyTouchpadMsg.tscval >>16;
ts_linear(&tsCalibration, (int *)&g_ts.x, (int *)&g_ts.y);
atomicSet(&g_touched);
}
if (keyTouchpadMsg.type & MSG_TYPE_KEYRESET) {
atomicSet(&g_keyRest);
}
}
}
void
USBUARTIntHandler(void)
{
unsigned int ulInts;
int lErrors;
//
// Get and clear the current interrupt source(s)
//
ulInts = UARTIntIdentityGet(SOC_UART_0_REGS);
/* Check if the cause is receiver line error condition.*/
if( UART_INTID_RX_LINE_STAT_ERROR == ulInts || UART_INTID_CHAR_TIMEOUT == ulInts)
{
UARTHandleError();
}
//
// Are we being interrupted because the TX FIFO has space available?
//
if(ulInts == UART_INTID_TX_THRES_REACH)
{
//
// Move as many bytes as we can into the transmit FIFO.
//
USBUARTPrimeTransmit(USB_UART_BASE);
//
// If the output buffer is empty, turn off the transmit interrupt.
//
if(!USBBufferDataAvailable(&g_sRxBuffer))
{
UARTIntDisable(USB_UART_BASE, UART_INTID_TX_THRES_REACH);
}
}
//
// Handle receive interrupts.
//
if(ulInts == UART_INTID_RX_THRES_REACH)
{
//
// Read the UART's characters into the buffer.
//
lErrors = ReadUARTData();
//
// Check to see if we need to notify the host of any errors we just
// detected.
//
CheckForSerialStateChange(&g_sCDCDevice, lErrors);
}
}
/*
** Interrupt Service Routine for UART.
*/
static void UARTIsr(void)
{
unsigned int rxErrorType = 0;
unsigned char rxByte = 0;
unsigned int intId = 0;
unsigned int idx = 0;
unsigned int i=0;
unsigned short rx_array[22];
//unsigned int rx_integer=0,rx_integer1=0;
/* Checking ths syource of UART interrupt. */
intId = UARTIntIdentityGet(SOC_UART_0_REGS);
//printf("intId=0x%x\n\r",intId);
switch(intId)
{
case UART_INTID_TX_THRES_REACH:
printf("UART_INTID_TX_THRES_REACH\n\r");
/*
** Checking if the entire transmisssion is complete. If this
** condition fails, then the entire transmission has been completed.
*/
if(currNumTxBytes < (sizeof(txArray) - 1))
{
txEmptyFlag = TRUE;
}
/*
** Disable the THR interrupt. This has to be done even if the
** transmission is not complete so as to prevent the Transmit
** empty interrupt to be continuously generated.
*/
UARTIntDisable(SOC_UART_0_REGS, UART_INT_THR);
break;
case UART_INTID_RX_THRES_REACH:
/*Берём один байт из UART */
//printf("UART_INTID_RX_THRES_REACH");
rx_array[0]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[1]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[2]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[3]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[4]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[5]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[6]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[7]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[8]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[9]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[10]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[11]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[12]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[13]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[14]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[15]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[16]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[17]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[18]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[19]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[20]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
rx_array[21]=UARTCharGetTimeout(SOC_UART_0_REGS, 100);
for(i=0;i<22;i++)
{
printf("rx_byte=%X\n\r",rx_array[i]);
}
//rxByte = UARTCharGetNonBlocking(SOC_UART_0_REGS);
//printf("rx_byte=%c\n\r",rxByte);
// printf("rx_byte=%x,rx_byte1=%x\n\r",rx_integer,rx_integer1);
//UARTCharPutNonBlocking(SOC_UART_0_REGS, rxByte);
break;
case UART_INTID_RX_LINE_STAT_ERROR:
printf("UART_INTID_RX_LINE_STAT_ERROR\n\r");
rxErrorType = UARTRxErrorGet(SOC_UART_0_REGS);
/* Check if Overrun Error has occured. */
if(rxErrorType & UART_LSR_RX_OE)
{
ConsoleUtilsPrintf("\r\nUART Overrun Error occured."
" Reading and Echoing all data in RX FIFO.\r\n");
/* Read the entire RX FIFO and the data in RX Shift register. */
for(idx = 0; idx < (RX_FIFO_SIZE + 1); idx++)
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
}
break;
}
/* Check if Break Condition has occured. */
else if(rxErrorType & UART_LSR_RX_BI)
{
ConsoleUtilsPrintf("\r\nUART Break Condition occured.");
}
/* Check if Framing Error has occured. */
else if(rxErrorType & UART_LSR_RX_FE)
{
ConsoleUtilsPrintf("\r\nUART Framing Error occured.");
}
/* Check if Parity Error has occured. */
else if(rxErrorType & UART_LSR_RX_PE)
{
ConsoleUtilsPrintf("\r\nUART Parity Error occured.");
}
ConsoleUtilsPrintf(" Data at the top of RX FIFO is: ");
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
break;
case UART_INTID_CHAR_TIMEOUT:
printf("UART_INTID_CHAR_TIMEOUT\n\r");
ConsoleUtilsPrintf("\r\nUART Character Timeout Interrupt occured."
" Reading and Echoing all data in RX FIFO.\r\n");
/* Read all the data in RX FIFO. */
while(TRUE == UARTCharsAvail(SOC_UART_0_REGS))
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
}
break;
default:
printf("default\n\r");
break;
}
}
void UART_0_ISR(void)
{
unsigned int rxErrorType = 0;
unsigned char rxByte = 0;
unsigned int intId = 0;
unsigned int idx = 0;
/* Checking ths source of UART interrupt. */
intId = UARTIntIdentityGet(SOC_UART_0_REGS);
switch(intId)
{
case UART_INTID_RX_THRES_REACH:
rxByte = UARTCharGetNonBlocking(SOC_UART_0_REGS);
UART_AddToRXBuffer(rxByte);
break;
case UART_INTID_RX_LINE_STAT_ERROR:
rxErrorType = UARTRxErrorGet(SOC_UART_0_REGS);
/* Check if Overrun Error has occured. */
if(rxErrorType & UART_LSR_RX_OE)
{
/* Read the entire RX FIFO and the data in RX Shift register. */
for(idx = 0; idx < (RX_FIFO_SIZE + 1); idx++)
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UART_AddToRXBuffer(rxByte);
}
break;
}
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
break;
case UART_INTID_CHAR_TIMEOUT:
/* Read all the data in RX FIFO. */
while(TRUE == UARTCharsAvail(SOC_UART_0_REGS))
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UART_AddToRXBuffer(rxByte);
}
break;
case (UART_INTID_TX_THRES_REACH):
/* UART transfer register and FIFO is empty */
if(UART_TX_remove != UART_TX_add)
{
while(UARTTxFIFOFullStatusGet(SOC_UART_0_REGS) == UART_TX_FIFO_NOT_FULL)
{
if(UART_TX_remove == UART_TX_add)
{
break;
}
UARTFIFOCharPut(SOC_UART_0_REGS, UART_TX_buffer[UART_TX_remove]);
UART_TX_remove = (UART_TX_remove + 1UL) % UART_TX_SIZE;
}
}
else
{
/* Disabling required TX Interrupts. */
UARTIntDisable(SOC_UART_0_REGS, UART_INT_THR);
}
break;
default:
break;
}
}
static void UARTIsr(void)
{
unsigned int rxErrorType = 0;
unsigned char rxByte = 0;
unsigned int intId = 0;
unsigned int idx = 0;
/* Checking ths source of UART interrupt. */
intId = UARTIntIdentityGet(SOC_UART_0_REGS);
switch(intId)
{
case UART_INTID_TX_THRES_REACH:
/*
** Checking if the entire transmisssion is complete. If this
** condition fails, then the entire transmission has been completed.
*/
if(currNumTxBytes < (sizeof(txArray) - 1))
{
txEmptyFlag = TRUE;
}
/*
** Disable the THR interrupt. This has to be done even if the
** transmission is not complete so as to prevent the Transmit
** empty interrupt to be continuously generated.
*/
UARTIntDisable(SOC_UART_0_REGS, UART_INT_THR);
break;
case UART_INTID_RX_THRES_REACH:
rxByte = UARTCharGetNonBlocking(SOC_UART_0_REGS);
UARTCharPutNonBlocking(SOC_UART_0_REGS, rxByte);
break;
case UART_INTID_RX_LINE_STAT_ERROR:
rxErrorType = UARTRxErrorGet(SOC_UART_0_REGS);
/* Check if Overrun Error has occured. */
if(rxErrorType & UART_LSR_RX_OE)
{
ConsoleUtilsPrintf("\r\nUART Overrun Error occured."
" Reading and Echoing all data in RX FIFO.\r\n");
/* Read the entire RX FIFO and the data in RX Shift register. */
for(idx = 0; idx < (RX_FIFO_SIZE + 1); idx++)
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
}
break;
}
/* Check if Break Condition has occured. */
else if(rxErrorType & UART_LSR_RX_BI)
{
ConsoleUtilsPrintf("\r\nUART Break Condition occured.");
}
/* Check if Framing Error has occured. */
else if(rxErrorType & UART_LSR_RX_FE)
{
ConsoleUtilsPrintf("\r\nUART Framing Error occured.");
}
/* Check if Parity Error has occured. */
else if(rxErrorType & UART_LSR_RX_PE)
{
ConsoleUtilsPrintf("\r\nUART Parity Error occured.");
}
ConsoleUtilsPrintf(" Data at the top of RX FIFO is: ");
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
break;
case UART_INTID_CHAR_TIMEOUT:
ConsoleUtilsPrintf("\r\nUART Character Timeout Interrupt occured."
" Reading and Echoing all data in RX FIFO.\r\n");
/* Read all the data in RX FIFO. */
while(TRUE == UARTCharsAvail(SOC_UART_0_REGS))
{
rxByte = UARTFIFOCharGet(SOC_UART_0_REGS);
UARTFIFOCharPut(SOC_UART_0_REGS, rxByte);
}
break;
default:
break;
}
}
