void adc_enable_single_swstart(adc_dev *dev) { adc_init(dev); adc_set_extsel(dev, ADC_SWSTART); adc_set_exttrig(dev, 1); adc_enable(dev); adc_calibrate(dev); }
static void adc_setup(void) { int i; rcc_periph_clock_enable(RCC_ADC1); /* Make sure the ADC doesn't run during config. */ adc_power_off(ADC1); /* We configure everything for one single timer triggered injected conversion. */ adc_disable_scan_mode(ADC1); adc_set_single_conversion_mode(ADC1); /* We can only use discontinuous mode on either the regular OR injected channels, not both */ adc_disable_discontinuous_mode_regular(ADC1); adc_enable_discontinuous_mode_injected(ADC1); /* We want to start the injected conversion with the TIM2 TRGO */ adc_enable_external_trigger_injected(ADC1,ADC_CR2_JEXTSEL_TIM2_TRGO); adc_set_right_aligned(ADC1); /* We want to read the temperature sensor, so we have to enable it. */ adc_enable_temperature_sensor(); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); adc_power_on(ADC1); /* Wait for ADC starting up. */ for (i = 0; i < 800000; i++) /* Wait a bit. */ __asm__("nop"); adc_reset_calibration(ADC1); adc_calibrate(ADC1); }
void cmd_readadc(char *line) { adc_init(PIN_MAP[12].adc_device); // all on ADC1 adc_set_extsel(PIN_MAP[12].adc_device, ADC_SWSTART); adc_set_exttrig(PIN_MAP[12].adc_device, true); adc_enable(PIN_MAP[12].adc_device); adc_calibrate(PIN_MAP[12].adc_device); adc_set_sample_rate(PIN_MAP[12].adc_device, ADC_SMPR_55_5); gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[19].gpio_device,PIN_MAP[19].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[20].gpio_device,PIN_MAP[20].gpio_bit, GPIO_INPUT_ANALOG); uint16 value1 = adc_read(PIN_MAP[12].adc_device,PIN_MAP[12].adc_channel); uint16 value2 = adc_read(PIN_MAP[19].adc_device,PIN_MAP[19].adc_channel); uint16 value3 = adc_read(PIN_MAP[20].adc_device,PIN_MAP[20].adc_channel); char values[50]; sprintf(values,"PA6 ADC Read: %u\r\n",value1); serial_write_string(values); sprintf(values,"PC4 ADC Read: %u\r\n",value2); serial_write_string(values); sprintf(values,"PC5 ADC Read: %u\r\n",value3); serial_write_string(values); }
static void adc_setup(void) { gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO0); gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO1); /* Make sure the ADC doesn't run during config. */ adc_power_off(ADC1); /* We configure everything for one single conversion. */ adc_disable_scan_mode(ADC1); adc_set_single_conversion_mode(ADC1); adc_disable_external_trigger_regular(ADC1); adc_set_right_aligned(ADC1); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); adc_power_on(ADC1); /* Wait for ADC starting up. */ int i; for (i = 0; i < 800000; i++) /* Wait a bit. */ __asm__("nop"); adc_reset_calibration(ADC1); adc_calibrate(ADC1); }
static void adcDefaultConfig(const adc_dev* dev) { adc_init(dev); adc_set_extsel(dev, ADC_SWSTART); adc_set_exttrig(dev, 1); adc_enable(dev); adc_calibrate(dev); adc_set_sample_rate(dev, ADC_SMPR_55_5); }
void com_adc_calibrate(const ComType com, const ADCCalibrate *data) { uint8_t port = (uint8_t)(tolower((uint8_t)data->bricklet_port) - 'a'); if(port >= BRICKLET_NUM) { com_return_error(data, sizeof(MessageHeader), MESSAGE_ERROR_CODE_INVALID_PARAMETER, com); logblete("Bricklet Port %d does not exist (adc calibrate)\n\r", port); return; } adc_calibrate(bs[port].adc_channel); adc_write_calibration_to_flash(); com_return_setter(com, data); logd("ADC Calibrate (port %c)\n\r", data->bricklet_port); }
static void adcDefaultConfig(const adc_dev *dev) { adc_init(dev); // ok adc_set_extsel(dev, ADC_SWSTART); // ok adc_set_exttrig(dev, true); // ok adc_enable(dev); // up to 1mA adc_calibrate(dev); // stick at 1mA adc_set_sample_rate(dev, ADC_SMPR_55_5); // stick at 1mA }
static void adc_setup(void) { int i; rcc_periph_clock_enable(RCC_ADC1); /* Make sure the ADC doesn't run during config. */ adc_power_off(ADC1); /* We configure everything for one single timer triggered injected conversion with interrupt generation. */ /* While not needed for a single channel, try out scan mode which does all channels in one sweep and * generates the interrupt/EOC/JEOC flags set at the end of all channels, not each one. */ adc_enable_scan_mode(ADC1); adc_set_single_conversion_mode(ADC1); /* We want to start the injected conversion with the TIM2 TRGO */ adc_enable_external_trigger_injected(ADC1,ADC_CR2_JEXTSEL_TIM2_TRGO); /* Generate the ADC1_2_IRQ */ adc_enable_eoc_interrupt_injected(ADC1); adc_set_right_aligned(ADC1); /* We want to read the temperature sensor, so we have to enable it. */ adc_enable_temperature_sensor(); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); /* Select the channels we want to convert. * 16=temperature_sensor, 17=Vrefint, 13=ADC1, 10=ADC2 */ channel_array[0] = 16; channel_array[1] = 17; channel_array[2] = 13; channel_array[3] = 10; adc_set_injected_sequence(ADC1, 4, channel_array); adc_power_on(ADC1); /* Wait for ADC starting up. */ for (i = 0; i < 800000; i++) /* Wait a bit. */ __asm__("nop"); adc_reset_calibration(ADC1); adc_calibrate(ADC1); }
static void enable(void) { // DMA DMA1_Channel1->CCR = 0; // Deinitialize DMA1_Channel1->CMAR = (uint32_t)_adc1_2_dma_buffer; DMA1_Channel1->CNDTR = sizeof(_adc1_2_dma_buffer) / 4; DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR; DMA1_Channel1->CCR = DMA_CCR_PL_0 | DMA_CCR_PL_1 | // Max priority DMA_CCR_MSIZE_1 | // 32 bit DMA_CCR_PSIZE_1 | // 32 bit DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_EN; // ADC enable, reset const uint32_t enr_mask = RCC_APB2ENR_ADC1EN | RCC_APB2ENR_ADC2EN; const uint32_t rst_mask = RCC_APB2RSTR_ADC1RST | RCC_APB2RSTR_ADC2RST; chSysDisable(); RCC->APB2ENR |= enr_mask; RCC->APB2RSTR |= rst_mask; RCC->APB2RSTR &= ~rst_mask; chSysEnable(); usleep(5); // Sequence: enable ADC, wait 2+ cycles, poweron, calibrate? // ADC calibration ADC1->CR2 = ADC_CR2_ADON; adc_calibrate(ADC1); ADC2->CR2 = ADC_CR2_ADON; adc_calibrate(ADC2); /* * ADC channel sampling: * A B C A B C VOLT * C A B C A B CURR */ ADC1->SQR1 = ADC_SQR1_L_1 | ADC_SQR1_L_2; ADC1->SQR3 = ADC_SQR3_SQ1_0 | ADC_SQR3_SQ2_1 | ADC_SQR3_SQ3_0 | ADC_SQR3_SQ3_1 | ADC_SQR3_SQ4_0 | ADC_SQR3_SQ5_1 | ADC_SQR3_SQ6_0 | ADC_SQR3_SQ6_1; ADC1->SQR2 = ADC_SQR2_SQ7_2; ADC2->SQR1 = ADC1->SQR1; ADC2->SQR3 = ADC_SQR3_SQ1_0 | ADC_SQR3_SQ1_1 | ADC_SQR3_SQ2_0 | ADC_SQR3_SQ3_1 | ADC_SQR3_SQ4_0 | ADC_SQR3_SQ4_1 | ADC_SQR3_SQ5_0 | ADC_SQR3_SQ6_1; ADC2->SQR2 = ADC_SQR2_SQ7_2 | ADC_SQR2_SQ7_0; // SMPR registers are not configured because they have right values by default // ADC initialization ADC1->CR1 = ADC_CR1_DUALMOD_1 | ADC_CR1_DUALMOD_2 | ADC_CR1_SCAN | ADC_CR1_EOCIE; ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_EXTTRIG | MOTOR_ADC1_2_TRIGGER | ADC_CR2_DMA; ADC2->CR1 = ADC_CR1_DUALMOD_1 | ADC_CR1_DUALMOD_2 | ADC_CR1_SCAN; ADC2->CR2 = ADC_CR2_ADON | ADC_CR2_EXTTRIG | ADC_CR2_EXTSEL_0 | ADC_CR2_EXTSEL_1 | ADC_CR2_EXTSEL_2; // ADC IRQ (only ADC1 IRQ is used because ADC2 is configured in slave mode) chSysDisable(); nvicEnableVector(ADC1_2_IRQn, MOTOR_IRQ_PRIORITY_MASK); chSysEnable(); }
void serial_process_command(char *line) { if(in_displayparams) { serial_displayparams_run(line); in_displayparams = false; } if(in_setdevicetag) { serial_setdevicetag_run(line); in_setdevicetag = false; } if(in_setrtc) { serial_setrtc_run(line); in_setrtc = false; } if(in_setkeyval) { serial_setkeyval_run(line); in_setkeyval = false; } serial_write_string("\r\n"); if(strcmp(line,"HELLO") == 0) { serial_write_string("GREETINGS PROFESSOR FALKEN.\r\n"); } else if(strcmp(line,"LIST GAMES") == 0) { serial_write_string("I'M KIND OF BORED OF GAMES, TURNS OUT THE ONLY WAY TO WIN IS NOT TO PLAY...\r\n"); } else if(strcmp(line,"LOGXFER") == 0) { serial_sendlog(); } else if(strcmp(line,"DISPLAYPARAMS") == 0) { serial_displayparams(); } else if(strcmp(line,"HELP") == 0) { serial_write_string("Available commands: HELP, LOGXFER, DISPLAYTEST, HELLO"); } else if(strcmp(line,"DISPLAYTEST") == 0) { display_test(); } else if(strcmp(line,"LOGTEST") == 0) { char stemp[100]; sprintf(stemp,"Raw log data\r\n"); serial_write_string(stemp); uint8_t *flash_log = flashstorage_log_get(); for(int n=0;n<1024;n++) { sprintf(stemp,"%u ",flash_log[n]); serial_write_string(stemp); if(n%64 == 0) serial_write_string("\r\n"); } serial_write_string("\r\n"); log_data_t data; data.time = 0; data.cpm = 1; data.accel_x_start = 2; data.accel_y_start = 3; data.accel_z_start = 4; data.accel_x_end = 5; data.accel_y_end = 6; data.accel_z_end = 7; data.log_type = UINT_MAX; sprintf(stemp,"Log size: %u\r\n",flashstorage_log_size()); serial_write_string(stemp); sprintf(stemp,"Writing test log entry of size: %u\r\n",sizeof(log_data_t)); serial_write_string(stemp); flashstorage_log_pushback((uint8 *) &data,sizeof(log_data_t)); sprintf(stemp,"Log size: %u\r\n",flashstorage_log_size()); serial_write_string(stemp); } else if(strcmp(line,"VERSION") == 0) { char stemp[50]; sprintf(stemp,"Version: %s\r\n",OS100VERSION); serial_write_string(stemp); } else if(strcmp(line,"GETDEVICETAG") == 0) { const char *devicetag = flashstorage_keyval_get("DEVICETAG"); if(devicetag != 0) { char stemp[100]; sprintf(stemp,"Devicetag: %s\r\n",devicetag); serial_write_string(stemp); } else { serial_write_string("No device tag set"); } } else if(strcmp(line,"SETDEVICETAG") == 0) { serial_setdevicetag(); } else if(strcmp(line,"READPRIVATEKEY") == 0) { // serial_readprivatekey(); // removed for production } else if(strcmp(line,"WRITEPRIVATEKEY") == 0) { // serial_writeprivatekey(); // maybe this should be removed for production? } else if(strcmp(line,"MAGREAD") == 0) { gpio_set_mode (PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit, GPIO_OUTPUT_PP); // MAGPOWER gpio_set_mode (PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit, GPIO_INPUT_PU); // MAGSENSE // Power up magsense gpio_write_bit(PIN_MAP[41].gpio_device,PIN_MAP[41].gpio_bit,1); // wait... delay_us(1000); // Read magsense int magsense = gpio_read_bit(PIN_MAP[29].gpio_device,PIN_MAP[29].gpio_bit); char magsenses[50]; sprintf(magsenses,"%u\r\n",magsense); serial_write_string(magsenses); } else if(strcmp(line,"WRITEDAC") == 0) { dac_init(DAC,DAC_CH2); int8_t idelta=1; uint8_t i=0; for(int n=0;n<1000000;n++) { if(i == 254) idelta = -1; if(i == 0 ) idelta = 1; i += idelta; dac_write_channel(DAC,2,i); } serial_write_string("WRITEDACFIN"); } else if(strcmp(line,"TESTHP") == 0) { gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_OUTPUT_PP); // HP_COMBINED for(int n=0;n<100000;n++) { gpio_write_bit(PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit,1); delay_us(100); gpio_write_bit(PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit,0); delay_us(100); } } else if(strcmp(line,"READADC") == 0) { adc_init(PIN_MAP[12].adc_device); // all on ADC1 adc_set_extsel(PIN_MAP[12].adc_device, ADC_SWSTART); adc_set_exttrig(PIN_MAP[12].adc_device, true); adc_enable(PIN_MAP[12].adc_device); adc_calibrate(PIN_MAP[12].adc_device); adc_set_sample_rate(PIN_MAP[12].adc_device, ADC_SMPR_55_5); gpio_set_mode (PIN_MAP[12].gpio_device,PIN_MAP[12].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[19].gpio_device,PIN_MAP[19].gpio_bit, GPIO_INPUT_ANALOG); gpio_set_mode (PIN_MAP[20].gpio_device,PIN_MAP[20].gpio_bit, GPIO_INPUT_ANALOG); int n=0; uint16 value1 = adc_read(PIN_MAP[12].adc_device,PIN_MAP[12].adc_channel); uint16 value2 = adc_read(PIN_MAP[19].adc_device,PIN_MAP[19].adc_channel); uint16 value3 = adc_read(PIN_MAP[20].adc_device,PIN_MAP[20].adc_channel); char values[50]; sprintf(values,"PA6 ADC Read: %u\r\n",value1); serial_write_string(values); sprintf(values,"PC4 ADC Read: %u\r\n",value2); serial_write_string(values); sprintf(values,"PC5 ADC Read: %u\r\n",value3); serial_write_string(values); } else if(strcmp(line,"SETMICREVERSE") == 0) { gpio_set_mode (PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit, GPIO_OUTPUT_PP); // MICREVERSE gpio_set_mode (PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit, GPIO_OUTPUT_PP); // MICIPHONE gpio_write_bit(PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit,1); // MICREVERSE gpio_write_bit(PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit,0); // MICIPHONE serial_write_string("Set MICREVERSE to 1, MICIPHONE to 0\r\n"); } else if(strcmp(line,"SETMICIPHONE") == 0) { gpio_set_mode (PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit, GPIO_OUTPUT_PP); // MICREVERSE gpio_set_mode (PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit, GPIO_OUTPUT_PP); // MICIPHONE gpio_write_bit(PIN_MAP[36].gpio_device,PIN_MAP[36].gpio_bit,0); // MICREVERSE gpio_write_bit(PIN_MAP[35].gpio_device,PIN_MAP[35].gpio_bit,1); // MICIPHONE serial_write_string("Set MICREVERSE to 0, MICIPHONE to 1\r\n"); } else if(strcmp(line,"TESTSIGN") == 0) { serial_signing_test(); } else if(strcmp(line,"PUBKEY") == 0) { signing_printPubKey(); serial_write_string("\n\r"); } else if(strcmp(line,"GUID") == 0) { signing_printGUID(); serial_write_string("\n\r"); } else if(strcmp(line,"KEYVALID") == 0) { if( signing_isKeyValid() == 1 ) serial_write_string("uu_valid VALID KEY\r\n"); else serial_write_string("uu_valid IMPROPER OR UNINITIALIZED KEY\r\n"); } else if(strcmp(line,"LOGSIG") == 0) { signing_hashLog(); serial_write_string("\n\r"); } else if(strcmp(line,"LOGPAUSE") == 0) { flashstorage_log_pause(); } else if(strcmp(line,"LOGRESUME") == 0) { flashstorage_log_resume(); } else if(strcmp(line,"LOGCLEAR") == 0) { serial_write_string("Clearing flash log\r\n"); flashstorage_log_clear(); serial_write_string("Cleared\r\n"); } else if(strcmp(line,"KEYVALDUMP") == 0) { serial_keyvaldump(); } else if(strcmp(line,"KEYVALSET") == 0) { serial_setkeyval(); } else if(strcmp(line,"SETRTC") == 0) { serial_setrtc(); } else if(strcmp(line,"RTCALARM") == 0) { serial_write_string("Alarm triggered for 10s\r\n"); rtc_set_alarm(RTC,rtc_get_time(RTC)+10); } serial_write_string("\r\n>"); }
int main(int argc, char* argv[]) { char buffer[80]; initialize(); hd44780_reset(HD44780_CMD_FUNC_SET | HD44780_CMD_FUNC_2LINES); hd44780_ir_write(HD44780_CMD_DISPLAY | HD44780_CMD_DISPLAY_ON | HD44780_CMD_DISPLAY_CURS_ON | HD44780_CMD_DISPLAY_CURS_BLINK ); hd44780_wait_busy(); hd44780_ir_write(HD44780_CMD_EMS | HD44780_CMD_EMS_INCR); hd44780_wait_busy(); adc_calibrate(); adc_start(); while(1) { uint16_t internal_temp = adc_get_median(0), external_temp = adc_get_median(1), battery = adc_get_median(2), reference = adc_get_median(3); //trace_printf("%d %d %d\n", external_temp, internal_temp, reference); uint32_t vdd = 3300u * *VREFINT_CAL / reference; uint32_t internal_temp_volts = internal_temp * vdd / 0xfff, external_temp_volts = external_temp * vdd / 0xfff, battery_volts = battery * vdd / 0xfff; int len = snprintf(buffer, sizeof(buffer), "%04x %04x %04x %04x", internal_temp, external_temp, battery, reference); //hd44780_clear_screen(); hd44780_goto_addr(0); hd44780_puts(buffer, len); len = snprintf(buffer, sizeof(buffer), "%ld.%03ld %ld.%03ld %ld.%03ld", internal_temp_volts / 1000, internal_temp_volts % 1000, external_temp_volts / 1000, external_temp_volts % 1000, battery_volts / 1000, battery_volts % 1000); hd44780_goto_addr(64); hd44780_puts(buffer, len); int32_t internal_temp_celsius = (int32_t)steinhart(internal_temp) - 273150; int32_t external_temp_celsius = hot_junction_temperature(internal_temp, external_temp, reference); len = snprintf(buffer, sizeof(buffer), "%ld.%03d %ld.%05d", internal_temp_celsius / 1000, abs(internal_temp_celsius) % 1000, external_temp_celsius / 100000, abs(external_temp_celsius) % 100000); hd44780_goto_addr(20); hd44780_puts(buffer, len); len = snprintf(buffer, sizeof(buffer), "%lu.%03lu", vdd / 1000, vdd % 1000); hd44780_goto_addr(84); hd44780_puts(buffer, len); delay_1ms(1000); } }
void STM32ADC::calibrate() { adc_calibrate(_dev); }
int adcc_init(int adc_num) { //PORT_MemMapPtr pctl = NULL; //uint8_t gpio_port; /* led pin init */ if(!lwgpio_init(&pm2p5_ledgpio, PM2P5_LED_PWREN, LWGPIO_DIR_OUTPUT, LWGPIO_VALUE_NOCHANGE)) { printf("Initializing GPIO with associated pins failed.\n"); _time_delay (200L); _task_block(); } lwgpio_set_functionality(&pm2p5_ledgpio, PM2P5_LED_MUX_GPIO); //lwgpio_set_value(&pm2p5_ledgpio, LWGPIO_VALUE_LOW); lwgpio_set_value(&pm2p5_ledgpio, LWGPIO_VALUE_HIGH); if(adc_num == 0) { /* SIM_SCGC6: ADC0=1 */ adc_ptr = ADC0_BASE_PTR; SIM_SCGC6 |= SIM_SCGC6_ADC0_MASK; } else { adc_ptr = ADC1_BASE_PTR; SIM_SCGC6 |= SIM_SCGC6_ADC1_MASK; } #ifdef ADC_HW_TRIGER SIM_SCGC6 |= SIM_SCGC6_PIT_MASK; /* enable PIT */ SIM_SOPT7 |= SIM_SOPT7_ADC1ALTTRGEN_MASK; SIM_SOPT7 |= (SIM_SOPT7_ADC1PRETRGSEL_MASK); /* Pre Trigger B */ SIM_SOPT7 &= ~(SIM_SOPT7_ADC1TRGSEL_MASK); SIM_SOPT7 |= SIM_SOPT7_ADC1TRGSEL(7); /* PIT trigger 3 */ PIT_MCR_REG(PIT_BASE_PTR) = 0; #endif // pin mux config : spec P216 ADC0_DP0/ADC1_DP3 is default /* set pin's multiplexer to analog gpio_port = ADC_SIG_PORTB | 4; pctl = (PORT_MemMapPtr) PORTB_BASE_PTR; pctl->PCR[gpio_port & 0x1F] &= ~PORT_PCR_MUX_MASK; */ // Initialize ADC0/1 ================================================================================= //averages (4 h/w) // bus 60M /8/2 = 3.75M ADC clock ADC_CFG1_REG(adc_ptr) = ADLPC_NORMAL | ADC_CFG1_ADIV(ADIV_8) /*| ADLSMP_LONG*/ | ADC_CFG1_MODE(MODE_16) | ADC_CFG1_ADICLK(/*ADICLK_BUS_2*/ADICLK_BUS); // do calibration if(adc_calibrate(adc_ptr)) printf("adc-%x calibrate failed\n",(int)adc_ptr); /* channel A/B selected */ #ifdef ADC_HW_TRIGER ADC_CFG2_REG(adc_ptr) = MUXSEL_ADCB | ADACKEN_ENABLED | ADHSC_HISPEED | ADC_CFG2_ADLSTS(ADLSTS_20); #else ADC_CFG2_REG(adc_ptr) = MUXSEL_ADCA /*| ADACKEN_ENABLED */| ADHSC_HISPEED | ADC_CFG2_ADLSTS(ADLSTS_20); #endif //ADC_CV1_REG(adc_ptr) = 0x0; //ADC_CV2_REG(adc_ptr) = 0x0; //ADC_SC1_REG(adc_ptr,0) = AIEN_ON | DIFF_SINGLE | ADC_SC1_ADCH(ADC_INPUT_CH); /* SC1 A */ //ADC_SC1_REG(adc_ptr,1) = AIEN_ON | DIFF_SINGLE | ADC_SC1_ADCH(ADC_INPUT_CH); /* SC1 B */ #ifdef ADC_HW_TRIGER ADC_SC2_REG(adc_ptr) = ADTRG_HW /*ADTRG_SW*/ | ACFE_DISABLED | ACFGT_GREATER | ACREN_DISABLED | DMAEN_DISABLED /* DMAEN_ENABLED*/| ADC_SC2_REFSEL(REFSEL_EXT); #else ADC_SC2_REG(adc_ptr) = ADTRG_SW /*| ACFE_DISABLED | ACFGT_GREATER | ACREN_DISABLED | DMAEN_DISABLED*/ | ADC_SC2_REFSEL(REFSEL_EXT); #endif ADC_SC3_REG(adc_ptr) = /*ADC_SC3_CALF_MASK |*/ CAL_OFF | ADCO_SINGLE /*| AVGE_ENABLED | ADC_SC3_AVGS(AVGS_4)*/; /* averages 4 h/w */ }