/*---------------------------------------------------------------------------*/
int ubasic_get_adc(int ch)
{
int var = 0xff;
switch(ch){
case 1:
if (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET) {
var = 0xff;
} else {
var = ADC_GetConversionValue(ADC1) & 0x00ff;
ADC_SoftwareStartConv(ADC1);
}
break;
case 2:
if (ADC_GetFlagStatus(ADC2, ADC_FLAG_EOC) == RESET) {
var = 0xff;
} else {
var = ADC_GetConversionValue(ADC2) & 0x00ff;
ADC_SoftwareStartConv(ADC2);
}
break;
case 3:
if (ADC_GetFlagStatus(ADC3, ADC_FLAG_EOC) == RESET) {
var = 0xff;
} else {
var = ADC_GetConversionValue(ADC3) & 0x00ff;
ADC_SoftwareStartConv(ADC3);
}
break;
default:
var = 0xff;
break;
}
return var;
}
/**
* @brief Calculate the actual Voltage
* @note
* @retval The value of the VoltageCal data.
//STM32F042Cx 为12 bit 精度ADC
*/
float VoltageCal(void)
{
//uint32_t Voltage;
#define Vref_CAL_ADDR ((uint16_t*) ((uint32_t) 0x1FFFF7ba))
float Voltage;
float Voltage2;
float Voltage3;
//启动转换
ADC_StartOfConversion(ADC1);
//wait for conversion complete
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC)){;}
//read ADC value
Voltage = (float)ADC_GetConversionValue(ADC1);
#if 1
//wait for conversion complete
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC)){;}
//read ADC value
Voltage2 = (float)ADC_GetConversionValue(ADC1);
Voltage3 = ((*Vref_CAL_ADDR )* 3.3) /Voltage2;
Voltage = ( Voltage * Voltage3) /0xFFF;
#else
Voltage = ( Voltage * 3.3) /0xFFF;
#endif
return Voltage;
}
/**
* @brief Initializes the temperature sensor and its related ADC.
* @param None
* @retval the float value of temperature measured in Celsius.
*/
float temperature_MeasureValue(void)
{
/* Raw value of temperature sensor voltage converted from ADC1_IN16 */
uint16_t v_refint;
/* Raw value of VREFINT converted from ADC1_INT17 */
uint16_t v_sensor;
/* select ADC1_IN16 to sample sensor voltage value*/
ADC_RegularChannelConfig(ADC1, ADC_Channel_16, 1, ADC_SampleTime_28Cycles);
/* start one ADC conversion */
ADC_SoftwareStartConv(ADC1);
/* wait unitl ECO bit is set, sample finished */
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
/* Read the value from ADC_DR*/
v_sensor = ADC_GetConversionValue(ADC1);
/* select ADC1_IN16 to sample reference voltage value*/
ADC_RegularChannelConfig(ADC1, ADC_Channel_17, 1, ADC_SampleTime_28Cycles);
/* start one ADC conversion */
ADC_SoftwareStartConv(ADC1);
/* wait unitl ECO bit is set, sample finished */
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
/* Read the value from ADC_DR*/
v_refint = ADC_GetConversionValue(ADC1);
/*
* measured_sensor_voltage = actual_reference_voltage * sampled_sensor_voltage / sampled_reference_voltage_value
* temperature = (measured_sensor_voltage - sensor_voltage_at_25) / AVG_SLOPE + 25
*/
return (VREFINT_VOLTAGE_V / v_refint * v_sensor - TEMPERATURE_V25) * 1000 / AVG_SLOPE + 25;
}
void CIO::interrupt()
{
uint8_t control = MARK_NONE;
uint16_t sample = DC_OFFSET;
uint16_t rawRSSI = 0U;
m_txBuffer.get(sample, control);
// Send the value to the DAC
DAC_SetChannel1Data(DAC_Align_12b_R, sample);
// Read value from ADC1 and ADC2
if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)) {
// shouldn't be still in reset at this point so null the sample value?
sample = 0U;
} else {
sample = ADC_GetConversionValue(ADC1);
#if defined(SEND_RSSI_DATA)
rawRSSI = ADC_GetConversionValue(ADC2);
#endif
}
// trigger next ADC1
ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
ADC_SoftwareStartConv(ADC1);
m_rxBuffer.put(sample, control);
m_rssiBuffer.put(rawRSSI);
m_watchdog++;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Configure System clocks -----------------------------------------------*/
RCC_Configuration();
/* Configure GPIO ports --------------------------------------------------*/
GPIO_Configuration();
USART_Configuration();
/* Output a message on Hyperterminal using printf function */
printf("\n\rADC different test: \n\r");
ADC_Configuration();
while(ADC_GetBitState(ADC_FLAG_EOC) != SET);
ADCConvertedValue = ADC_GetConversionValue();
printf("\n\rThe original data %d\n\r",ADCConvertedValue);
ADC_DeInit(&ADC_InitStructure);
ADC_OVERConfiguration();
while(ADC_GetBitState(ADC_FLAG_EOC) != SET);
ADCConvertedValue_OVER = ADC_GetConversionValue();
printf("\n\rOversampling data %d\n\r",ADCConvertedValue_OVER);
while (1)
{
}
}
void DMA2_Stream0_IRQHandler (void) {
__IO uint16_t SENSOR_A_VoltValue = ADC_GetConversionValue(ADC1) * 3000/0xfff;
__IO uint16_t SENSOR_B_VoltValue = ADC_GetConversionValue(ADC2) * 3000/0xfff;
if(SENSOR_A_VoltValue > SENSOR_B_VoltValue) {
sensor_header = 1;
} else {
sensor_header = -1;
}
DMA_ClearITPendingBit(DMA2_Stream0, DMA_IT_TCIF0);
}
uint16_t adc_read(uint8_t channel){
uint16_t vref;
ADC_RegularChannelConfig(ADC1, ADC_Channel_Vrefint, 0, ADC_SampleTime_384Cycles);
ADC_SoftwareStartConv(ADC1);
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
vref=ADC_GetConversionValue(ADC1);
ADC_RegularChannelConfig(ADC1, channel, 0, ADC_SampleTime_384Cycles);
ADC_SoftwareStartConv(ADC1);
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
return ADC_GetConversionValue(ADC1)*6840/vref; // magic number to get millivolts
}
void ADC_IRQHandler(void) {
//ADC_ClearFlag(ADC1,ADC_FLAG_EOC);
__IO uint16_t SENSOR_A_VoltValue = ADC_GetConversionValue(ADC1) * 3000/0xfff;
__IO uint16_t SENSOR_B_VoltValue = ADC_GetConversionValue(ADC2) * 3000/0xfff;
if(SENSOR_A_VoltValue > SENSOR_B_VoltValue) {
sensor_header = 1;
} else {
sensor_header = -1;
}
}
int Get_ADC_Voltage(ADC_TypeDef* ADCx)
{
AD_value=ADC_GetConversionValue(ADCx); //读取ADC转换出的值
Precent = (AD_value*100/4096); //算出百分比
Voltage = Precent*33; //3.3V的电平，计算等效电平
return(Voltage);
}
/**
* @brief To get adc value of A0 ~ A3 from a WIZnet module.
* @param index The sequence for A0 ~ A3 registration
* @return adc value (uint16_t)
*/
uint16_t get_ADC_val(uint8_t index)
{
uint16 adc_value = 0;
#if 0
// for Test
switch(index)
{
case A0: // WIZ550web BaseBoard: Potentiometer
if(ADC_GetFlagStatus(ADC2, ADC_FLAG_EOC) == SET) adc_value = ADC_GetConversionValue(ADC2);
break;
case A1: // WIZ550web BaseBoard: Temperature Sensor
adc_value = ADC1ConvertedValue; // TemperatureC = (((ADC_value * 3300) / 1023) - 500) / 10;
break;
case A2:
adc_value = 1000;
break;
case A3:
adc_value = 2000;
break;
default:
adc_value = 0;
break;
}
#else
adc_value = ADC_DualConvertedValueTab[index];
#endif
return adc_value;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* ADC Configuration */
ADC_Config();
/* LCD Display init */
Display_Init();
/* Infinite loop */
while (1)
{
/* Test EOC flag */
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
/* Get ADC1 converted data */
ADC1ConvertedValue =ADC_GetConversionValue(ADC1);
/* Compute the voltage */
ADC1ConvertedVoltage = (ADC1ConvertedValue *3300)/0xFFF;
/* Display converted data on the LCD */
Display();
}
}
float readTemp(){
float temperature;
ADC_SoftwareStartConv(ADC1); // Start the conversion
while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); // Wait for conversion to finish
temperature = (float) ADC_GetConversionValue(ADC1); // Get ADC reading
// Print ADC reading
setbuf(stdout, NULL);
printf("%f, " , temperature);
// TODO: Convert ADC (digital) reading back to voltage value
// Use the formula on page 20 of the lecture slides
// Here, v_min = 0, v_max = 3.3, and n depends on the resolution
// of the ADC (refer to the adc intialization in initTempSensor() function)
// Assign the voltage value back to the temperature variable
convADC(&temperature,12);
setbuf(stdout, NULL);
printf("%f, " , temperature);
// TODO: Convert the digital value to a temperature and assign back
// to the temperature value.
// The formula for this conversion is given in the Technical Reference Manual
// (v_sense is the voltage value we calculated in the previous step
// and assigned back to temp)
// Temperature (in °C) = {(V_SENSE - V_25) / Avg_Slope} + 25
convVolt(&temperature);
setbuf(stdout, NULL);
printf("%f\n" , temperature);
return temperature;
}
char sampleADC(void)
{
char res = 0x0;
CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, ENABLE);
ADC_DeInit(ADC1);
ADC_VrefintCmd(ENABLE);
delay_10us(3);
ADC_Cmd(ADC1, ENABLE);
ADC_Init(ADC1, ADC_ConversionMode_Single,
ADC_Resolution_6Bit, ADC_Prescaler_1);
ADC_SamplingTimeConfig(ADC1, ADC_Group_SlowChannels, ADC_SamplingTime_9Cycles);
ADC_ChannelCmd(ADC1, ADC_Channel_0, ENABLE);
delay_10us(3);
ADC_SoftwareStartConv(ADC1);
while( ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == 0);
res = (char)ADC_GetConversionValue(ADC1);
ADC_VrefintCmd(DISABLE);
ADC_DeInit(ADC1);
/* disable SchmittTrigger for ADC_Channel_24, to save power */
//ADC_SchmittTriggerConfig(ADC1, ADC_Channel_24, DISABLE);
CLK_PeripheralClockConfig(CLK_Peripheral_ADC1, DISABLE);
ADC_ChannelCmd(ADC1, ADC_Channel_0, DISABLE);
return res;
}
uint16_t adc_lightsensor(void) {
digitalWrite(ADC_LIGHTSENSOR_ENABLE, HIGH);
ADC_SoftwareStartConv(ADC2);
while(ADC_GetSoftwareStartConvStatus(ADC2));
return ADC_GetConversionValue(ADC2);
digitalWrite(ADC_LIGHTSENSOR_ENABLE, LOW);
}
void adc_convert(void){
uint16_t ADC1ConvertedValue;
/* Test EOC flag */
while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)
;
/* Get ADC1 converted data */
ADC1ConvertedValue = ADC_GetConversionValue(ADC1);
//update_rawADC(USART2, ADC1ConvertedValue); //ADC value 0-4096
//update_degF(USART2, ADC1ConvertedValue/1.64); //degF 0-2500F
//update_degC(USART2, ADC1ConvertedValue/3); //degC 0-1370C
//USART_PUT_TEMPF(USART2, ADC1ConvertedValue/1.64);
//USART_PUT_TEMPC(USART2, ADC1ConvertedValue/3);
if (ADC1ConvertedValue > 4000)
{
GPIOC->BSRR = GPIO_Pin_8;
GPIOC->BSRR = GPIO_Pin_9;
}
else if (ADC1ConvertedValue > 2000)
{
GPIOC->BSRR = GPIO_Pin_8;
GPIOC->BRR = GPIO_Pin_9;
}
else
{
GPIOC->BRR = GPIO_Pin_8;
GPIOC->BRR = GPIO_Pin_9;
}
}
static inline uint16_t adc_read(analogin_t *obj) {
// Get ADC registers structure address
ADC_TypeDef *adc = (ADC_TypeDef *)(obj->adc);
// Configure ADC channel
switch (obj->pin) {
case PA_0:
ADC_RegularChannelConfig(adc, ADC_Channel_0, 1, ADC_SampleTime_7Cycles5);
break;
case PA_1:
ADC_RegularChannelConfig(adc, ADC_Channel_1, 1, ADC_SampleTime_7Cycles5);
break;
case PA_4:
ADC_RegularChannelConfig(adc, ADC_Channel_4, 1, ADC_SampleTime_7Cycles5);
break;
case PB_0:
ADC_RegularChannelConfig(adc, ADC_Channel_8, 1, ADC_SampleTime_7Cycles5);
break;
case PC_1:
ADC_RegularChannelConfig(adc, ADC_Channel_11, 1, ADC_SampleTime_7Cycles5);
break;
case PC_0:
ADC_RegularChannelConfig(adc, ADC_Channel_10, 1, ADC_SampleTime_7Cycles5);
break;
default:
return 0;
}
ADC_SoftwareStartConvCmd(adc, ENABLE); // Start conversion
while(ADC_GetFlagStatus(adc, ADC_FLAG_EOC) == RESET); // Wait end of conversion
return(ADC_GetConversionValue(adc)); // Get conversion value
}
unsigned short ReadADC1 (unsigned int channel)
{
uint32_t tmpreg = 0;
//GPIOA_PIN4_ON;
// Set channel and sample time
//ADC_ChannelConfig(ADC1, channel, ADC_SampleTime_7_5Cycles); //pifia la medicion 2800 o 3400 en ves de 4095
//ADC_ChannelConfig(ADC1, channel, ADC_SampleTime_239_5Cycles);
//ADC_ChannelConfig(ADC1, ADC_Channel_0, ADC_SampleTime_239_5Cycles);
//ADC_ChannelConfig INTERNALS
/* Configure the ADC Channel */
ADC1->CHSELR = channel;
/* Clear the Sampling time Selection bits */
tmpreg &= ~ADC_SMPR1_SMPR;
/* Set the ADC Sampling Time register */
tmpreg |= (uint32_t)ADC_SampleTime_239_5Cycles;
/* Configure the ADC Sample time register */
ADC1->SMPR = tmpreg ;
// Start the conversion
ADC_StartOfConversion(ADC1);
// Wait until conversion completion
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
// Get the conversion value
//GPIOA_PIN4_OFF; //tarda 20us en convertir
return ADC_GetConversionValue(ADC1);
}
void InternalTempSensor::measureTemp(bool calibrate)
{
// ADC Conversion to read temperature sensor
// Temperature (in °C) = ((Vsense – V25) / Avg_Slope) + 25
// Vense = Voltage Reading From Temperature Sensor
// V25 = Voltage at 25°C, for STM32F407 = 0.76V
// Avg_Slope = 2.5mV/°C
// This data can be found in the STM32F407VF Data Sheet
taskENTER_CRITICAL();
ADC_SoftwareStartConv(ADC1); //Start the conversion
while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET) {} ; //Processing the conversion
temp = ADC_GetConversionValue(ADC1); //Return the converted data
temp *= 3300;
temp /= 0xfff; //Reading in mV
temp /= 1000.0; //Reading in Volts
temp -= 0.760; // Subtract the reference voltage at 25°C
temp /= .0025; // Divide by slope 2.5mV
temp += 25.0; // Add the 25°C
if (calibrate)
{
temp -= calibration;
}
taskEXIT_CRITICAL();
}
void ADC_Handler(char *pcInsert)
{
/* We have only one SSI handler iIndex = 0 */
char Digit1=0, Digit2=0, Digit3=0, Digit4=0;
uint32_t ADCVal = 0;
if (ADC_not_configured ==1) {
ADC_Configuration();
ADC_not_configured=0;
}
/* get ADC conversion value */
ADCVal = ADC_GetConversionValue(ADC1);
/* convert to Voltage, step = 0.8 mV */
ADCVal = (uint32_t)(ADCVal * 0.8);
/* get digits to display */
Digit1= ADCVal/1000;
Digit2= (ADCVal-(Digit1*1000))/100 ;
Digit3= (ADCVal-((Digit1*1000)+(Digit2*100)))/10;
Digit4= ADCVal -((Digit1*1000)+(Digit2*100)+ (Digit3*10));
/* prepare data to be inserted in html */
*pcInsert = (char)(Digit1+0x30);
*(pcInsert + 1) = (char)(Digit2+0x30);
*(pcInsert + 2) = (char)(Digit3+0x30);
*(pcInsert + 3) = (char)(Digit4+0x30);
*(pcInsert + 4) = 0;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* LCD Display init */
Display_Init();
/* Initialize LED4 */
STM_EVAL_LEDInit(LED4);
/* Configure ADC channel 11 */
ADC_Config();
/* Infinite loop */
while (1)
{
/* Get ADC1 converted data */
ADC1ConvertedValue =ADC_GetConversionValue(ADC1);
/* Compute the voltage */
ADC1ConvertedVoltage = (ADC1ConvertedValue *3300)/0xFFF;
/* Display converted data on the LCD */
Display();
}
}
uint32_t adc_read_channel(int channel)
{
int timeout = 10000;
if (channel > (ADC_NUM_CHANNELS-1)) {
return 0;
}
/* ADC regular channel config ADC/Channel/SEQ Rank/Sample time */
ADC_RegularChannelConfig(ADCx, channel, 1, ADC_SampleTime_15Cycles);
/* Start ADC single conversion */
ADC_SoftwareStartConv(ADCx);
/* Wait for conversion to be complete*/
while(!ADC_GetFlagStatus(ADCx, ADC_FLAG_EOC) && --timeout >0) {
}
/* ADC conversion timed out */
if (timeout == 0) {
return 0;
}
/* Return converted data */
return ADC_GetConversionValue(ADCx);
}
/**
@brief End Of Conversion handler. All physical staff was left in IRQ handler
*/
void Analog::end_of_conversion()
{
if (ch == channel_list.end())
ch = channel_list.begin();
(*ch)->write(ADC_GetConversionValue(_base));
++ch;
}
float ad_readval() {
ADC_SoftwareStartConv(ADC1);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
int ival = ADC_GetConversionValue(ADC1);
float fval = (float) (ival - 2048) / 2048.0;
return fval;
}
void ADC1_2_IRQHandler(void)
{
ADCReData=ADC_GetConversionValue(ADC2);
ADCInt=340*ADCReData/4096;
delay_nus(10000);
if(ADCInt>100)
{
Display_LedNum(ADCInt);
GPIO_SetBits(GPIOC, HEX_D7);
}
else
{
if(ADCInt<10)
{
Hex_test(7,0);
}
Display_LedNum(ADCInt);
Hex_test(6,0);
GPIO_SetBits(GPIOC, HEX_D7);
}
ADC_ClearITPendingBit(ADC2,ADC_IT_EOC);
}
uint16_t AdcMcuRead( Adc_t *obj, uint8_t channel )
{
uint16_t adcData = 0;
/* Enable The HSI (16Mhz) */
RCC_HSICmd( ENABLE );
/* Check that HSI oscillator is ready */
while( RCC_GetFlagStatus( RCC_FLAG_HSIRDY ) == RESET );
RCC_APB2PeriphClockCmd( RCC_APB2Periph_ADC1, ENABLE );
// Temperature or Vref measurement
if( ( channel == ADC_Channel_16 ) || ( channel == ADC_Channel_17 ) )
{
// Yes, enable temperature sensor and internal reference voltage
ADC_TempSensorVrefintCmd( ENABLE );
}
// Configure selected channel
ADC_RegularChannelConfig( ADC1, channel, 1, ADC_SampleTime_192Cycles );
/* Define delay between ADC1 conversions */
ADC_DelaySelectionConfig( ADC1, ADC_DelayLength_Freeze );
/* Enable ADC1 Power Down during Delay */
ADC_PowerDownCmd( ADC1, ADC_PowerDown_Idle_Delay, ENABLE );
/* Enable ADC1 */
ADC_Cmd( ADC1, ENABLE );
/* Wait until ADC1 ON status */
while( ADC_GetFlagStatus( ADC1, ADC_FLAG_ADONS ) == RESET )
{
}
/* Start ADC1 Software Conversion */
ADC_SoftwareStartConv( ADC1 );
/* Wait until ADC Channel 5 or 1 end of conversion */
while( ADC_GetFlagStatus( ADC1, ADC_FLAG_EOC ) == RESET )
{
}
adcData = ADC_GetConversionValue( ADC1 );
ADC_Cmd( ADC1, DISABLE );
if( ( channel == ADC_Channel_16 ) || ( channel == ADC_Channel_17 ) )
{
// De-initialize ADC
ADC_TempSensorVrefintCmd( DISABLE );
}
RCC_APB2PeriphClockCmd( RCC_APB2Periph_ADC1, DISABLE );
RCC_HSICmd( DISABLE );
return adcData;
}
uint16_t adc_battery(void) {
digitalWrite(ADC_BATTERY_ENABLE, HIGH);
ADC_SoftwareStartConv(ADC1);
while(ADC_GetSoftwareStartConvStatus(ADC1));
return ADC_GetConversionValue(ADC1);
digitalWrite(ADC_BATTERY_ENABLE, LOW);
}
int get_raw(void) {
int raw;
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
raw = ADC_GetConversionValue(ADC1);
return raw;
}
uint16_t read_adc(uint8_t channel)
{
uint16_t value=0;
ADC_RegularChannelConfig(ADC3, channel, 1, ADC_SampleTime_7Cycles5);
ADC_SoftwareStartConvCmd(ADC3, ENABLE);
while(ADC_GetFlagStatus(ADC3,ADC_FLAG_EOC)==RESET);
value=ADC_GetConversionValue(ADC3);//*3300/0xfff;
switch(channel)
{
case 4:
DEBUG("BATS_AB_MON_I val %d\r\n",value);
break;
case 6:
DEBUG("BATS_A_V_MON val %d\r\n",value);
break;
case 7:
DEBUG("BATS_B_V_MON val %d\r\n",value);
break;
default:
break;
}
return value;
}
uint16_t TM_ADC_Read(ADC_TypeDef* ADCx, uint8_t channel) {
ADC_RegularChannelConfig(ADCx, channel, 1, ADC_SampleTime_15Cycles);
ADC_SoftwareStartConv(ADCx);
while (ADC_GetFlagStatus(ADCx, ADC_FLAG_EOC) == RESET);
return ADC_GetConversionValue(ADCx);
}
/*
* NOTE: No protection, should only be called from ISR
*/
static uint16_t read_channel(oscilloscope_input_t ch)
{
uint8_t real_ch;
switch(ch)
{
case input_channel0:
real_ch = ADC_Channel_7;
break;
case input_channel1:
real_ch = ADC_Channel_8;
break;
default:
ipc_watchdog_signal_error(0);
return UINT16_MAX;
}
ADC_RegularChannelConfig(ADC1, real_ch, 1, ADC_SampleTime_239Cycles5);
ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
/* spin until we have data */
while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));
return ADC_GetConversionValue(ADC1);
}