static uint16_t read_adc_naiive(uint8_t channel)
{
uint8_t channel_array[16];
channel_array[0] = channel;
adc_set_regular_sequence(ADC1, 1, channel_array);
adc_start_conversion_direct(ADC1);
while (!adc_eoc(ADC1));
uint16_t reg16 = adc_read_regular(ADC1);
return reg16;
}
/**
* NOTE this is a state machine, but it expects to run often enough for millis()
* @param machine
* @param res
*/
void jack_run_task(volatile struct jacks_machine_t *machine, struct jacks_result_t *res)
{
res->ready = false;
if (!jack_connected(machine->jack)) {
return;
}
switch (machine->step) {
case jack_machine_step_off:
// is it time to do a reading yet?
if (millis() - 3000 > machine->last_read_millis) {
printf("switching power on: channel %u\n", (unsigned int) machine->jack->val_channel);
gpio_set(machine->jack->power_port, machine->jack->power_pin);
machine->step = jack_machine_step_powered;
machine->step_entry_millis = millis();
}
break;
case jack_machine_step_powered:
// have we been powered up long enough yet?
if (millis() - machine->jack->power_on_time_millis > machine->step_entry_millis) {
printf("power stable!\n");
machine->step = jack_machine_step_ready;
// not really necessary... machine->step_entry_millis = millis();
} else {
printf(".");
}
break;
case jack_machine_step_ready:
// TODO - this should actually start a dma sequence and go to a next step
// that decimates/averages and finally returns.
// ok! do a few readings and call it good
adc_disable_scan_mode(ADC1);
adc_set_single_conversion_mode(ADC1);
adc_set_sample_time_on_all_channels(ADC1, ADC_SMPR_SMP_28DOT5CYC);
//adc_set_single_channel(ADC1, machine->jack->val_channel);
adc_set_regular_sequence(ADC1, 1, (u8*)&(machine->jack->val_channel));
adc_enable_external_trigger_regular(ADC1, ADC_CR2_EXTSEL_SWSTART);
adc_start_conversion_regular(ADC1);
printf("ok, doing reading on channel!\n");
while(!adc_eoc(ADC1)) {
;
}
res->ready = true;
res->value = adc_read_regular(ADC1);
machine->last_value = res->value;
machine->last_read_millis = millis();
gpio_clear(machine->jack->power_port, machine->jack->power_pin);
machine->step = jack_machine_step_off;
break;
}
return;
}
void adc1_2_isr(void) {
if ( adc_eoc(ADC1) != 0 ) {
sig = adc_read_regular(ADC1);
gpio_port_write(GPIOE, (sig << 8) | 0x0001);
DAC_DHR8R1 = DAC_DHR8R1_DACC1DHR_MSK & sig;
//DAC_DHR12R1 = DAC_DHR12R1_DACC1DHR_MSK & 0x0FFF;
ADC1_CR |= ADC_CR_ADSTART;
}
}
float voltage_measure (uint32_t adc,uint8_t channel)
{
uint8_t channels[16];
float voltage;
channels[0] = channel;
adc_set_regular_sequence(adc, 1, channels);
adc_start_conversion_regular(adc);
gpio_toggle (GPIOD,GPIO15);
while (!adc_eoc(adc));
voltage=adc_read_regular(adc)*(VREF/ADC_CONVERSION_FACTOR);
return voltage;
}
int main(void)
{
uint16_t temp;
clock_setup();
gpio_setup();
adc_setup();
usart_setup();
while (1) {
adc_start_conversion_regular(ADC1);
while (!(adc_eoc(ADC1)));
temp=adc_read_regular(ADC1);
gpio_port_write(GPIOE, temp << 4);
my_usart_print_int(USART2, temp);
}
return 0;
}
int main(void)
{
uint16_t temp;
adc_setup();
usart_setup();
while (1) {
adc_start_conversion_regular(ADC1);
while (!(adc_eoc(ADC1)));
temp = adc_read_regular(ADC1);
my_usart_print_int(USART1, temp);
int i;
for (i = 0; i < 800000; i++) { /* Wait a bit. */
__asm__("nop");
}
}
return 0;
}
void adc_isr(void)
{
static int adc_counter=0;
static float V_stm32_A = 0.0f;
static float V_stm32_B = 0.0f;
static float V_stm32_strain_gauge = 0.0f;
float V_stm32_Ud = 0.0f;
float V_shunt_A = 0.0f;
float V_shunt_B = 0.0f;
float V_strain_gauge =0.0f;
/* ORIGINAL
if (adc_counter==0)
{
V_stm32_A = adc_read_regular(ADC1);
voltage_measure (ADC1,ADC_CHANNEL2);
adc_counter++;
}
else if (adc_counter==1)
{
V_stm32_B = adc_read_regular(ADC1);
voltage_measure (ADC1,ADC_CHANNEL15);
adc_counter++;
}
else if (adc_counter==2)
{
V_stm32_strain_gauge = adc_read_regular(ADC1);
voltage_measure (ADC1,ADC_CHANNEL3);
adc_counter++;
}
*/
V_stm32_A = adc_read_regular(ADC1);//agregada
V_stm32_B = adc_read_regular(ADC2);//agregada
V_stm32_strain_gauge = adc_read_regular(ADC3);//agregada
//Porque si lo hago asi, no tengo que llamar a voltage_measure() despues de cada asignacion de adc_read_regular()??
//else //quitado
//{ //quitado
V_stm32_Ud = adc_read_regular(ADC1)*(VREF/ADC_CONVERSION_FACTOR);
U_d = V_stm32_Ud*BATTERY_VOLTAGE_CONVERTION_FACTOR;
V_shunt_A = (V_stm32_A*(VREF/ADC_CONVERSION_FACTOR)-V_DIFFERENTIAL_AMPLIFIER_REFFERENCE_A)/G_OP_AMP_A;
i_sA = V_shunt_A/R_SHUNT_A;
V_shunt_B = (V_stm32_B*(VREF/ADC_CONVERSION_FACTOR)-V_DIFFERENTIAL_AMPLIFIER_REFFERENCE_B)/G_OP_AMP_B;
i_sB = V_shunt_B/R_SHUNT_B;
//V_strain_gauge=V_stm32_strain_gauge*(VREF/ADC_CONVERSION_FACTOR);
//strain_gauge = V_strain_gauge-strain_gauge_reference;
V_strain_gauge=V_stm32_strain_gauge*(VREF/ADC_CONVERSION_FACTOR)-strain_gauge_reference;
V_strain_gauge=te_moving_average_filter(V_strain_gauge);
strain_gauge = V_strain_gauge*STRAIN_GAUGE_CONVERSION_FACTOR;
//strain_gauge =te_moving_average_filter(strain_gauge);
if (reset_strain_gauge_reference==true)
{
/*
strain_gauge_reference=strain_gauge_reference+strain_gauge;
strain_gauge=0.0f;
reset_strain_gauge_reference=false;
*/
strain_gauge_reference=strain_gauge_reference+V_strain_gauge;
V_strain_gauge=0.0f;
reset_strain_gauge_reference=false;
}
//filtering currents
//i_sA = isA_moving_average_filter(i_sA);
//i_sB = isB_moving_average_filter(i_sB);
adc_counter=0;
DTC_SVM();
//collecting_data();
//oscilloscope flag: start of halves
gpio_clear(GPIOB, GPIO15);
gpio_clear(GPIOD, GPIO14); //agregada
//oscilloscope flag: end of interrupt
gpio_clear(GPIOD, GPIO9);
//gpio_clear(GPIOD, GPIO11);
}
uint16_t battery_sense_read() {
adc_start_conversion_regular(BAT_SENSE_ADC);
while (!adc_eoc(BAT_SENSE_ADC));
return adc_read_regular(BAT_SENSE_ADC);
}
