void adc_init (void) { rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_ADC1EN); rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPAEN); rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_IOPCEN); gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); //PA1 joint_1 gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO2); //PA2 joint_2 gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO3); //PA3 joint_3 gpio_mode_setup(GPIOC, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); //PC1 joint_4 gpio_mode_setup(GPIOC, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO2); //PC2 joint_5 gpio_mode_setup(GPIOC, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO5); //PC5 joint_6 adc_set_clk_prescale(ADC_CCR_ADCPRE_BY2); adc_disable_scan_mode(ADC1); adc_set_single_conversion_mode(ADC1); adc_set_sample_time(ADC1, ADC_CHANNEL1, ADC_SMPR_SMP_3CYC); //joint_1 adc_set_sample_time(ADC1, ADC_CHANNEL2, ADC_SMPR_SMP_3CYC); //joint_2 adc_set_sample_time(ADC1, ADC_CHANNEL3, ADC_SMPR_SMP_3CYC); //joint_3 adc_set_sample_time(ADC1, ADC_CHANNEL11, ADC_SMPR_SMP_3CYC); //joint_4 adc_set_sample_time(ADC1, ADC_CHANNEL12, ADC_SMPR_SMP_3CYC); //joint_5 adc_set_sample_time(ADC1, ADC_CHANNEL15, ADC_SMPR_SMP_3CYC); //joint_6 adc_set_multi_mode(ADC_CCR_MULTI_INDEPENDENT); adc_power_on(ADC1); //nvic_enable_irq(NVIC_ADC_IRQ); //adc_enable_eoc_interrupt(ADC1); //adc_disable_eoc_interrupt(ADC1); }
void adc_setup(void) { //ADC rcc_peripheral_enable_clock(&RCC_AHBENR, RCC_AHBENR_ADC12EN); rcc_peripheral_enable_clock(&RCC_AHBENR, RCC_AHBENR_IOPAEN); //ADC gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO0); gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); adc_off(ADC1); adc_set_clk_prescale(ADC_CCR_CKMODE_DIV2); adc_set_single_conversion_mode(ADC1); adc_disable_external_trigger_regular(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_SMPR1_SMP_61DOT5CYC); uint8_t channel_array[16]; channel_array[0]=16; // Vts (Internal temperature sensor channel_array[0]=1; //ADC1_IN1 (PA0) adc_set_regular_sequence(ADC1, 1, channel_array); adc_set_resolution(ADC1, ADC_CFGR_RES_12_BIT); adc_power_on(ADC1); /* Wait for ADC starting up. */ int i; for (i = 0; i < 800000; i++) /* Wait a bit. */ __asm__("nop"); }
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_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_calibration(ADC1); }
/** **************************************************************************************** * @brief Initialize ADC * @param[in] in_mod ADC input mode * @param[in] work_clk ADC work_clk = (ADC_SOURCE_CLK / (2<<ADC_DIV)), ADC_DIV = 0 ~ 15, * ADC_SOURCE_CLK is 32k or system clock(4 types, decided by CLK_MUX), * the max work_clk = 1MHz. * @param[in] ref_vol ADC reference voltage * @param[in] resolution ADC resolution * @description * This function is used to set ADC input mode, work clock, reference voltage, resolution, * and interrupt. * ***************************************************************************************** */ void adc_init(enum ADC_IN_MOD in_mod, enum ADC_WORK_CLK work_clk, enum ADC_REF ref_vol, enum ADC_RESOLUTION resolution) { adc_init_configuration adc_cfg; #if CONFIG_ADC_DEFAULT_IRQHANDLER==TRUE adc_env.mode = SINGLE_MOD; adc_env.samples = 0; adc_env.bufptr = NULL; #if ADC_CALLBACK_EN==TRUE adc_env.callback = NULL; #endif #endif // enable ADC module clock adc_clock_on(); // power on ADC module adc_power_on(); // delay for power on delay(30); // reset adc register adc_reset(); adc_cfg.work_clk = work_clk; adc_cfg.ref_vol = ref_vol; adc_cfg.resolution = resolution; switch (in_mod) { case ADC_DIFF_WITH_BUF_DRV: adc_cfg.buf_in_p = ADC_BUFIN_CHANNEL; adc_cfg.buf_in_n = ADC_BUFIN_CHANNEL; adc_cfg.gain = ADC_BUF_GAIN_BYPASS; break; case ADC_DIFF_WITHOUT_BUF_DRV: adc_cfg.buf_in_p = ADC_BUFIN_CHANNEL; adc_cfg.buf_in_n = ADC_BUFIN_CHANNEL; adc_cfg.gain = ADC_BUF_BYPASS; break; case ADC_SINGLE_WITH_BUF_DRV: adc_cfg.buf_in_p = ADC_BUFIN_CHANNEL; adc_cfg.buf_in_n = ADC_BUFIN_VCM; adc_cfg.gain = ADC_BUF_GAIN_BYPASS; break; case ADC_SINGLE_WITHOUT_BUF_DRV: adc_cfg.buf_in_p = ADC_BUFIN_CHANNEL; adc_cfg.buf_in_n = ADC_BUFIN_GND; adc_cfg.gain = ADC_BUF_BYPASS; break; default: break; } __adc_cofig(&adc_cfg); __adc_calibrate(&adc_cfg); }
static void adc_setup(void) { rcc_periph_clock_enable(RCC_ADC); rcc_periph_clock_enable(RCC_GPIOA); gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO0); gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); adc_power_off(ADC1); adc_set_clk_source(ADC1, ADC_CLKSOURCE_ADC); adc_calibrate_start(ADC1); adc_calibrate_wait_finish(ADC1); adc_set_operation_mode(ADC1, ADC_MODE_SCAN); adc_disable_external_trigger_regular(ADC1); adc_set_right_aligned(ADC1); adc_enable_temperature_sensor(); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPTIME_071DOT5); adc_set_regular_sequence(ADC1, 1, channel_array); adc_set_resolution(ADC1, ADC_RESOLUTION_12BIT); adc_disable_analog_watchdog(ADC1); adc_power_on(ADC1); /* Wait for ADC starting up. */ int i; for (i = 0; i < 800000; i++) { /* Wait a bit. */ __asm__("nop"); } }
static void adc_setup(void) { int i; rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_ADC1EN); /* Make sure the ADC doesn't run during config. */ adc_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(ADC1); 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); while ((ADC_CR2(ADC1) & ADC_CR2_RSTCAL) != 0); adc_calibration(ADC1); while ((ADC_CR2(ADC1) & ADC_CR2_CAL) != 0); }
void adc_setup() { rcc_periph_clock_enable(RCC_ADC1); /* Make sure the ADC doesn't run during config. */ adc_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"); /* Select the channel we want to convert. 16=temperature_sensor. */ uint8_t channel_array[16]; channel_array[0] = 0; adc_set_regular_sequence(ADC1, 1, channel_array); /* Start the conversion directly (not trigger mode). */ adc_start_conversion_direct(ADC1); }
static void adc_setup(void) { int i; rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_ADC1EN); /* Make sure the ADC doesn't run during config. */ adc_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); /* We want to read the temperature sensor, so we have to enable it. */ adc_enable_temperature_sensor(ADC1); 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_calibration(ADC1); }
static void adc_setup(void) { int i; rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_ADC1EN); /* Make sure the ADC doesn't run during config. */ adc_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(ADC1); 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); while ((ADC_CR2(ADC1) & ADC_CR2_RSTCAL) != 0); adc_calibration(ADC1); while ((ADC_CR2(ADC1) & ADC_CR2_CAL) != 0); }
void adc_setup(void) { rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_ADC1EN); gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, GPIO6); gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO5 | GPIO1); /* Make sure the ADC doesn't run during config. */ adc_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_enable_temperature_sensor(ADC1); //adc_set_injected_offset(ADC1, 0x2, 0x00); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); adc_power_on(ADC1); /* Wait for ADC starting up. */ delay_ms(170); adc_reset_calibration(ADC1); adc_calibration(ADC1); }
/** * Configure a specific adc. */ void adc_config(uint32_t adc, const uint8_t const *channel_array) { adc_enable_scan_mode(adc); adc_set_continuous_conversion_mode(adc); adc_set_right_aligned(adc); adc_enable_external_trigger_regular(adc, ADC_CR2_EXTSEL_SWSTART); adc_set_sample_time_on_all_channels(adc, ADC_SAMPLE_TIME); adc_enable_dma(adc); adc_power_on(adc); { int i; /* Wait a bit for the adc to power on. */ for (i = 0; i < 800000; i++) { __asm("nop"); } } adc_reset_calibration(adc); adc_calibration(adc); adc_set_regular_sequence(adc, ADC_RAW_SAMPLE_COUNT/2, (uint8_t *)channel_array); }
static uint16_t ADC_Measure(uint16_t ch) { uint16_t val; uint8_t channel_array[16]; /* Make sure the ADC doesn't run during config. */ // adc_off(TS_ADC); /* We configure everything for one single conversion. */ adc_disable_scan_mode(TS_ADC); adc_set_single_conversion_mode(TS_ADC); adc_disable_external_trigger_regular(TS_ADC); adc_set_right_aligned(TS_ADC); /* ADC regular channel14 configuration */ // adc_set_sample_time(TS_ADC, ch, ADC_SMPR_SMP_55DOT5CYC); adc_set_sample_time_on_all_channels(TS_ADC, ADC_SMPR_SMP_55DOT5CYC); // adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC); // ADC_RegularChannelConfig(TS_ADC, ch, 1, ADC_SampleTime_55Cycles5); /* Enable ADC */ // ADC_Cmd(TS_ADC, ENABLE); adc_power_on(TS_ADC); delay(100); #if 1 /* Enable ADC reset calibaration register */ adc_reset_calibration(TS_ADC); // ADC_ResetCalibration(TS_ADC); /* Check the end of ADC reset calibration register */ // while(ADC_GetResetCalibrationStatus(TS_ADC)); /* Start ADC calibaration */ // ADC_StartCalibration(TS_ADC); // adc_calibration(TS_ADC); adc_calibrate_async(TS_ADC); /* Check the end of ADC calibration */ // while(ADC_GetCalibrationStatus(TS_ADC)); #endif /* Select the channel we want to convert. */ channel_array[0] = ch; adc_set_regular_sequence(TS_ADC, 1, channel_array); /* Start ADC Software Conversion */ // adc_start_conversion_regular(TS_ADC); adc_start_conversion_direct(TS_ADC); while(!adc_eoc(TS_ADC)); // val = adc_read_regular(TS_ADC); val = ADC_DR(TS_ADC); // adc_off(TS_ADC); return val; }
int main(void) { clock_setup(); gpio_setup(); systick_setup(); adc_off(ADC1); usart_enable_all_pins(); usart_console_setup(); printf("hello!\n"); // power up the RHT chip... dht_power(true); delay_ms(2000); setup_tim7(); platform_simrf_init(); // interrupt pin from mrf platform_mrf_interrupt_enable(); simrf_soft_reset(); simrf_init(); simrf_immediate_sleep(); simrf_pan_write(0xcafe); uint16_t pan_sanity_check = simrf_pan_read(); printf("pan read back in as %#x\n", pan_sanity_check); simrf_address16_write(0x1111); adc_power_on(ADC1); adc_reset_calibration(ADC1); adc_calibration(ADC1); jack_setup(&jack1, &state.jack_machine1); jack_setup(&jack2, &state.jack_machine2); //state.rf_dest_id = 0x4202; state.rf_dest_id = 0x1; while (1) { struct jacks_result_t jr1, jr2; simrf_check_flags(NULL, &handle_tx); loop_forever(); jack_run_task(&state.jack_machine1, &jr1); if (jr1.ready) { printf("Channel 1 result: %d\n", jr1.value); } jack_run_task(&state.jack_machine2, &jr2); if (jr2.ready) { printf("Channel 2 result: %d\n", jr2.value); } task_send_data(&state); __WFI(); } return 0; }
static void adc_setup(void) { gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO0); gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); adc_power_off(ADC1); adc_disable_scan_mode(ADC1); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_3CYC); adc_power_on(ADC1); }
void battery_setup() { gpio_mode_setup(BAT_STAT_PORT, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, BAT_STAT1_PORT | BAT_STAT2_PORT | BAT_PG_PORT); gpio_mode_setup(BAT_SENSE_PORT, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, BAT_SENSE_PIN); adc_off(BAT_SENSE_ADC); adc_disable_scan_mode(BAT_SENSE_ADC); adc_set_single_conversion_mode(ADC1); adc_set_sample_time(ADC1, ADC_CHANNEL10, ADC_SMPR_SMP_15CYC); uint8_t channels[] = {ADC_CHANNEL10}; adc_set_regular_sequence(BAT_SENSE_ADC, 1, channels); adc_power_on(BAT_SENSE_ADC); }
/*--------------------------------------------------------------------*/ void adc_setup(void) { rcc_periph_clock_enable(RCC_ADC1); rcc_periph_clock_enable(RCC_GPIOA); nvic_enable_irq(NVIC_ADC_IRQ); /* Set port PA1 for ADC1 to analogue mode. */ gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO1); adc_power_on(ADC1); uint8_t channel[1] = { ADC_CHANNEL1 }; adc_set_regular_sequence(ADC1, 1, channel); adc_set_clk_prescale(ADC_CCR_ADCPRE_BY2); adc_enable_scan_mode(ADC1); adc_set_continuous_conversion_mode(ADC1); adc_set_sample_time(ADC1, ADC_CHANNEL1, ADC_SMPR_SMP_3CYC); adc_set_multi_mode(ADC_CCR_MULTI_INDEPENDENT); adc_set_dma_continue(ADC1); adc_enable_dma(ADC1); adc_enable_overrun_interrupt(ADC1); }
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 platform_init_adc() { /* Set up DMA for the ADC */ nvic_enable_irq(NVIC_DMA2_STREAM0_IRQ); nvic_set_priority(NVIC_DMA2_STREAM0_IRQ, 64); /* Set up ADC */ for (int i = 0; i < NUM_SENSORS; ++i) { if (config.sensors[i].method == SENSOR_ADC) { adc_pins[i] = config.sensors[i].pin; gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, (1<<adc_pins[i])); } } adc_off(ADC1); adc_enable_scan_mode(ADC1); adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_15CYC); adc_power_on(ADC1); adc_disable_dma(ADC1); adc_enable_dma(ADC1); adc_clear_overrun_flag(ADC1); adc_set_dma_continue(ADC1); dma_stream_reset(DMA2, DMA_STREAM0); dma_set_priority(DMA2, DMA_STREAM0, DMA_SxCR_PL_HIGH); dma_set_memory_size(DMA2, DMA_STREAM0, DMA_SxCR_MSIZE_16BIT); dma_set_peripheral_size(DMA2, DMA_STREAM0, DMA_SxCR_PSIZE_16BIT); dma_enable_memory_increment_mode(DMA2, DMA_STREAM0); dma_set_transfer_mode(DMA2, DMA_STREAM0, DMA_SxCR_DIR_PERIPHERAL_TO_MEM); dma_enable_circular_mode(DMA2, DMA_STREAM0); dma_set_peripheral_address(DMA2, DMA_STREAM0, (uint32_t) &ADC1_DR); dma_set_memory_address(DMA2, DMA_STREAM0, (uint32_t) adc_dma_buf); dma_set_number_of_data(DMA2, DMA_STREAM0, NUM_SENSORS); dma_enable_transfer_complete_interrupt(DMA2, DMA_STREAM0); dma_channel_select(DMA2, DMA_STREAM0, DMA_SxCR_CHSEL_0); dma_enable_stream(DMA2, DMA_STREAM0); adc_set_regular_sequence(ADC1, NUM_SENSORS, adc_pins); }
void accel_highg_init() { uint8_t channel_array[16]; gpio_set_mode(GPIOB, GPIO_MODE_INPUT, GPIO_CNF_INPUT_ANALOG, GPIO0 | GPIO1 | GPIO2); adc_set_dual_mode(ADC_CR1_DUALMOD_RSM); /* ADC1 + ADC2 dual mode */ adc_set_dual_mode(ADC_CR1_DUALMOD_ISM); adc_enable_external_trigger_injected(ADC1, ADC_CR2_JEXTSEL_TIM1_TRGO); adc_enable_external_trigger_injected(ADC3, ADC_CR2_JEXTSEL_TIM1_TRGO); adc_enable_dma(ADC1); adc_enable_dma(ADC3); adc_power_on(ADC1); adc_power_on(ADC2); adc_power_on(ADC3); adc_stab_sleep(); adc_reset_calibration(ADC1); adc_reset_calibration(ADC2); adc_reset_calibration(ADC3); adc_calibration(ADC1); adc_calibration(ADC2); adc_calibration(ADC3); memset(channel_array, 0, sizeof(channel_array)); channel_array[0] = 10; adc_set_injected_sequence(ADC1, 1, channel_array); channel_array[0] = 11; adc_set_injected_sequence(ADC2, 1, channel_array); channel_array[0] = 12; adc_set_injected_sequence(ADC3, 1, channel_array); timer_reset(TIM1); timer_enable_irq(TIM1, TIM_DIER_UIE); timer_set_mode(TIM1, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); /* 500Hz */ timer_set_prescaler(TIM1, 64); timer_set_period(TIM1, 2250); /* Generate TRGO */ timer_set_master_mode(TIM1, TIM_CR2_MMS_UPDATE); dma_set_peripheral_address(DMA1, DMA_CHANNEL5, (uint32_t) &ADC1_DR); dma_set_read_from_memory(DMA1, DMA_CHANNEL5); dma_enable_memory_increment_mode(DMA1, DMA_CHANNEL5); dma_set_peripheral_size(DMA1, DMA_CHANNEL5, DMA_CCR_PSIZE_32BIT); dma_set_memory_size(DMA1, DMA_CHANNEL5, DMA_CCR_MSIZE_32BIT); dma_set_priority(DMA1, DMA_CHANNEL5, DMA_CCR_PL_HIGH); dma_set_peripheral_address(DMA1, DMA_CHANNEL6, (uint32_t) &ADC3_DR); dma_set_read_from_peripheral(DMA1, DMA_CHANNEL6); dma_enable_memory_increment_mode(DMA1, DMA_CHANNEL6); dma_set_peripheral_size(DMA1, DMA_CHANNEL6, DMA_CCR_PSIZE_16BIT); dma_set_memory_size(DMA1, DMA_CHANNEL6, DMA_CCR_MSIZE_16BIT); dma_set_priority(DMA1, DMA_CHANNEL6, DMA_CCR_PL_HIGH); dma_enable_transfer_complete_interrupt(DMA1, DMA_CHANNEL5); dma_enable_transfer_complete_interrupt(DMA1, DMA_CHANNEL6); }
static inline void adc_init_single(uint32_t adc, uint8_t nb_channels, uint8_t* channel_map) { // Paranoia, must be down for 2+ ADC clock cycles before calibration adc_off(adc); /* Configure ADC */ /* Explicitly setting most registers, reset/default values are correct for most */ /* Set CR1 register. */ /* Clear AWDEN */ adc_disable_analog_watchdog_regular(adc); /* Clear JAWDEN */ adc_disable_analog_watchdog_injected(adc); /* Clear DISCEN */ adc_disable_discontinuous_mode_regular(adc); /* Clear JDISCEN */ adc_disable_discontinuous_mode_injected(adc); /* Clear JAUTO */ adc_disable_automatic_injected_group_conversion(adc); /* Set SCAN */ adc_enable_scan_mode(adc); /* Enable ADC<X> JEOC interrupt (Set JEOCIE) */ adc_enable_eoc_interrupt_injected(adc); /* Clear AWDIE */ adc_disable_awd_interrupt(adc); /* Clear EOCIE */ adc_disable_eoc_interrupt(adc); /* Set CR2 register. */ /* Clear TSVREFE */ #if defined(STM32F1) adc_disable_temperature_sensor(adc); #elif defined(STM32F4) adc_disable_temperature_sensor(); #endif /* Clear EXTTRIG */ adc_disable_external_trigger_regular(adc); /* Clear ALIGN */ adc_set_right_aligned(adc); /* Clear DMA */ adc_disable_dma(adc); /* Clear CONT */ adc_set_single_conversion_mode(adc); //uint8_t x = 0; //for (x = 0; x < nb_channels; x++) { // adc_set_sample_time(adc, channel_map[x], ADC_SAMPLE_TIME); //} adc_set_sample_time_on_all_channels(adc, ADC_SAMPLE_TIME); adc_set_injected_sequence(adc, nb_channels, channel_map); #if USE_AD_TIM4 PRINT_CONFIG_MSG("Info: Using TIM4 for ADC") #if defined(STM32F1) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM4_TRGO); #elif defined(STM32F4) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM4_TRGO, ADC_CR2_JEXTEN_BOTH_EDGES); #endif #elif USE_AD_TIM1 PRINT_CONFIG_MSG("Info: Using TIM1 for ADC") #if defined(STM32F1) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM1_TRGO); #elif defined(STM32F4) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM1_TRGO, ADC_CR2_JEXTEN_BOTH_EDGES); #endif #else PRINT_CONFIG_MSG("Info: Using default TIM2 for ADC") #if defined(STM32F1) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM2_TRGO); #elif defined(STM32F4) adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM2_TRGO, ADC_CR2_JEXTEN_BOTH_EDGES); #endif #endif /* Enable ADC<X> */ adc_power_on(adc); #if defined(STM32F1) /* Enable ADC<X> reset calibaration register */ adc_reset_calibration(adc); /* Check the end of ADC<X> reset calibration */ while ((ADC_CR2(adc) & ADC_CR2_RSTCAL) != 0); /* Start ADC<X> calibaration */ adc_calibration(adc); /* Check the end of ADC<X> calibration */ while ((ADC_CR2(adc) & ADC_CR2_CAL) != 0); #endif return; } // adc_init_single
/** * Enable selected channels on specified ADC. * Usage: * * adc_init_single(ADC1, 1, 1, 0, 0); * * ... would enable ADC1, enabling channels 1 and 2, * but not 3 and 4. */ static inline void adc_init_single(uint32_t adc, uint8_t chan1, uint8_t chan2, uint8_t chan3, uint8_t chan4) { uint8_t num_channels, rank; uint8_t channels[4]; // Paranoia, must be down for 2+ ADC clock cycles before calibration adc_off(adc); /* enable adc clock */ if (adc == ADC1) { #ifdef USE_AD1 num_channels = NB_ADC1_CHANNELS; ADC1_GPIO_INIT(); #endif } else if (adc == ADC2) { #ifdef USE_AD2 num_channels = NB_ADC2_CHANNELS; ADC2_GPIO_INIT(); #endif } /* Configure ADC */ /* Explicitly setting most registers, reset/default values are correct for most */ /* Set CR1 register. */ /* Clear AWDEN */ adc_disable_analog_watchdog_regular(adc); /* Clear JAWDEN */ adc_disable_analog_watchdog_injected(adc); /* Clear DISCEN */ adc_disable_discontinuous_mode_regular(adc); /* Clear JDISCEN */ adc_disable_discontinuous_mode_injected(adc); /* Clear JAUTO */ adc_disable_automatic_injected_group_conversion(adc); /* Set SCAN */ adc_enable_scan_mode(adc); /* Enable ADC<X> JEOC interrupt (Set JEOCIE) */ adc_enable_eoc_interrupt_injected(adc); /* Clear AWDIE */ adc_disable_awd_interrupt(adc); /* Clear EOCIE */ adc_disable_eoc_interrupt(adc); /* Set CR2 register. */ /* Clear TSVREFE */ adc_disable_temperature_sensor(adc); /* Clear EXTTRIG */ adc_disable_external_trigger_regular(adc); /* Clear ALIGN */ adc_set_right_aligned(adc); /* Clear DMA */ adc_disable_dma(adc); /* Clear CONT */ adc_set_single_conversion_mode(adc); rank = 0; if (chan1) { adc_set_sample_time(adc, adc_channel_map[0], ADC_SMPR1_SMP_41DOT5CYC); channels[rank] = adc_channel_map[0]; rank++; } if (chan2) { adc_set_sample_time(adc, adc_channel_map[1], ADC_SMPR1_SMP_41DOT5CYC); channels[rank] = adc_channel_map[1]; rank++; } if (chan3) { adc_set_sample_time(adc, adc_channel_map[2], ADC_SMPR1_SMP_41DOT5CYC); channels[rank] = adc_channel_map[2]; rank++; } if (chan4) { adc_set_sample_time(adc, adc_channel_map[3], ADC_SMPR1_SMP_41DOT5CYC); channels[rank] = adc_channel_map[3]; } adc_set_injected_sequence(adc, num_channels, channels); #if USE_AD_TIM4 #pragma message "Info: Using TIM4 for ADC" adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM4_TRGO); #elif USE_AD_TIM1 #pragma message "Info: Using TIM1 for ADC" adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM1_TRGO); #else #pragma message "Info: Using default TIM2 for ADC" adc_enable_external_trigger_injected(adc, ADC_CR2_JEXTSEL_TIM2_TRGO); #endif /* Enable ADC<X> */ adc_power_on(adc); /* Enable ADC<X> reset calibaration register */ adc_reset_calibration(adc); /* Check the end of ADC<X> reset calibration */ while ((ADC_CR2(adc) & ADC_CR2_RSTCAL) != 0); /* Start ADC<X> calibaration */ adc_calibration(adc); /* Check the end of ADC<X> calibration */ while ((ADC_CR2(adc) & ADC_CR2_CAL) != 0); } // adc_init_single