void ADC0SS0Handler(void) { ROM_ADCIntClear(ADC0_BASE,SEQUENCER); ROM_ADCSequenceDataGet(ADC0_BASE,SEQUENCER,&g_ulADCData[0]); g_ulADCCount++; }
//***************************************************************************** // // This function is called to start an acquisition running. It determines // which channels are to be logged, enables the ADC sequencers, and computes // the first RTC match value. This will start the acquisition running. // //***************************************************************************** void AcquireStart() { unsigned long ulIdx; ulIdx = ulSelectedMask; g_ulNumItems = 0; while(ulIdx) { if(ulIdx & 1) { g_ulNumItems++; } ulIdx >>= 1; } //USBStickOpenLogFile(0); ROM_ADCSequenceEnable(ADC0_BASE,SEQUENCER); //ROM_ADCSequenceDataGet(ADC0_BASE,SEQUENCER,&g_ulADCData[0]); ROM_ADCIntClear(ADC0_BASE,SEQUENCER); ROM_ADCIntEnable(ADC0_BASE,SEQUENCER); ROM_IntEnable(INT_ADC0SS2); ROM_TimerEnable(TIMER0_BASE, TIMER_A); //ROM_IntEnable(INT_TIMER1A); //ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT); //ROM_TimerEnable(TIMER1_BASE, TIMER_A); ROM_IntMasterEnable(); }
static void IR_Detector_ISR(void) { volatile uint32_t ADCResult; ROM_ADCIntClear(ADC0_BASE, 2); ROM_ADCSequenceDataGet(ADC0_BASE, 2, (uint32_t *)&ADCResult); ADC_Step++; ADC_Step %= 8; switch (ADC_Step) { case 0: IR_Result[3] = -ADCResult+IR_ResultTmp[3]; TURN_ON_IRD1(); break; case 1: IR_ResultTmp[0] = ADCResult; TURN_OFF_IRD1(); break; case 2: IR_Result[0] = -ADCResult+IR_ResultTmp[0]; TURN_ON_IRD2(); break; case 3: IR_ResultTmp[1] = ADCResult; TURN_OFF_IRD2(); break; case 4: IR_Result[1] = -ADCResult+IR_ResultTmp[1]; TURN_ON_IRD3(); break; case 5: IR_ResultTmp[2] = ADCResult; TURN_OFF_IRD3(); break; case 6: IR_Result[2] = -ADCResult+IR_ResultTmp[2]; TURN_ON_IRD4(); break; case 7: IR_ResultTmp[3] = ADCResult; TURN_OFF_IRD4(); break; default: //Code should never reach this statement ADC_Step = 0; TURN_ON_IRD1(); break; } ir_Runtimeout(&IR_Timer_Timeout, 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); }
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); }
//***************************************************************************** // // The interrupt handler for the second timer interrupt. (temperature) // //***************************************************************************** void Timer1IntHandler(void) { // // Clear the timer interrupt. // ROM_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT); // // Clear ADC interrupt // ROM_ADCIntClear(ADC0_BASE, 3); //Increment Timer A Count TimerBCount++; /*// // Use the flags to Toggle the LED for this timer // GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, g_ui32Flags);*/ // // Toggle the flag for the temperature timer. // HWREGBITW(&g_ui32InterruptFlags, 0) = 1; // // Trigger ADC Conversion // ROM_ADCProcessorTrigger(ADC0_BASE, 3); // //Wait for ADC conversion to complete // while(!ROM_ADCIntStatus(ADC0_BASE, 3, false)) { //Wait for ADC to finish sampling } ROM_ADCSequenceDataGet(ADC0_BASE, 3, adc_value); //Get data from Sequencer 3 // // Update the interrupt status. // //ROM_IntMasterDisable(); //UARTprintf("ADC Value = %d\n", adc_value[0]); //Print out the first (and only) value //ROM_IntMasterEnable(); }
void BattSenseISR(void) { uint8_t temp; uint32_t BattResult; static uint32_t avrBattResult = 2700; ROM_ADCIntClear(ADC1_BASE, 3); ROM_ADCSequenceDataGet(ADC1_BASE, 3, &BattResult); avrBattResult = (4 * avrBattResult + BattResult) / 5; if (avrBattResult < 2500) { ROM_GPIOPinWrite(ENABLE_PORT, ENA_LEFT_PIN | ENA_RIGHT_PIN, 0x00); SetPWM(MOTOR_LEFT, DEFAULT, 0); SetPWM(MOTOR_RIGHT, DEFAULT, 0); BoostDisable(); IntMasterDisable(); } }
void BattSenseISR(void) { uint32_t ADCResult, BatteryVoltage; ROM_ADCIntClear(ADC0_BASE, 3); ROM_ADCSequenceDataGet(ADC0_BASE, 3, (uint32_t *)&ADCResult); BatteryVoltage = ((float)ADCResult) / 4096 * 3.3 * (220 + 680) / 220; #warning CHECK BATT SENSE #if 0 if (BatteryVoltage < (float)11.0) { HBridgeEnable(); throttleStop(); while(1) { LED3_TOGGLE; ROM_SysCtlDelay(ROM_SysCtlClockGet()/3); } } #endif }
void BattSenseISR(void) { uint32_t ADCResult; ROM_ADCIntClear(ADC1_BASE, 3); battery_Runtimeout(&BattSenseTimerTimout, 10000); ROM_ADCSequenceDataGet(ADC1_BASE, 3, (uint32_t *)&ADCResult); BatteryVoltage = ((float)ADCResult) / 4096 * 3.3 * (200 + 470) / 200; if (BatteryVoltage < (float)7.0) { buzzer_low_battery_shutdown(); //shutdown robot here to protect battery } else if (BatteryVoltage < (float)7.2) { //Notify user to shutdown robot buzzer_low_batterry_notify(); } }
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); } } }
//***************************************************************************** // // This function is called each time the ADC sample sequence completes. // //***************************************************************************** void ADCIntHandler(void) { unsigned short pusADCData[8]; unsigned long ulIdx; // // Clear the ADC interrupt. // ROM_ADCIntClear(ADC0_BASE, 0); // // If running on Rev A0 silicon, clear the PWM trigger interrupt sources. // This is a workaround to allow them to retrigger the ADC. Since this // workaround is otherwise harmless, it is done unconditionally (to avoid // checking the silicon revision within this interrupt handler). // ROM_PWMGenIntClear(PWM0_BASE, PWM_GEN_0, PWM_INT_CNT_BD); // // Call the H-bridge update function. // HBridgeTick(); // // Drain the ADC of conversions. // if(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY) { return; } pusADCData[0] = HWREG(ADC0_BASE + ADC_O_SSFIFO0); if(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY) { return; } pusADCData[1] = HWREG(ADC0_BASE + ADC_O_SSFIFO0); if(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY) { return; } pusADCData[2] = HWREG(ADC0_BASE + ADC_O_SSFIFO0); if(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY) { return; } pusADCData[3] = HWREG(ADC0_BASE + ADC_O_SSFIFO0); if(!(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY)) { while(!(HWREG(ADC0_BASE + ADC_O_SSFSTAT0) & ADC_SSFSTAT0_EMPTY)) { HWREG(ADC0_BASE + ADC_O_SSFIFO0); } return; } g_pusADCData[0] = pusADCData[0]; g_pusADCData[1] = pusADCData[1]; g_pusADCData[2] = pusADCData[2]; g_pusADCData[3] = pusADCData[3]; // // Put this winding current reading into the current bucket. // g_pusBuckets[g_ulBucket >> 16] += g_pusADCData[WINDING_CURRENT]; g_ulBucket++; // // See if this bucket is full. // if((g_ulBucket & 0xffff) == 16) { // // Compute the new averaged winding current reading. // g_usCurrent = ((g_pusBuckets[0] + g_pusBuckets[1] + g_pusBuckets[2] + g_pusBuckets[3] + g_pusBuckets[4] + g_pusBuckets[5] + g_pusBuckets[6] + g_pusBuckets[7]) / (8 * 16)); // // Advance to the next bucket. // g_ulBucket = (g_ulBucket + 0x10000) & 0x00070000; g_pusBuckets[g_ulBucket >> 16] = 0; }
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); } }