unsigned int ReadWall_IR () {
uint32_t resultRight, resultFront;
int i;
ADCProcessorTrigger(ADC0_BASE, 2);
//Wait for ADC to finish converting.
for ( i = 10000; i>0; i--); //delay a bit
ADCSequenceDataGet(ADC0_BASE, 2, &resultRight);
ADCSequenceDataGet(ADC0_BASE, 2, &resultFront);
//Check if the front wall is close.
if (resultFront > MAX_VAL_F){
front_wall_det = 1;
}
else {
front_wall_det = 0;
}
//Check if the right wall is close.
if (resultRight < MIN_VAL_R){
wall_det = 0;
}
else {
wall_det = 1;
}
return resultRight;
}
void UARTIntHandler() {
uint32_t ui32Status;
uint32_t ui32ADC0Value[4]; // ADC FIFO
volatile uint32_t ui32TempAvg; // Store average
volatile uint32_t ui32TempValueC; // Temp in C
volatile uint32_t ui32TempValueF; // Temp in F
ui32Status = UARTIntStatus(UART0_BASE, true); //get interrupt status
UARTIntClear(UART0_BASE, ui32Status); //clear the asserted interrupts
ADCIntClear(ADC0_BASE, 2); // Clear ADC0 interrupt flag.
ADCProcessorTrigger(ADC0_BASE, 2); // Trigger ADC conversion.
while (!ADCIntStatus(ADC0_BASE, 2, false))
; // wait for conversion to complete.
ADCSequenceDataGet(ADC0_BASE, 2, ui32ADC0Value); // get converted data.
// Average read values, and round.
// Each Value in the array is the result of the mean of 64 samples.
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2]
+ ui32ADC0Value[3] + 2) / 4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096) / 10; // calc temp in C
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
//while(UARTCharsAvail(UART0_BASE)) //loop while there are chars
//{
// UARTCharPutNonBlocking(UART0_BASE, UARTCharGetNonBlocking(UART0_BASE)); //echo character
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); //blink LED
SysCtlDelay(SysCtlClockGet() / (1000 * 3)); //delay ~1 msec
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); //turn off LED
//}
}
// *******************************************************
// Takes an ADC sample. This is the location of
// the helicopter on the vertical axis.
void heightSample(void)
{
//* we could just read ADC every time we call this
//* not much need to use systick as with yaw??
//* could combine yaw and height ISRs in one.
unsigned long ulValue[10];
//long ulCount = 0;
//
// Trigger the ADC conversion.
ADCProcessorTrigger(ADC0_BASE, 3);
//
// Wait for conversion to be completed.
while(!ADCIntStatus(ADC0_BASE, 3, false))
{
}
// Read ADC Value.
//ulCount = ADCSequenceDataGet(ADC0_BASE, 3, ulValue);
//Strange thing is happening, ADCSequecnceDataGet()
// Regularly returns a value on the order of 10^9
// when the return value is 0 (false).
if (ADCSequenceDataGet(ADC0_BASE, 3, ulValue) == 1)
{
g_height = ulValue[0];
writeCircBuf(&g_heightBuf, g_height);
}
// I'm not going to bother taking a new reading because
// one sample is not significant since it is averaged.
}
void SampleLightCO(void){
unsigned long ulADC0_Value[1];
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, ADC_CTL_CH0 | ADC_CTL_IE |
ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
while(1){
ADCProcessorTrigger(ADC0_BASE, 3);
while(!ADCIntStatus(ADC0_BASE, 3, false)){
}
ADCIntClear(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, ulADC0_Value);
Log("Breath Level = ");
LogD(ulADC0_Value[0]);
Log("\r");
SysCtlDelay(SysCtlClockGet() / 12);
}
}
void ADC0IntHandler()
{
unsigned long adc0Value; // Holds the ADC result
char adc0String[5]; // Holds the string-converted ADC result
// 清ADC0中断标志.
// ADCIntClear (unsigned long ulBase, unsigned long ulSequenceNum)
ADCIntClear(ADC0_BASE, 0);
//从SSO读出转换结果 (FIFO0),本例中只有一个采样.如果要使用多个转换源,需要使用数组做为参数传递给API函数,保存FIFO转换结果.
// long ADCSequenceDataGet (unsigned long ulBase,unsigned long ulSequenceNum,unsigned long *pulBuffer)
ADCSequenceDataGet(ADC0_BASE, 0, &adc0Value);
adc0Value= ((59960 - (adc0Value * 100)) / 356);
// 在OLED上显示当前温度
usprintf(adc0String, "%d", adc0Value);
IntMasterDisable();
RIT128x96x4StringDraw("Current temp : ", 6, 48, 15);
RIT128x96x4StringDraw(adc0String, 94, 48, 15);
IntMasterEnable();
// ADC模块空闲,可以进行下一次转换
adc_busy=0;
}
int setADC (void)
{
unsigned long ulValue;
//char buffer[32] = "";
//
// Trigger the sample sequence.
//
ADCProcessorTrigger(ADC0_BASE, 0);
//
// Wait until the sample sequence has completed.
//
while(!ADCIntStatus(ADC0_BASE, 0, false))
{
}
//
// Read the value from the ADC.
//
ADCSequenceDataGet(ADC0_BASE, 0, &ulValue);
/*debug show value
RIT128x96x4StringDraw(" ", 90, 88, mainFULL_SCALE);
itoa(ulValue, buffer, 10 );
RIT128x96x4StringDraw(buffer, 90, 88, mainFULL_SCALE);
*/
return ulValue;
}
/*****************************************************
* Function: checkIntTempSensor
* Description: Reads internal temperature sensor
* Input: NONE
* Output: ui32TempAvg, ui32TempValueC, ui32TempValueF
*****************************************************/
void checkIntTempSensor(void)
{
// Clear flag
ADCIntClear(ADC0_BASE, 0);
// Trigger processor
ADCProcessorTrigger(ADC0_BASE, 0);
// Wait for ADC status to be set
while(!ADCIntStatus(ADC0_BASE, 0, false)){}
// Get data and convert to useful values
// Read all four steps of sequence into ui32ADC0Value
ADCSequenceDataGet(ADC0_BASE, 0, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
ui32TempValueF = ((ui32TempValueC * 9) + 160) / 5;
// Shutdown if device is getting too hot
if(ui32TempValueF >= SHUTDOWN_TEMP)
{
mode = SYSTEM_SHUTDOWN;
}
}
//******************************************************************************
// The handler for the ADC conversion (height) complete interrupt.
// Writes to the circular buffer.
//*****************************************************************************
void HeightIntHandler(void)
{
unsigned long ulValue;
static int counter = 0; //Keeping track of the buffer count for the initialRead
int current;
int sum = 0;
int i;
// Clean up, clearing the interrupt
ADCIntClear(ADC0_BASE, 3);
// Get the single sample from ADC0. (Yes, I know, I just did what you did sir :p)
ADCSequenceDataGet(ADC0_BASE, 3, &ulValue);
// Place it in the circular buffer (advancing write index)
g_inBuffer.data[g_inBuffer.windex] = (int) ulValue;
g_inBuffer.windex++;
if (g_inBuffer.windex >= g_inBuffer.size)
g_inBuffer.windex = 0;
if (counter < BUF_SIZE) {
counter++;
if (counter == BUF_SIZE) {
for (i = 0; i < BUF_SIZE; i++) {
current = ulValue;
sum = sum + current;
}
//Average voltage to calibrate the minimum height of the helicopter
initialRead = ADC_TO_MILLIS(sum/BUF_SIZE);
}
}
}
long getADCValue(void) {
unsigned long ADCValue = 0;
ADCProcessorTrigger(ADC_BASE, 0 );
while(!ADCIntStatus(ADC_BASE, 0, false));
ADCSequenceDataGet(ADC_BASE, 0, &ADCValue);
return ADCValue;
}
unsigned long ADC_In(unsigned int channelNum){
unsigned long config;
unsigned long data;
// Configuring ADC to start by processor call instead of interrupt
ADCSequenceConfigure(ADC0_BASE, 3, ADC_TRIGGER_PROCESSOR, 0);
// Determine input channel
switch(channelNum){
case 0: config = ADC_CTL_CH0; break;
case 1: config = ADC_CTL_CH1; break;
case 2: config = ADC_CTL_CH2; break;
case 3: config = ADC_CTL_CH3; break;
}
// Enable ADC interrupt and last step of sequence
config |= ADC_CTL_IE | ADC_CTL_END;
ADCSequenceStepConfigure(ADC0_BASE, 3, 0, config);
ADCSequenceEnable(ADC0_BASE, 3);
ADCIntClear(ADC0_BASE, 3);
// Start ADC conversion
ADCProcessorTrigger(ADC0_BASE, 3);
// Wait for ADC conversion to finish
while(!ADCIntStatus(ADC0_BASE, 3, false)){}
// Clear interrupt flag and read conversion data
ADCIntClear(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, &data);
return data;
}
int main(void)
{
SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5);
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5);
ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_CH8);
ADCSequenceStepConfigure(ADC0_BASE, 2, 1, ADC_CTL_CH11 | ADC_CTL_IE | ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 2);
ADCIntClear(ADC0_BASE, 2);
while(1)
{
ADCProcessorTrigger(ADC0_BASE, 2);
while(!ADCIntStatus(ADC0_BASE, 2, false));
ADCIntClear(ADC0_BASE, 2);
ADCSequenceDataGet(ADC0_BASE, 2, adcValue);
SysCtlDelay(SysCtlClockGet() / 12);
}
}
int main(void)
{
uint32_t ui32ADC0Value[4];
volatile uint32_t ui32TempAvg;
volatile uint32_t ui32TempValueC;
volatile uint32_t ui32TempValueF;
setup();
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
while(1)
{
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
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;
}
}
/**
* Do a processor A/D conversion sequence.
*/
static void scan_proc_adc(void)
{
int samples;
/*
* We occasionally get too many or too few samples because
* the extra (missing) samples will show up on the next read
* operation. Just do it again if this happens.
*/
for (samples = 0; samples != ADC_SAMPLES; ) {
ADCSequenceEnable(ADC0_BASE, 0);
ADCProcessorTrigger(ADC0_BASE, 0);
/*
* Wait until the sample sequence has completed.
*/
while(!ADCIntStatus(ADC0_BASE, 0, false))
;
/*
* Read the values from the ADC. The whole sequence
* gets converted and stored in one fell swoop.
*/
if (xSemaphoreTake(io_mutex, IO_TIMEOUT)) {
samples = ADCSequenceDataGet(ADC0_BASE, 0,
(unsigned long *)adc_val);
xSemaphoreGive(io_mutex);
}
#if (DEBUG > 0)
if (samples != ADC_SAMPLES) {
lprintf("A/D samples: is %d, "
"should be %d.\r\n",
samples, ADC_SAMPLES);
}
#endif
}
}
long readRightIRSensor (void) {
unsigned long ADCValue = 0;
ADCProcessorTrigger(ADC_BASE, 2 );
while(!ADCIntStatus(ADC_BASE, 2, false));
ADCSequenceDataGet(ADC_BASE, 2, &ADCValue);
return ADCValue;
}
void adc_init(void)
{
unsigned long ulDummy = 0;
// Enable the ADC hardware
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
// Configure the pin as analog input
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); // PIN D3/2/1 as ADC.
GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5); // PIN E5 as ADC.
//GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5 | GPIO_PIN_4); // U_AN{0..1}
// for 6 ADCs
// use Sample Sequencer 0 since it is the only one able to handle more than four ADCs
ADCSequenceDisable(ADC0_BASE, 0);
// configure Sequencer to trigger from processor with priority 0
ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
// do NOT use TRIGGER_TIMER because of malfunction in the touch screen handler
//ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_TIMER, 0);
// configure the steps of the Sequencer
ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH4); //CH4 = PD3
ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH5); //CH5 = PD2
ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH6); //CH6 = PD1
ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH8 | ADC_CTL_IE | ADC_CTL_END);//CH8 = PE5
//ADCSequenceStepConfigure(ADC0_BASE, 0, 1, ADC_CTL_CH11); // U_AN1
//ADCSequenceStepConfigure(ADC0_BASE, 0, 2, ADC_CTL_CH4); // U_AN2
//ADCSequenceStepConfigure(ADC0_BASE, 0, 3, ADC_CTL_CH5); // U_AN3
//ADCSequenceStepConfigure(ADC0_BASE, 0, 4, ADC_CTL_CH6); // U_AN4
//ADCSequenceStepConfigure(ADC0_BASE, 0, 5, ADC_CTL_CH7 | ADC_CTL_IE | ADC_CTL_END); // U_AN5
ADCSequenceEnable(ADC0_BASE, 0);
// flush the ADC
ADCSequenceDataGet(ADC0_BASE, 0, &ulDummy);
// Enable Interrupt for ADC0 Sequencer 0
ADCIntEnable(ADC0_BASE, 0);
IntEnable(INT_ADC0);
/*
for (int i=0; i < 4; i++) {
for (int j=0; j < ADC_BUFF_SIZE; j++) {
adcBuff[i][j] = 50; //give the buffers a half decent starting value.
}
}
adcBuffCnt = 0;
*/
}
long getADCValues(int port) {
unsigned long ADCValue[4] = {0,0,0,0};
ADCIntClear(ADC_BASE, port);
ADCProcessorTrigger(ADC_BASE, port);
while(!ADCIntStatus(ADC_BASE, port, false));
ADCSequenceDataGet(ADC_BASE, port, ADCValue);
return ADCValue[0];
}
long sampleAdcPort(int port) {
unsigned long ADCValues[4] = {0};
ADCProcessorTrigger(ADC_BASE, 0 );
while(!ADCIntStatus(ADC_BASE, 0, false));
ADCSequenceDataGet(ADC_BASE, 0, ADCValues);
ADCIntClear(ADC_BASE, 0);
return ADCValues[port];
}
void mode1() //Obtain samples from ADC
{
ADCProcessorTrigger(ADC0_BASE, 2); // Start Sampling
while(!ADCIntStatus(ADC0_BASE, 2, false)); // Wait until sampling is done
ADCIntClear(ADC0_BASE, 2); //Clear Interrupt
ADCSequenceDataGet(ADC0_BASE, 2, adcValue); //Obtain the sample
ssdset(adcValue[0]);
}
void ADC0_Handler(void){
// Clear flag
ADCIntClear(ADC0_BASE, 0);
ADCSequenceDataGet(ADC0_BASE, 0, Buffer);
Status = TRUE;
}
rt_uint32_t read_battert_adc_value()
{
uint32_t battertValue;
ADCProcessorTrigger(ADC0_BASE, 3);
while(!ADCIntStatus(ADC0_BASE, 3, false));
ADCSequenceDataGet(ADC0_BASE, 3, &battertValue);
return battertValue;
}
/*
* This function is the implementation of the ADC1 interrupt handler.
*/
interrupt void ADC1IntHandler(void) {
//Clear the ADC interrupt flags
ADCIntClear(ADC1_BASE, 3);
//Get data from ADC0 sequence 3
ADCSequenceDataGet(ADC1_BASE, 3, ulLVDT);
UARTprintf("LVDT: %u\n", ulLVDT[0]);
}
/*
* This function is the implementation of the ADC0 interrupt handler.
*/
interrupt void ADC0IntHandler(void) {
//Clear the ADC interrupt flags
ADCIntClear(ADC0_BASE, 3);
//Get data from ADC0 sequence 3
ADCSequenceDataGet(ADC0_BASE, 3, ulCurrent);
UARTprintf("Current: %u ", ulCurrent[0]);
}
void ADCIntHandler(void) {
while(!ADCIntStatus(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, false));
ADCIntClear(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
xSemaphoreTakeFromISR(adc_mutex, pdFALSE);
ADCSequenceDataGet(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM, adc_vals);
xSemaphoreGiveFromISR(adc_mutex, pdTRUE);
ADCProcessorTrigger(MODULE_ADC_BASE, MODULE_ADC_SEQUENCE_NUM);
}
void adc_read() {
ADCProcessorTrigger(ADC0_BASE, 0);
while(!ADCIntStatus(ADC0_BASE, 0, false));
ADCIntClear(ADC0_BASE, 0);
ADCSequenceDataGet(ADC0_BASE, 0, ulADC0_Value);
ADCSequenceEnable(ADC0_BASE, 0);
}
void get_temp(void){
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2] + ui32ADC0Value[3] + 2)/4;
ui32TempValueC = (1475 - ((2475 * ui32TempAvg)) / 4096)/10;
}
int main(void) {
settemp = 25;
uint32_t ui32ADC0Value[4];
SysCtlClockSet(
SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN
| SYSCTL_XTAL_16MHZ);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 1, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE, 1, 2, ADC_CTL_TS);
ADCSequenceStepConfigure(ADC0_BASE,1,3,ADC_CTL_TS|ADC_CTL_IE|ADC_CTL_END);
ADCSequenceEnable(ADC0_BASE, 1);
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_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){
ADCIntClear(ADC0_BASE, 1);
ADCProcessorTrigger(ADC0_BASE, 1);
while(!ADCIntStatus(ADC0_BASE, 1, false))
{
}
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;
char m[] = "Current Temperature is *C, Set Temperature is *C";
m[23]=(ui32TempValueC/10 % 10) + '0';
m[24]=(ui32TempValueC%10) + '0';
m[49]=(settemp/10 % 10) + '0';
m[50]=(settemp%10) + '0';
int i;
for(i=0;m[i];i++){
UARTCharPut(UART0_BASE, m[i]);
}
if(ui32TempValueC < settemp){
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,8);
}
else{
GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,2);
}
UARTCharPut(UART0_BASE, '\r');
UARTCharPut(UART0_BASE, '\n');
SysCtlDelay(1000000);
}
}
extern "C" void ADC0IntHandler(void) // NOT started yet !!!!
{
uint32_t ui32ADC0Value[4]; //used for storing data from ADC FIFO, must be as large as the FIFO for sequencer in use. Sequencer 1 has FIFO depth of 4
//variables that cannot be optimized out by compiler
ADCIntClear(ADC0_BASE, 1); //clear interrupt flag
ADCSequenceDataGet(ADC0_BASE, 1, ui32ADC0Value);
ui32TempAvg = (ui32ADC0Value[0] + ui32ADC0Value[1] + ui32ADC0Value[2]
+ ui32ADC0Value[3] + 2) / 4; //calculate average
ADCProcessorTrigger(ADC0_BASE, 1);
}
//================ PRIVATE DEFINE ===========================================//
//
//================ PRIVATE MACRO ============================================//
//
//================ SOURCE CODE ==============================================//
void LightSensorIntHandler(void) {
//
// Get ADC Data
//
ADCSequenceDataGet(ADC0_BASE, 3, &(LigthIntensityValue));
//
// Clear the ADC interrupt flag.
//
ROM_ADCIntClear(ADC0_BASE, 3);
}
float Board::getTemp() {
float ulTemp_ValueC;
unsigned long gt;
ADCProcessorTrigger(ADC0_BASE, 3);
ADCSequenceDataGet(ADC0_BASE, 3, >);
// Berechnung
ulTemp_ValueC = ((1475 * 1023) - (2250 * gt)) / 10230;
return ulTemp_ValueC/10000;
}
void Handler2() {
TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
ADCProcessorTrigger(ADC_BASE, 0);
while (!ADCIntStatus(ADC_BASE, 0, false));
ADCSequenceDataGet(ADC_BASE, 0, &ADC_resultValue);
pwm = ((double) 400 / 1024) * ADC_resultValue;
usnprintf(buffer, BUFFSIZE, "ADC : %d\n", (int)ADC_resultValue);
UARTPrint0((unsigned char *) buffer);
}