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
