static void IR_Timer_Timeout(void)
{
ir_TimerID = INVALID_TIMER_ID;
switch (ADC_Step)
{
case 0:
case 1:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH3 | ADC_CTL_IE);
break;
case 2:
case 3:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH2 | ADC_CTL_IE);
break;
case 4:
case 5:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH1 | ADC_CTL_IE);
break;
case 6:
case 7:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH0 | ADC_CTL_IE);
break;
default:
ADC_Step = 0;
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH3 | ADC_CTL_IE);
break;
}
ROM_ADCProcessorTrigger(ADC0_BASE, 2);
}
//*****************************************************************************
//
// Initialize the ADC inputs used by the game pad device. This example uses
// the ADC pins on Port E pins 1, 2, and 3(AIN0-2).
//
//*****************************************************************************
void
ADCInit(void)
{
int32_t ui32Chan;
//
// Enable the GPIOs and the ADC used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralReset(SYSCTL_PERIPH_ADC0);
//
// Select the external reference for greatest accuracy.
//
ROM_ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
//
// Configure the pins which are used as analog inputs.
//
ROM_GPIOPinTypeADC(GPIO_PORTE_AHB_BASE, GPIO_PIN_3 | GPIO_PIN_2 |
GPIO_PIN_1);
//
// Configure the sequencer for 3 steps.
//
for(ui32Chan = 0; ui32Chan < 2; ui32Chan++)
{
//
// Configure the sequence step
//
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, ui32Chan, ui32Chan);
}
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH2 | ADC_CTL_IE |
ADC_CTL_END);
//
// Enable the sequence but do not start it yet.
//
ROM_ADCSequenceEnable(ADC0_BASE, 0);
}
//*****************************************************************************
//
// Initializes the ADC.
//
//*****************************************************************************
void
ADCInit(void)
{
//
// Set the ADC speed to 1 Msps.
//
ROM_SysCtlADCSpeedSet(SYSCTL_ADCSPEED_1MSPS);
//
// Configure the GPIOs used with the analog inputs.
//
GPIOPinTypeADC(ADC_POSITION_PORT, ADC_POSITION_PIN);
GPIOPinTypeADC(ADC_CURRENT_PORT, ADC_CURRENT_PIN);
GPIOPinTypeADC(ADC_VBUS_PORT, ADC_VBUS_PIN);
GPIOPinTypeADC(ADC_VBOOTA_PORT, ADC_VBOOTA_PIN);
GPIOPinTypeADC(ADC_VBOOTB_PORT, ADC_VBOOTB_PIN);
//
// Configure the ADC sample sequence that is triggered by PWM
// generator 2
//
ROM_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PWM0, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CURRENT_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_VBUS_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_POSITION_CH);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 0, 3,
(ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END));
ROM_ADCSequenceEnable(ADC0_BASE, 0);
//
// Enable interrupts
//
ROM_ADCIntEnable(ADC0_BASE, 0);
ROM_IntEnable(INT_ADC0SS0);
//
// Set the zero current to indicate that the initial sampling has just
// begun.
//
g_usCurrentZero = 0xffff;
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! \param ui32SysClock is the frequency of the system clock.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC 0 sample sequence 3
//! - Timer 5 subtimer B
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(uint32_t ui32SysClock)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ui32TSState = TS_STATE_INIT;
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5);
//
// Configure the ADC sample sequence used to read the touch screen reading.
//
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 4);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
TS_YP_ADC | ADC_CTL_END | ADC_CTL_IE);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ROM_ADCIntEnable(ADC0_BASE, 3);
ROM_IntEnable(INT_ADC0SS3);
//
// Configure the timer to trigger the sampling of the touch screen
// every 2.5 milliseconds.
//
if((HWREG(TIMER5_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0) {
ROM_TimerConfigure(TIMER5_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PWM |
TIMER_CFG_B_PERIODIC));
}
ROM_TimerPrescaleSet(TIMER5_BASE, TIMER_B, 255);
ROM_TimerLoadSet(TIMER5_BASE, TIMER_B, ((ui32SysClock / 256) / 400) - 1);
TimerControlTrigger(TIMER5_BASE, TIMER_B, true);
//
// Enable the timer. At this point, the touch screen state machine will
// sample and run every 2.5 ms.
//
ROM_TimerEnable(TIMER5_BASE, TIMER_B);
}
static void IR_Timer_Timeout(void)
{
switch (ADC_Step)
{
case 0:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH3 | ADC_CTL_IE);
break;
case 1:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH2 | ADC_CTL_IE);
break;
case 2:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH1 | ADC_CTL_IE);
break;
case 3:
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH0 | ADC_CTL_IE);
break;
default:
ADC_Step = 0;
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH3 | ADC_CTL_IE);
break;
}
ROM_ADCProcessorTrigger(ADC0_BASE, 2);
}
void BattSense_init(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC1);
ROM_GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_4);
ROM_ADCHardwareOversampleConfigure(ADC1_BASE, 64);
ROM_ADCSequenceConfigure(ADC1_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ROM_ADCSequenceStepConfigure(ADC1_BASE, 3, 0, ADC_CTL_END | ADC_CTL_CH10 | ADC_CTL_IE);
ROM_ADCSequenceEnable(ADC1_BASE, 3);
ADCIntRegister(ADC1_BASE, 3, &BattSenseISR);
ROM_ADCIntEnable(ADC1_BASE, 3);
battery_Runtimeout(&BattSenseTimerTimout, 10000);
}
void LightSensorInit(void) {
// Set up pin as ADC
ROM_GPIOPinTypeADC(LIGHTSENSOR_PORT, LIGHTSENSOR_PIN);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE
| ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
ROM_ADCIntEnable(ADC0_BASE, 3);
ROM_ADCIntClear(ADC0_BASE, 3);
ADCIntRegister(ADC0_BASE, 3, LightSensorIntHandler);
}
rt_uint8_t battery_adc_initialize(void)
{
ROM_SysCtlADCSpeedSet(SYSCTL_ADCSPEED_1MSPS);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_ADCHardwareOversampleConfigure(ADC0_BASE,64);
ROM_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2);
ADCSequenceConfigure(ADC0_BASE, 3,ADC_TRIGGER_PROCESSOR, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE,3, 0, ADC_CTL_CH1| ADC_CTL_IE |ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
rt_kprintf("battery_adc_initialize\n");
return 0;
}
void
configureADC()
{
//
// Setup ADC Using ROM functions
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0); //Enable ADC0
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //Enable GPIO E
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 64); //Configure hardware oversampling to sample 64 times and average
HWREG(ADC0_BASE + ADC_O_PC) = ADC_PC_SR_125K; //Set ADC speed to 125K
ROM_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3); //Enable ADC on PE3
ROM_ADCSequenceDisable(ADC0_BASE, 3); //Disable sequence before configuring it
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); //Use sequencer 3 to trigger at all times with a priority of 0 (highest)
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE | ADC_CTL_END); //Enable sampling using sequencer 3 on CH0 (PE3)
ROM_ADCSequenceEnable(ADC0_BASE, 3); //Enable the sequencer
}
void IRDetector_init(void)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, 0x00);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 32);
ROM_ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_END | ADC_CTL_CH0 | ADC_CTL_IE); //PE3, enable interrupt
ROM_ADCSequenceEnable(ADC0_BASE, 2);
ADCIntRegister(ADC0_BASE, 2, &IR_Detector_ISR);
ROM_ADCIntEnable(ADC0_BASE, 2);
ADC_Step = 0;
TURN_ON_IRD1();
ir_Runtimeout(&IR_Timer_Timeout, 1);
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC sample sequence 3
//! - Timer 1 subtimer A
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(void)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ulTSState = TS_STATE_INIT;
//
// Determine which calibration parameter set we will be using.
//
g_plParmSet = g_lTouchParameters[SET_NORMAL];
if(g_eDaughterType == DAUGHTER_SRAM_FLASH)
{
//
// If the SRAM/Flash daughter board is present, select the appropriate
// calibration parameters and reading threshold value.
//
g_plParmSet = g_lTouchParameters[SET_SRAM_FLASH];
g_sTouchMin = 40;
}
else if(g_eDaughterType == DAUGHTER_FPGA)
{
//
// If the FPGA daughter board is present, select the appropriate
// calibration parameters and reading threshold value.
//
g_plParmSet = g_lTouchParameters[SET_FPGA];
g_sTouchMin = 70;
}
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralEnable(TS_P_PERIPH);
ROM_SysCtlPeripheralEnable(TS_N_PERIPH);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// Configure the ADC sample sequence used to read the touch screen reading.
//
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 4);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
ADC_CTL_CH_YP | ADC_CTL_END | ADC_CTL_IE);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ROM_ADCIntEnable(ADC0_BASE, 3);
ROM_IntEnable(INT_ADC0SS3);
//
// Configure the GPIOs used to drive the touch screen layers.
//
ROM_GPIOPinTypeGPIOOutput(TS_P_BASE, TS_XP_PIN | TS_YP_PIN);
//
// If no daughter board or one which does not rewire the touchscreen
// interface is installed, set up GPIOs to drive the XN and YN signals.
//
if((g_eDaughterType != DAUGHTER_SRAM_FLASH) &&
(g_eDaughterType != DAUGHTER_FPGA))
{
ROM_GPIOPinTypeGPIOOutput(TS_N_BASE, TS_XN_PIN | TS_YN_PIN);
}
ROM_GPIOPinWrite(TS_P_BASE, TS_XP_PIN | TS_YP_PIN, 0x00);
if(g_eDaughterType == DAUGHTER_SRAM_FLASH)
{
HWREGB(LCD_CONTROL_CLR_REG) = LCD_CONTROL_XN | LCD_CONTROL_YN;
}
else if(g_eDaughterType == DAUGHTER_FPGA)
{
HWREGH(LCD_FPGA_CONTROL_CLR_REG) = LCD_CONTROL_XN | LCD_CONTROL_YN;
}
else
{
ROM_GPIOPinWrite(TS_N_BASE, TS_XN_PIN | TS_YN_PIN, 0x00);
}
//
// See if the ADC trigger timer has been configured, and configure it only
// if it has not been configured yet.
//
if((HWREG(TIMER1_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0)
{
//
// Configure the timer to trigger the sampling of the touch screen
// every millisecond.
//
ROM_TimerConfigure(TIMER1_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC));
ROM_TimerLoadSet(TIMER1_BASE, TIMER_A,
(ROM_SysCtlClockGet() / 1000) - 1);
ROM_TimerControlTrigger(TIMER1_BASE, TIMER_A, true);
//
// Enable the timer. At this point, the touch screen state machine
// will sample and run once per millisecond.
//
ROM_TimerEnable(TIMER1_BASE, TIMER_A);
}
}
//*****************************************************************************
//
// This function initializes the ADC hardware in preparation for data
// acquisition.
//
//*****************************************************************************
void
AcquireInit(void)
{
unsigned long ulChan;
//
// Enable the ADC peripherals and the associated GPIO port
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP);
ROM_SysCtlADCSpeedSet(SYSCTL_ADCSPEED_125KSPS);
ROM_GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 |GPIO_PIN_7 | GPIO_PIN_3);
ROM_GPIOPinTypeADC(GPIO_PORTP_BASE, GPIO_PIN_0);
// ROM_ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V);
//ROM_ADCR
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
HWREG(GPIO_PORTB_BASE + GPIO_O_AMSEL) |= GPIO_PIN_6;
ADCSequenceDisable(ADC0_BASE,SEQUENCER);
ROM_ADCSequenceConfigure(ADC0_BASE, SEQUENCER, ADC_TRIGGER_TIMER, 0);
for(ulChan = 0; ulChan < 2; ulChan++)
{
unsigned long ulChCtl;
if (ulChan ==1)
{
ROM_ADCSequenceStepConfigure(ADC0_BASE, SEQUENCER, ulChan, ADC_CTL_CH1|ADC_CTL_IE | ADC_CTL_END);
}
else if(ulChan==0)
{
ulChCtl = ADC_CTL_CH0;
ROM_ADCSequenceStepConfigure(ADC0_BASE, SEQUENCER, ulChan, ADC_CTL_CH0);
}
}
ADCHardwareOversampleConfigure(ADC0_BASE, 1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
//SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
ROM_TimerConfigure(TIMER0_BASE,TIMER_CFG_32_BIT_PER );
//100 micro
unsigned long freq=SAMPLING_FREQUENCY;
unsigned long period=(2*ROM_SysCtlClockGet()/(freq));
ROM_TimerLoadSet(TIMER0_BASE, TIMER_A,period);
ROM_TimerControlTrigger(TIMER0_BASE, TIMER_A, true);
//ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
//ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet() /2);
CFAL96x64x16Init();
GrContextInit(&sDisplayContext, &g_sCFAL96x64x16);
sRect1.sXMin = 0;
sRect1.sYMin = 0;
sRect1.sXMax = GrContextDpyWidthGet(&sDisplayContext) - 1;
sRect1.sYMax = 23;
sRect2.sXMin = 0;
sRect2.sYMin = 23;
sRect2.sXMax = GrContextDpyWidthGet(&sDisplayContext) - 1;
sRect2.sYMax = GrContextDpyHeightGet(&sDisplayContext) - 1;
snprintf(text,sizeof(text),"STart");
GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);
GrRectFill(&sDisplayContext, &sRect1);
GrContextForegroundSet(&sDisplayContext, ClrWhite);
//GrRectDraw(&sDisplayContext, &sRect1);
GrContextFontSet(&sDisplayContext, g_pFontCm12);
GrStringDrawCentered(&sDisplayContext,text, -1,
GrContextDpyWidthGet(&sDisplayContext) / 2, 10, 0);
//GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);
//GrRectFill(&sDisplayContext, &sRect1);
//GrContextForegroundSet(&sDisplayContext, ClrWhite);
//GrRectDraw(&sDisplayContext, &sRect1);
/*GrContextForegroundSet(&sDisplayContext, ClrDarkBlue);
GrRectFill(&sDisplayContext, &sRect2);
GrContextForegroundSet(&sDisplayContext, ClrWhite);
GrRectDraw(&sDisplayContext, &sRect2);
*/
compute_filter();
maxi1=0;
maxi2=0;
max1=0;
max2=0;
res=0;
res1=0;
g_ulADCCount=0;
buffer_index=0;
ulLastADCCount=0;
}
int main(void)
{
uint32_t ui32ADC0Value[4];
volatile uint32_t ui32TempAvg;
volatile uint32_t ui32TempValueC;
volatile uint32_t ui32TempValueF;
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_16MHZ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 64);
ROM_ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ROM_ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 64);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
UARTConfigSetExpClk(UART0_BASE, SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
IntMasterEnable();
IntEnable(INT_UART0);
UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
while(1)
{
if(mode == 0)
{
ROM_ADCIntClear(ADC0_BASE, 1);
ROM_ADCProcessorTrigger(ADC0_BASE, 1);
while(!ROM_ADCIntStatus(ADC0_BASE, 1, false))
{
}
ROM_ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
UARTStrPut("Current Temperature ");
UARTIntPut(ui32TempValueC);
UARTCharPut(UART0_BASE, 176);
UARTStrPut("C, Set Temperature ");
UARTIntPut(setTemp);
UARTCharPut(UART0_BASE, 176);
UARTStrPut("C\r\n");
int temp;
if (setTemp < ui32TempValueC) temp = 2; // red
else if (setTemp > ui32TempValueC) temp = 8; // green
else temp = 4; // blue if equal
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, temp);
SysCtlDelay(SysCtlClockGet()/3);
}
}
}
//*****************************************************************************
//
//! Initializes the touch screen driver.
//!
//! This function initializes the touch screen driver, beginning the process of
//! reading from the touch screen. This driver uses the following hardware
//! resources:
//!
//! - ADC sample sequence 3
//! - Timer 1 subtimer A
//!
//! \return None.
//
//*****************************************************************************
void
TouchScreenInit(void)
{
//
// Set the initial state of the touch screen driver's state machine.
//
g_ulTSState = TS_STATE_INIT;
//
// There is no touch screen handler initially.
//
g_pfnTSHandler = 0;
//
// Enable the peripherals used by the touch screen interface.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ROM_SysCtlPeripheralEnable(TS_P_PERIPH);
ROM_SysCtlPeripheralEnable(TS_N_PERIPH);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
//
// Configure the ADC sample sequence used to read the touch screen reading.
//
ROM_ADCHardwareOversampleConfigure(ADC0_BASE, 4);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_TIMER, 0);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0,
ADC_CTL_CH_YP | ADC_CTL_END | ADC_CTL_IE);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
//
// Enable the ADC sample sequence interrupt.
//
ROM_ADCIntEnable(ADC0_BASE, 3);
ROM_IntEnable(INT_ADC0SS3);
//
// Configure the GPIOs used to drive the touch screen layers.
//
ROM_GPIOPinTypeGPIOOutput(TS_P_BASE, TS_XP_PIN | TS_YP_PIN);
ROM_GPIOPinTypeGPIOOutput(TS_N_BASE, TS_XN_PIN | TS_YN_PIN);
ROM_GPIOPinWrite(TS_P_BASE, TS_XP_PIN | TS_YP_PIN, 0x00);
ROM_GPIOPinWrite(TS_N_BASE, TS_XN_PIN | TS_YN_PIN, 0x00);
//
// See if the ADC trigger timer has been configured, and configure it only
// if it has not been configured yet.
//
if((HWREG(TIMER1_BASE + TIMER_O_CTL) & TIMER_CTL_TAEN) == 0)
{
//
// Configure the timer to trigger the sampling of the touch screen
// every millisecond.
//
ROM_TimerConfigure(TIMER1_BASE, (TIMER_CFG_SPLIT_PAIR |
TIMER_CFG_A_PERIODIC | TIMER_CFG_B_PERIODIC));
ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, (SysCtlClockGet() / 1000) - 1);
ROM_TimerControlTrigger(TIMER1_BASE, TIMER_A, true);
//
// Enable the timer. At this point, the touch screen state machine
// will sample and run once per millisecond.
//
ROM_TimerEnable(TIMER1_BASE, TIMER_A);
}
}
void vTempDriverTask() //Code Credit to Tivaware Example temperature_sensor.c
{
uint32_t measurement[1];
uint32_t ui32TempValueC;
ROM_GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_1);
ROM_ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0); //D0
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH15 | ADC_CTL_IE |
ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
ROM_ADCIntClear(ADC0_BASE, 3);
for(;;)
{
xSemaphoreTake(pollTempSem, portMAX_DELAY);
ROM_ADCProcessorTrigger(ADC0_BASE, 3);
// Wait for conversion to be completed.
while(!ROM_ADCIntStatus(ADC0_BASE, 3, false)) {}
// Clear the ADC interrupt flag.
ROM_ADCIntClear(ADC0_BASE, 3);
// Read ADC Value.
ROM_ADCSequenceDataGet(ADC0_BASE, 3, measurement);
ui32TempValueC = (uint32_t)(log(40960/(29.0*measurement[0]) - 10.0/29) * -1/0.041);
outputBuffer.tempR = ui32TempValueC;
//Switch to other Thermistor
ROM_ADCSequenceDisable(ADC0_BASE, 3);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH14 | ADC_CTL_IE | //D1
ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
//Begin ADC poll
ROM_ADCProcessorTrigger(ADC0_BASE, 3);
// Wait for conversion to be completed.
while(!ROM_ADCIntStatus(ADC0_BASE, 3, false)) {}
// Clear the ADC interrupt flag.
ROM_ADCIntClear(ADC0_BASE, 3);
// Read ADC Value.
ROM_ADCSequenceDataGet(ADC0_BASE, 3, measurement);
ui32TempValueC = (uint32_t)(log(40960/(29.0*measurement[0]) - 10.0/29) * -1/0.041);
outputBuffer.tempL = ui32TempValueC;
ROM_ADCSequenceDisable(ADC0_BASE, 3);
ROM_ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH15 | ADC_CTL_IE |
ADC_CTL_END);
ROM_ADCSequenceEnable(ADC0_BASE, 3);
}
}