void Sysdelay(unsigned int milliSec)
{
#ifdef DELAY_USE_INTERRUPTS
unsigned int countVal = TIMER_OVERFLOW - (milliSec * TIMER_1MS_COUNT);
DMTimerCounterSet(SOC_DMTIMER_7_REGS, countVal);
flagIsr = FALSE;
/* Enable the DMTimer interrupts */
DMTimerIntEnable(SOC_DMTIMER_7_REGS, DMTIMER_INT_OVF_EN_FLAG);
/* Start the DMTimer */
DMTimerEnable(SOC_DMTIMER_7_REGS);
while(FALSE == flagIsr) ;
/* Disable the DMTimer interrupts */
DMTimerIntDisable(SOC_DMTIMER_7_REGS, DMTIMER_INT_OVF_EN_FLAG);
#else
while(milliSec != 0)
{
DMTimerCounterSet(SOC_DMTIMER_7_REGS, 0);
DMTimerEnable(SOC_DMTIMER_7_REGS);
while(DMTimerCounterGet(SOC_DMTIMER_7_REGS) < TIMER_1MS_COUNT);
DMTimerDisable(SOC_DMTIMER_7_REGS);
milliSec--;
}
#endif
}
void SysDelayTimerSetup(void)
{
#ifdef DELAY_USE_INTERRUPTS
/* This function will enable clocks for the DMTimer7 instance */
DMTimer7ModuleClkConfig();
/* Registering DMTimerIsr */
IntRegister(SYS_INT_TINT7, DMTimerIsr);
/* Set the priority */
IntPrioritySet(SYS_INT_TINT7, 0, AINTC_HOSTINT_ROUTE_IRQ);
/* Enable the system interrupt */
IntSystemEnable(SYS_INT_TINT7);
DMTimerCounterSet(SOC_DMTIMER_7_REGS, 0);
/* Configure the DMTimer for Auto-reload and compare mode */
DMTimerModeConfigure(SOC_DMTIMER_7_REGS, DMTIMER_ONESHOT_NOCMP_ENABLE);
#else
DMTimer7ModuleClkConfig();
DMTimerModeConfigure(SOC_DMTIMER_7_REGS, DMTIMER_ONESHOT_NOCMP_ENABLE);
#endif
}
/*
** Timer 3 ISR
*/
static void Timer3Isr(void)
{
/* Clear the status of the interrupt flags */
DMTimerIntStatusClear(SOC_DMTIMER_3_REGS, DMTIMER_INT_MAT_EN_FLAG);
DMTimerDisable(SOC_DMTIMER_3_REGS);
DMTimerCounterSet(SOC_DMTIMER_3_REGS, 0);
touchRelease = 1;
}
/**
* /brief This function starts the timer.
*
* /milliSec Maximum value = TIMER_OVERFLOW/TIMER_1MS_COUNT.
*
* /NOTE SysDelay functionality cannot be used till SysStopTimer is called.
*/
void SysStartTimer(unsigned int milliSec)
{
#ifdef DELAY_USE_INTERRUPTS
unsigned int countVal = TIMER_OVERFLOW - (milliSec * TIMER_1MS_COUNT);
DMTimerCounterSet(SOC_DMTIMER_7_REGS, countVal);
flagIsr = FALSE;
/* Enable the DMTimer interrupts */
DMTimerIntEnable(SOC_DMTIMER_7_REGS, DMTIMER_INT_OVF_EN_FLAG);
/* Start the DMTimer */
DMTimerEnable(SOC_DMTIMER_7_REGS);
#else
DMTimerCounterSet(SOC_DMTIMER_7_REGS, 0);
DMTimerEnable(SOC_DMTIMER_7_REGS);
flagIsr = milliSec;
#endif
}
/*
** Setup the timer for one-shot and compare mode.
*/
static void DMTimerSetUp(void)
{
/* Load the counter with the initial count value */
DMTimerCounterSet(SOC_DMTIMER_2_REGS, TIMER_INITIAL_COUNT);
/* Load the load register with the reload count value */
DMTimerReloadSet(SOC_DMTIMER_2_REGS, TIMER_RLD_COUNT);
/* Configure the DMTimer for Auto-reload and compare mode */
DMTimerModeConfigure(SOC_DMTIMER_2_REGS, DMTIMER_AUTORLD_NOCMP_ENABLE);
}
/*
** Configures the Timer4 for 32 bit
*/
void Timer4Config(void)
{
/* Load the counter with the initial count value */
DMTimerCounterSet(SOC_DMTIMER_4_REGS, TIMER4_INITIAL_COUNT);
/* Load the load register with the reload count value */
DMTimerReloadSet(SOC_DMTIMER_4_REGS, TIMER_200MS_DELAY);
/* Configure the DMTimer for one shot mode */
DMTimerModeConfigure(SOC_DMTIMER_4_REGS, DMTIMER_AUTORLD_NOCMP_ENABLE);
Timer4Stop();
}
/*
** Configures the Timer2 for 32 bit
*/
void Timer2Config(void)
{
/* Load the counter with the initial count value */
DMTimerCounterSet(SOC_DMTIMER_2_REGS, TIMER_INITIAL_COUNT);
/* Load the load register with the reload count value */
//DMTimerReloadSet(SOC_DMTIMER_2_REGS, TIMER_RLD_COUNT);
/* Configure the DMTimer for one shot mode */
DMTimerModeConfigure(SOC_DMTIMER_2_REGS, DMTIMER_ONESHOT_NOCMP_ENABLE);
Timer2Stop();
}
/*
** Timer 2 Interrupt Service Routine
*/
static void Timer2Isr(void)
{
static unsigned int index = 0;
/* Clear the status of the interrupt flags */
DMTimerIntStatusClear(SOC_DMTIMER_2_REGS, DMTIMER_INT_OVF_EN_FLAG);
tmr2Flag = TRUE;
DMTimerCounterSet(SOC_DMTIMER_2_REGS, timerCount[index++%10]);
DMTimerEnable(SOC_DMTIMER_2_REGS);
}
unsigned int SysTimer(unsigned int flag)
{
unsigned int timeInTicks=0;
if(flag)
{
DMTimerCounterSet(SOC_DMTIMER_7_REGS, 0);
DMTimerEnable(SOC_DMTIMER_7_REGS);
}
else
{
DMTimerDisable(SOC_DMTIMER_7_REGS);
timeInTicks = DMTimerCounterGet(SOC_DMTIMER_7_REGS);
}
return timeInTicks;
}
static void TouchCalibrate(void)
{
unsigned char i;
POINT stDisplayPoint[3] = {{0, 0},{LCD_WIDTH, 0}, {0, LCD_HEIGHT}};
POINT stTouchScreenPoint[3];
UARTPuts("Touch at Right bottom", -1);
while(!IsTSPress);
IsTSPress = 1;
for(i = 0; i < 3; i++)
{
while(DMTimerCounterGet(SOC_DMTIMER_2_REGS) < 0xffffff);
DMTimerDisable(SOC_DMTIMER_2_REGS);
DMTimerCounterSet(SOC_DMTIMER_2_REGS, 0);
stTouchScreenPoint[i].x = x_val[0];
stTouchScreenPoint[i].y = y_val[0];
if(i == 0)
{
UARTPuts("\r\n", -1);
UARTPuts("Touch at Left bottom", -1);
}
else if(i == 1)
{
UARTPuts("\r\n", -1);
UARTPuts("Touch at Right Top", -1);
}
else
{
UARTPuts("\r\n", -1);
}
}
setCalibrationMatrix( stDisplayPoint, stTouchScreenPoint, &stMatrix);
}
/*
** Configures the Timer6 for 32 bit
*/
void Timer6Config(void)
{
/* Register DMTimer6 interrupts */
Timer6IntRegister();
/* Enable DMTimer6 module clocks */
DMTimer6ModuleClkConfig();
/* Set counter value to overflow in 15 seconds */
DMTimerCounterSet(SOC_DMTIMER_6_REGS, TIMER6_INITIAL_COUNT);
/* Configure the DMTimer for one shot mode */
DMTimerModeConfigure(SOC_DMTIMER_6_REGS, DMTIMER_ONESHOT_NOCMP_ENABLE);
/* Stop the timer */
Timer6Stop();
/* Enable DMTimer6 interrupts */
Timer6IntEnable();
}
/*
** Configure and start the Timer
*/
static void TimerSetupAndEnable(void)
{
/* This function will enable clocks for the DMTimer2 instance */
DMTimer2ModuleClkConfig();
/* Load the counter with the initial count value */
DMTimerCounterSet(TIMER_INST_BASE, TIMER_INITIAL_COUNT);
/* Load the load register with the reload count value */
DMTimerReloadSet(TIMER_INST_BASE, TIMER_RLD_COUNT);
/* Configure the DMTimer for Auto-reload and compare mode */
DMTimerModeConfigure(TIMER_INST_BASE, DMTIMER_AUTORLD_NOCMP_ENABLE);
/* Enable the DMTimer interrupts */
DMTimerIntEnable(TIMER_INST_BASE, DMTIMER_INT_OVF_EN_FLAG);
/* Start the DMTimer */
DMTimerEnable(TIMER_INST_BASE);
IntSystemEnable(TIMER_INT_NUM);
}
/*
** This function configures given source for standby wakeup.
*/
void enableStandbyWakeSrc(unsigned int wakeSource)
{
/* Disable interrupt of SW pin to avoid wake through SW for other src sel */
GPIOPinIntDisable(GPIO_INST_BASE_SW, GPIO_INT_LINE_1, GPIO_SW_PIN_NUM);
GPIOPinIntDisable(GPIO_INST_BASE_SW, GPIO_INT_LINE_2, GPIO_SW_PIN_NUM);
/* IO Pad Configuration */
pmStdbySrcIOPin.padConfig.slewRate = 0;
pmStdbySrcIOPin.padConfig.mode = 7;
pmStdbySrcIOPin.padConfig.type = CONTROL_CONF_RXACTIVE;
pmStdbySrcIOPin.padConfig.pullEnable = CONTROL_CONF_PULLUDDISABLE;
pmStdbySrcIOPin.padConfig.pullSel = 0;
/* GPIO Pin Configuration */
pmStdbySrcIOPin.gpioConfig.dir = GPIO_DIR_INPUT;
pmStdbySrcIOPin.gpioConfig.debouEnable = GPIO_DEBOUNCE_FUNC_DISABLE;
pmStdbySrcIOPin.gpioConfig.intrEnable = 1;
pmStdbySrcIOPin.gpioConfig.intrType = GPIO_INT_TYPE_BOTH_EDGE;
switch(wakeSource)
{
case WAKE_SOURCE_TSC:
/* Skip Touchscreen for Enable/Disable Module */
ModuleListConfig(FALSE, CLK_ADC_TSC);
/* Enable hardware pen event interrupt */
TSCADCEventInterruptEnable(TSC_ADC_INSTANCE,
TSCADC_ASYNC_HW_PEN_EVENT_INT);
break;
case WAKE_SOURCE_UART:
/* Skip GPIO for Enable/Disable Module */
ModuleListConfig(FALSE, CLK_GPIO1);
/* Enable GPIO Interrupt on UART RXD Pin */
pmStdbySrcIOPin.ioPadOff = GPIO_UART_RDX_PAD_OFFSET;
pmStdbySrcIOPin.pinNum = GPIO_UART_RDX_PIN_NUM;
pmStdbySrcIOPin.gpioBaseAddr = GPIO_INST_BASE_UART_RXD;
pmStdbySrcIOPin.gpioConfig.intrLine = GPIO_UART_RXD_INTR_LINE;
pmStdbySrcIOPin.intrNum = GPIO_UART_RXD_SYS_INT_NUM;
pmStdbySrcIOPin.gpioIsr = gpioStdbyUartIsr;
DemoGpioPinStandbySrcConfig(&pmStdbySrcIOPin);
break;
case WAKE_SOURCE_TMR:
/* Skip Timer for Enable/Disable Module */
ModuleListConfig(FALSE, CLK_TIMER6);
ConsoleUtilsPrintf("\r\n Peripheral domain Timer is configured as"
"wake source.\r\n\r\n ... system will release "
"from standby in 20 seconds ...\r\n\r\n");
/* Configure Timer 6 */
Timer6Config();
/* Set the counter value */
DMTimerCounterSet(DMTIMER6_BASE_ADDR, TIMER_OVRFLW_20_SECOND_24MHZ);
/* Start the timer */
Timer6Start();
break;
case WAKE_SOURCE_GPIO:
/* Skip GPIO for Enable/Disable Module */
ModuleListConfig(FALSE, CLK_GPIO0);
/* Enable GPIO Interrupt on UART RXD Pin */
pmStdbySrcIOPin.ioPadOff = GPIO_SW_PAD_OFFSET;
pmStdbySrcIOPin.pinNum = GPIO_SW_PIN_NUM;
pmStdbySrcIOPin.gpioBaseAddr = GPIO_INST_BASE_SW;
pmStdbySrcIOPin.gpioConfig.intrLine = GPIO_SW_INTR_LINE;
pmStdbySrcIOPin.intrNum = GPIO_SW_SYS_INT_NUM;
pmStdbySrcIOPin.gpioIsr = gpioStdbyGPIOIsr;
DemoGpioPinStandbySrcConfig(&pmStdbySrcIOPin);
break;
case WAKE_SOURCE_RTC:
/* Include GPIO for Enable/Disable Module */
ModuleListConfig(FALSE, CLK_RTC);
ConsoleUtilsPrintf("\t..Alarm is configured to wakeup system after "
"20 Sec..");
configWakeRTC();
enableRTCAlarmIntr();
break;
default:
break;
}
}
static void TouchScreenIsr()
{
unsigned int wordsLeft = 0;
unsigned int status;
unsigned int arr_x[5] = {0,0,0,0,0};
unsigned int arr_y[5] = {0,0,0,0,0};
unsigned int x_data = 0;
unsigned int y_data = 0;
unsigned int i = 0;
unsigned int sum = 0;
status = TSCADCIntStatus(TSC_ADC_INSTANCE);
if(status & TSCADC_FIFO1_THRESHOLD_INT)
{
wordsLeft = TSCADCFIFOWordCountRead(TSC_ADC_INSTANCE, TSCADC_FIFO_0);
while(wordsLeft)
{
x_data = TSCADCFIFOADCDataRead(TSC_ADC_INSTANCE, TSCADC_FIFO_0);
arr_x[i++] = x_data;
wordsLeft = TSCADCFIFOWordCountRead(TSC_ADC_INSTANCE, TSCADC_FIFO_0);
}
sum = arr_x[1] + arr_x[2] + arr_x[3];
sum = sum / 3;
x_data = sum;
wordsLeft = TSCADCFIFOWordCountRead(TSC_ADC_INSTANCE, TSCADC_FIFO_1);
i = 0;
while(wordsLeft)
{
y_data = TSCADCFIFOADCDataRead(TSC_ADC_INSTANCE, TSCADC_FIFO_1);
arr_y[i++] = y_data;
wordsLeft = TSCADCFIFOWordCountRead(TSC_ADC_INSTANCE, TSCADC_FIFO_1);
}
sum = arr_y[1] + arr_y[2] + arr_y[3];
sum = sum / 3;
y_data = sum;
}
x_val[Index] = x_data;
y_val[Index] = y_data;
Index = (Index + 0x01) & 0x01;
/* Load the counter with the initial count value */
DMTimerCounterSet(SOC_DMTIMER_2_REGS, 0);
/* Start the DMTimer */
DMTimerEnable(SOC_DMTIMER_2_REGS);
TSCADCIntStatusClear(TSC_ADC_INSTANCE, TSCADC_FIFO1_THRESHOLD_INT);
IsTSPress = 1;
StepEnable();
}
/*
** ISR for Touch Screen
*/
static void TouchScreenIsr(void)
{
volatile unsigned int wordsLeft = 0;
unsigned int status;
unsigned int i = 0;
unsigned int prevVal_x = 0xFFFFFFFF;
unsigned int prevVal_y = 0xFFFFFFFF;
unsigned int currDiff_x;
unsigned int currDiff_y;
unsigned int prevDiff_x = 0xFFFFFFFF;
unsigned int prevDiff_y = 0xFFFFFFFF;
unsigned int readx1;
unsigned int ready1;
status = TSCADCIntStatus(SOC_ADC_TSC_0_REGS);
wordsLeft = TSCADCFIFOWordCountRead(SOC_ADC_TSC_0_REGS, TSCADC_FIFO_1);
if(status & TSCADC_FIFO1_THRESHOLD_INT)
{
for (i = 0; i < wordsLeft; i++)
{
readx1 = TSCADCFIFOADCDataRead(SOC_ADC_TSC_0_REGS, TSCADC_FIFO_0);
readx1 = readx1 & 0xfff;
if (readx1 > prevVal_x)
{
currDiff_x = readx1 - prevVal_x;
}
else
{
currDiff_x = prevVal_x - readx1;
}
if (currDiff_x < prevDiff_x)
{
prevDiff_x = currDiff_x;
xdata = readx1;
}
prevVal_x = readx1;
ready1 = TSCADCFIFOADCDataRead(SOC_ADC_TSC_0_REGS, TSCADC_FIFO_1);
ready1 &= 0xfff;
if (ready1 > prevVal_y)
{
currDiff_y = ready1 - prevVal_y;
}
else
{
currDiff_y = prevVal_y - ready1;
}
if (currDiff_y < prevDiff_y)
{
prevDiff_y = currDiff_y;
ydata = ready1;
}
prevVal_y = ready1;
wordsLeft = TSCADCFIFOWordCountRead(SOC_ADC_TSC_0_REGS, TSCADC_FIFO_1);
}
x_data[dbidx] = xdata;
y_data[dbidx] = ydata;
dbidx = (dbidx + 1) & 0x01;
}
/* Restart the timer counter */
DMTimerCounterSet(SOC_DMTIMER_3_REGS, 0);
DMTimerEnable(SOC_DMTIMER_3_REGS);
//TSCADCIntStatusClear(SOC_ADC_TSC_0_REGS, TSCADC_FIFO1_THRESHOLD_INT);
TSCADCIntStatusClear(SOC_ADC_TSC_0_REGS, TSCADC_FIFO1_THRESHOLD_INT |
TSCADC_ASYNC_HW_PEN_EVENT_INT |
TSCADC_SYNC_PEN_EVENT_INT |
TSCADC_FIFO0_UNDER_FLOW_INT |
TSCADC_FIFO1_UNDER_FLOW_INT |
TSCADC_END_OF_SEQUENCE_INT |
TSCADC_FIFO0_THRESHOLD_INT |
TSCADC_FIFO0_OVER_RUN_INT |
TSCADC_FIFO1_OVER_RUN_INT |
TSCADC_OUT_OF_RANGE_INT |
TSCADC_PEN_UP_EVENT_INT);
IsTSPress = 1;
touchRelease = 0;
StepEnable();
}