u16 getAverage(u8 channel) { u8 i; u16 temp,max,min,ret; temp = getAdcValue(channel<<4); ret= temp; max =temp; min = temp; for(i=0;i<9;i++) { delay_us(200); temp = getAdcValue(channel<<4); if(temp > max) { max = temp; } if(temp < min) { min = temp; } ret += temp; } return (ret - max - min)>>3;
/** * @return kg/hour value */ float getRealMaf(DECLARE_ENGINE_PARAMETER_F) { int mafAdc = getAdcValue("maf", engineConfiguration->mafAdcChannel); /** * here we drop from 12 bit ADC to 8 bit index */ return engine->mafDecodingLookup[mafAdc >> 4]; }
/** Read white line sensors and encode the values in lower three LSBs */ STATUS readWhiteLineSensors(UINT *pValue) { UINT wl1, wl2, wl3; STATUS ret; ASSERT(pValue != NULL); ret = getAdcValue(ADC_WHITE_LINE1, &wl1); /* Left */ ASSERT(ret == STATUS_OK); ret = getAdcValue(ADC_WHITE_LINE2, &wl2); /* Middle */ ASSERT(ret == STATUS_OK); ret = getAdcValue(ADC_WHITE_LINE3, &wl3); /* Right */ ASSERT(ret == STATUS_OK); *pValue = COLOR(wl1) << 2 | COLOR(wl2) << 1 | COLOR(wl3); return STATUS_OK; }
/** * get battery voltage * Measure AVCC again the the internal band gap reference * * REFS1 REFS0 --> internal bandgap reference * MUX3 MUX2 MUX1 MUX0 --> 1110 1.1V (VBG) (for instance Atmega 328p) */ uint16_t Battery::getBatteryVoltageInternal() { uint16_t adcValue = getAdcValue( (0<<REFS1) | (1<<REFS0), // Voltage Reference = AVCC with external capacitor at AREF pin (1<<MUX3) | (1<<MUX2) | (1<<MUX1) | (0<<MUX0) // Input Channel = 1.1V (V BG) ); adcValue = AVR_BANDGAP_VOLTAGE * 1023 / adcValue; // calculate battery voltage in mV return adcValue; }
/* usbFunctionRead() is called when the host requests a chunk of data from * the device. For more information see the documentation in usbdrv/usbdrv.h. */ uchar usbFunctionRead(uchar *data, uchar len) { if(len > bytesRemaining) len = bytesRemaining; //eeprom_read_block(data, (uchar *)0 + currentAddress, len); *(ushort*)data = (ushort)getAdcValue(); currentAddress += len; bytesRemaining -= len; return len; }
uint16_t Battery::getBatteryVoltageExternal() { pinMode(tEnablePin, OUTPUT); digitalWrite(tEnablePin, LOW); uint16_t adcValue = getAdcValue( (1<<REFS1) | (1<<REFS0), // Voltage Reference = Internal 1.1V Voltage Reference tAdcPin ); float tmpFloat = ((adcValue * AVR_BANDGAP_VOLTAGE) / 1023) / tFact; // calculate battery voltage in mV adcValue = (uint16_t)tmpFloat; pinMode(tEnablePin, INPUT); return adcValue; }
/* * Return TPS ADC readings. * We need ADC value because TunerStudio has a nice TPS configuration wizard, and this wizard * wants a TPS value. */ int getTPS12bitAdc(DECLARE_ENGINE_PARAMETER_SIGNATURE) { #if !EFI_PROD_CODE if (engine->mockTpsAdcValue != MOCK_UNDEFINED) { return engine->mockTpsAdcValue; } #endif if (engineConfiguration->tps1_1AdcChannel == EFI_ADC_NONE) return -1; #if EFI_PROD_CODE return getAdcValue("tps10", engineConfiguration->tps1_1AdcChannel); // return tpsFastAdc / 4; #else return 0; #endif /* EFI_PROD_CODE */ }
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) { if (htim->Instance == htim1.Instance) { HAL_GPIO_TogglePin(GREEN_LED_GPIO_Port, GREEN_LED_Pin); } else if (htim->Instance == htim2.Instance) { char *buffer = malloc(sizeof(char) * 16); uint32_t value = getAdcValue(nextChannel); int l = sprintf(buffer, "%d: %08ld\n", nextChannel, value); UART_Send((uint8_t *)buffer, l); nextChannel++; if (nextChannel == 3) { nextChannel = 0; } } }
static void printAdcValue(adc_channel_e channel) { int value = getAdcValue("print", channel); float volts = adcToVoltsDivided(value); scheduleMsg(&logger, "adc voltage : %.2f", volts); }
int main() { AdcChannel channel[] = { ADC_BATTERY_VOLTAGE, ADC_WHITE_LINE1, ADC_WHITE_LINE2, ADC_WHITE_LINE3, ADC_IR_PROXIMITY1, ADC_IR_PROXIMITY2, ADC_IR_PROXIMITY3, ADC_IR_PROXIMITY4, ADC_IR_PROXIMITY5, ADC_IR_RANGE1, ADC_IR_RANGE2, ADC_IR_RANGE3, ADC_IR_RANGE4, ADC_IR_RANGE5, ADC_SERVO_POD1, ADC_SERVO_POD1, ADC_LAST }; char strChannel[17][20] = { "ADC_BATTERY_VOLTAGE", "ADC_WHITE_LINE1", "ADC_WHITE_LINE2", "ADC_WHITE_LINE3", "ADC_IR_PROXIMITY1", "ADC_IR_PROXIMITY2", "ADC_IR_PROXIMITY3", "ADC_IR_PROXIMITY4", "ADC_IR_PROXIMITY5", "ADC_IR_RANGE1", "ADC_IR_RANGE2", "ADC_IR_RANGE3", "ADC_IR_RANGE4", "ADC_IR_RANGE5", "ADC_SERVO_POD1", "ADC_SERVO_POD2", "ADC_LAST" }; char buf[17]; UINT value, idx; initAdc(); initLcd(); for(idx = 0; idx < (sizeof(channel)/sizeof(channel[0])); idx ++) { lcdClear(); lcdCursor(1,1); lcdString(strChannel[idx]); lcdCursor(2,1); if(getAdcValue(channel[idx], &value) == STATUS_OK) { snprintf(buf, sizeof(buf), "%d", value); lcdString(buf); } else { lcdString("Error"); } _delay_ms(DELAY_COUNT); } return 0; }
/* * Return TPS ADC readings. * We need ADC value because TunerStudio has a nice TPS configuration wizard, and this wizard * wants a TPS value. */ int getTPS10bitAdc(void) { int adc = getAdcValue(engineConfiguration->tpsAdcChannel); return (int) adc / 4; // Only for TunerStudio compatibility. Max TS adc value in 1023 }
static void printAdcValue(int channel) { int value = getAdcValue(channel); float volts = adcToVoltsDivided(value); scheduleMsg(&logger, "adc voltage : %f", volts); }
int main(void) { uchar i; /* calibration value from last time */ uchar calibrationValue = eeprom_read_byte(EEPROM_OSCCAL); if(calibrationValue != 0xff) { OSCCAL = calibrationValue; } wdt_enable(WDTO_1S); /* Even if you don't use the watchdog, turn it off here. On newer devices, * the status of the watchdog (on/off, period) is PRESERVED OVER RESET! */ /* RESET status: all port bits are inputs without pull-up. * That's the way we need D+ and D-. Therefore we don't need any * additional hardware initialization. */ odDebugInit(); DBG1(0x00, 0, 0); /* debug output: main starts */ sbi(DDRB, WHITE_LED); sbi(DDRB, YELLOW_LED); cbi(DDRB, 4); cbi(PORTB, 4); sbi(MCUCR, PUD); timerInit(); //Create a timer that will trigger a flag at a ~60hz rate adcInit(); //Setup the ADC conversions usbInit(); usbDeviceDisconnect(); /* enforce re-enumeration, do this while interrupts are disabled! */ i = 0; while(--i) { /* fake USB disconnect for > 250 ms */ wdt_reset(); _delay_ms(1); } usbDeviceConnect(); //set_sleep_mode(SLEEP_MODE_PWR_SAVE); //sleep_mode(); //sleep_enable(); sei(); DBG1(0x01, 0, 0); /* debug output: main loop starts */ for(;;) { /* main event loop */ DBG1(0x02, 0, 0); /* debug output: main loop iterates */ //sleep_cpu(); sbi(PORTB, YELLOW_LED); wdt_reset(); usbPoll(); cbi(PORTB, YELLOW_LED); if(usbInterruptIsReady()) { /* called after every poll of the interrupt endpoint */ reportBuffer.adcvalue = getAdcValue(); DBG1(0x03, 0, 0); /* debug output: interrupt report prepared */ usbSetInterrupt((void *)&reportBuffer, sizeof(reportBuffer)); } timerPoll(); adcPoll(); _delay_ms(5); } return 0; }