void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) { /*ADC1 regular group conversion is finished*/ /*count the amount of samples collected*/ sampleCounter[0]--; for (int i = 0;i < 3;i++) { /*collect all ADC samples*/ adcAccumulator[i] += adcConvertedValues[i]; } if(sampleCounter[0] == 0) { /*if required number of samples is collected calculate average data and turn off ADC and DMA*/ HAL_ADC_Stop_DMA(&hadc1); xPosSignal = adcAccumulator[0]/ADC1_SAMPL_NUMBER; yPosSignal = adcAccumulator[1]/ADC1_SAMPL_NUMBER; zPosSignal = adcAccumulator[2]/ADC1_SAMPL_NUMBER; } else { /*perform next conversion cycle otherwise*/ HAL_ADC_Start_IT(&hadc1); } }
void adcSetResolution (uint8_t res){ samplingDisable(); HAL_ADC_Stop_DMA(&hadc1); HAL_ADC_Stop_DMA(&hadc2); HAL_ADC_Stop_DMA(&hadc3); if(res==8){ ADCResolution = ADC_RESOLUTION8b; }else if(res==12){ ADCResolution = ADC_RESOLUTION12b; }else{ return; } HAL_ADC_DeInit(&hadc1); HAL_ADC_DeInit(&hadc2); HAL_ADC_DeInit(&hadc3); HAL_DMA_DeInit(&hdma_adc1); HAL_DMA_DeInit(&hdma_adc2); HAL_DMA_DeInit(&hdma_adc3); MX_ADC1_Init(); MX_ADC2_Init(); MX_ADC3_Init(); }
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* AdcHandle) { HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9); HAL_ADC_Stop_DMA(&g_AdcHandle); osSignalSet(tid_TH_GUI,DMA_ConvCpltSig); HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_9); //GPIOB->ODR ^= GPIO_PIN_9; // this is just for test of DMA speed }
/** * @brief Update power module instance adc measurements. * @param power_module: pointer to power module instance for which to get adc measurements. * @retval None. */ void EPS_update_power_module_state(EPS_PowerModule *power_module){ /*initialize adc handle*/ power_module->hadc_power_module->Init.NbrOfConversion = 2; //power_module->hadc_power_module->NbrOfConversionRank = 2; HAL_ADC_Init(power_module->hadc_power_module); /*setup conversion sequence for */ ADC_ChannelConfTypeDef sConfig; sConfig.SamplingTime = ADC_SAMPLETIME_192CYCLES; /*power module current*/ sConfig.Channel = power_module->ADC_channel_current ; sConfig.Rank = 1; HAL_ADC_ConfigChannel(power_module->hadc_power_module, &sConfig); /*power module voltage*/ sConfig.Channel = power_module->ADC_channel_voltage ; sConfig.Rank = 2; HAL_ADC_ConfigChannel(power_module->hadc_power_module, &sConfig); /*start dma transfer from adc to memory.*/ uint32_t adc_measurement_dma_power_modules[67]= { 0 };//2*64 +1 adc_reading_complete = ADC_TRANSFER_NOT_COMPLETED;//external global flag defined in main and shared with the adc complete transfer interrupt handler. HAL_ADC_Start_DMA(power_module->hadc_power_module, adc_measurement_dma_power_modules, 66); /*Process Measurements*/ uint32_t voltage_avg =0; uint32_t current_avg =0; /*Wait till DMA ADC sequence transfer is ready*/ while(adc_reading_complete==ADC_TRANSFER_NOT_COMPLETED){ //wait for dma transfer complete. } /*ADC must be stopped in the adc dma transfer complete callback.*/ HAL_ADC_Stop_DMA(power_module->hadc_power_module); /*de-interleave and sum voltage and current measurements.*/ for (int sum_index = 2; sum_index < 66; sum_index+=2) { /*top*/ current_avg = current_avg + adc_measurement_dma_power_modules[sum_index]; voltage_avg = voltage_avg + adc_measurement_dma_power_modules[sum_index+1]; } /*filter ting*/ /*average of 16 concecutive adc measurements.skip the first to avoid adc power up distortion.*/ power_module->voltage = voltage_avg>>5; power_module->current = current_avg>>5; }
void HAL_ADC_Enable(int enable) { #ifdef ENABLE_ADC if ( (adc_enabled == 0) && (enable != 0) ) { memset(&adc_samples,0, sizeof(adc_samples)); HAL_StatusTypeDef status = HAL_ADC_Start_DMA(&hadc1, (uint32_t *)&adc_samples, sizeof(adc_samples)); adc_enabled = ( status == HAL_OK ) ? 1 : 0; } else { if (adc_enabled != 0) { HAL_ADC_Stop_DMA(&hadc1); } } #endif }
static int stm32f4_adc_release_buffer(struct adc_dev *dev, void *buf, int buf_len) { ADC_HandleTypeDef *hadc; struct stm32f4_adc_dev_cfg *cfg; assert(dev); cfg = (struct stm32f4_adc_dev_cfg *)dev->ad_dev.od_init_arg; hadc = cfg->sac_adc_handle; HAL_ADC_Stop_DMA(hadc); return (0); }
/* USER CODE BEGIN 1 */ void ADC_DMA_Reconfig(uint8_t chan, uint32_t *buff, uint32_t len){ ADC_HandleTypeDef adcHandler; switch(chan){ case 0: adcHandler=hadc1; break; case 1: adcHandler=hadc2; break; case 2: adcHandler=hadc3; break; } HAL_ADC_Stop_DMA(&adcHandler); HAL_ADC_Start_DMA(&adcHandler, buff, len); }
/** * @brief HAL_ADC_ConvCpltCallback * Get U/I output values * @param ADC Handle * @retval None */ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) { /* Stop DMA */ HAL_ADC_Stop_DMA(&hadc1); /**/ Calc_ADC_UI(ADC_SAMPLES_CNT/4, ADC_SAMPLES_CNT/2); /* Convert U/I values */ float U = ( (float)adc_sum.v * 32.2F * 13.48F ) / 4095.0F; // Convert, value = [ (adcdata * vdda * k) / 2^12 ], were k = 12k/1k + 1 = 13 float I = ( ((float)adc_sum.i * 322.0F * (1.0F/0.047F) ) / (4095.0F * 9.2F) ); // Convert, value to mA hw_channel_self.data.v = (uint16_t)( U / (float)(ADC_SAMPLES_CNT/2) ); hw_channel_self.data.i = (uint16_t)( I / (float)(ADC_SAMPLES_CNT/2) ) - 1; /* Complite data collection for channel callback */ HW_Channel_GetDataCallback(&hw_channel_self); }
result_t stop(Port p) { if(false == initialised(p)) { return resNOK; } if(true == s_adc_isrunning) { HAL_ADC_Stop_DMA(&hadc1); s_adc_isrunning = false; } s_adc_isrunning = false; return resOK; }
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) { //SCOPE_1_TOGGLE(); adcDma_fullcnt = uni_adcDMA_bytesCaptured(hadc1.Init.NbrOfConversion); #ifdef CIRCULAR_DMA //is.dma2_complete_flag = true; power_from_ADC(adc_dma_buf_2); // ****** use is.adc_samples_per_cycle here? // continues automatically #else HAL_ADC_Stop_DMA(&hadc1); // call uni_adc_start(); to restart #endif }
void test_Vbat(void) { ADC_ChannelConfTypeDef sConfig; int vbat; int vref = 3300; //mV int coeff = 33; //% ExpanderSetbit(7,0); HAL_Delay(100); ExpanderSetbit(7,1); HAL_Delay(100); ssd1306Init(0); ssd1306ClearScreen(); ssd1306Refresh(); while(1) { HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, SET); ssd1306ClearScreen(); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_15; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_56CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_8, 1); vbat = (((vref * uhADCxConvertedValue_8) / 40950) * coeff); ssd1306PrintInt(10, 5, "Vbat = ", vbat, &Font_5x8); ssd1306Refresh(); HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, RESET); HAL_Delay(100); } }
/** * @brief Stop audio recording * @retval None */ uint8_t BSP_AUDIO_IN_Stop(void) { uint32_t ret = AUDIO_OK; /* Stop the time base triggering the ADC */ if (HAL_TIM_Base_Stop(&hAudioInTim3) != HAL_OK) { ret = AUDIO_ERROR; } if (HAL_ADC_Stop_DMA(&hAudioInAdc) != HAL_OK) { /* Return 0 if all operations are OK */ ret = AUDIO_ERROR; } /* Disable OPAMPx */ if (HAL_OPAMP_Stop(&hAudioInOpamp) != HAL_OK) { ret = AUDIO_ERROR; } return ret; }
static EPS_soft_error_status EPS_update_state_adc_measurements(volatile EPS_State *state, ADC_HandleTypeDef *hadc_eps){ EPS_soft_error_status adc_update_state = EPS_SOFT_ERROR_UPDATE_STATE_ADC; /*initialize adc handle*/ hadc_eps->Init.NbrOfConversion = 6; HAL_ADC_Init(hadc_eps); /*setup conversion sequence for */ ADC_ChannelConfTypeDef sConfig; sConfig.SamplingTime = ADC_SAMPLETIME_384CYCLES; /*Vbat*/ sConfig.Channel = ADC_VBAT; sConfig.Rank = 1; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); /*Ibat+*/ sConfig.Channel = ADC_IBAT_PLUS; sConfig.Rank = 2; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); /*Ibat-*/ sConfig.Channel = ADC_IBAT_MINUS; sConfig.Rank = 3; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); /*I3v3*/ sConfig.Channel = ADC_I3V3; sConfig.Rank = 4; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); /*I5v*/ sConfig.Channel = ADC_I5V; sConfig.Rank = 5; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); /*cpu internal temp sensor*/ sConfig.Channel = ADC_CHANNEL_TEMPSENSOR; sConfig.Rank = 6; HAL_ADC_ConfigChannel(hadc_eps, &sConfig); adc_update_state = EPS_SOFT_ERROR_UPDATE_STATE_ADC_DMA; /*Start conversion and dma transfer*/ uint32_t adc_measurement_dma_eps_state[55]= { 0 };//2*6 +1 adc_reading_complete = ADC_TRANSFER_NOT_COMPLETED; HAL_ADC_Start_DMA(hadc_eps, adc_measurement_dma_eps_state, 54); /*Process Measurements*/ uint32_t battery_voltage_avg =0; uint32_t battery_current_plus_avg =0; uint32_t battery_current_minus_avg =0; uint32_t v3_3_current_avg =0; uint32_t v5_current_avg =0; uint32_t cpu_temp_avg =0; /*Wait till DMA ADC sequence transfer is ready*/ while(adc_reading_complete==ADC_TRANSFER_NOT_COMPLETED){ } HAL_ADC_Stop_DMA(hadc_eps); adc_update_state = EPS_SOFT_ERROR_UPDATE_STATE_ADC_FILTER; //de-interleave and sum adc state measurements.overflow strategy??? : 2^12(max adc value) * 32 = 2^17 < 2^32 so you do not need one! for (int sum_index = 6; sum_index < 54; sum_index+=6) { /*top*/ battery_voltage_avg = battery_voltage_avg + adc_measurement_dma_eps_state[sum_index]; battery_current_plus_avg = battery_current_plus_avg + adc_measurement_dma_eps_state[sum_index+1]; battery_current_minus_avg = battery_current_minus_avg + adc_measurement_dma_eps_state[sum_index+2]; v3_3_current_avg = v3_3_current_avg + adc_measurement_dma_eps_state[sum_index+3]; v5_current_avg = v5_current_avg + adc_measurement_dma_eps_state[sum_index+4]; cpu_temp_avg = cpu_temp_avg + adc_measurement_dma_eps_state[sum_index+5]; } /*filter ting*/ //average of 8 concecutive adc measurements.skip the first to avoid adc power up distortion. state->battery_voltage = battery_voltage_avg>>3; state->battery_current_plus = battery_current_plus_avg>>3; state->battery_current_minus = battery_current_minus_avg>>3; state->v3_3_current_avg = v3_3_current_avg>>3; state->v5_current_avg = v5_current_avg>>3; adc_update_state = EPS_SOFT_ERROR_UPDATE_STATE_ADC_CPU_TEMP; state->cpu_temperature = COMPUTATION_TEMPERATURE_TEMP30_TEMP110((cpu_temp_avg>>3)); adc_update_state = EPS_SOFT_ERROR_OK; return adc_update_state; }
/** \brief 停止进行温度AD转换 * * \return void */ static void drv_StopMeasureTemperatureRaw() { HAL_ADC_Stop_DMA(&ADC_HandleStruct); }
void test_LineSensors(void) { ADC_ChannelConfTypeDef sConfig; ExpanderSetbit(7,0); HAL_Delay(100); ExpanderSetbit(7,1); HAL_Delay(100); ssd1306Init(0); ssd1306ClearScreen(); ssd1306Refresh(); while(1) { ssd1306ClearScreen(); HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, SET); HAL_Delay(25); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_3; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_1, 1); ssd1306PrintInt(10, 5, "ADC3 = ", uhADCxConvertedValue_1, &Font_5x8); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_4; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_2, 1); ssd1306PrintInt(10, 15, "ADC4 = ", uhADCxConvertedValue_2, &Font_5x8); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_1; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_3, 1); ssd1306PrintInt(10, 25, "ADC1 = ", uhADCxConvertedValue_3, &Font_5x8); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_13; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_4, 1); ssd1306PrintInt(10, 35, "ADC13 = ", uhADCxConvertedValue_4, &Font_5x8); HAL_ADC_Stop_DMA(&hadc1); sConfig.Channel = ADC_CHANNEL_12; sConfig.Rank = 1; sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES; HAL_ADC_ConfigChannel(&hadc1, &sConfig); HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&uhADCxConvertedValue_5, 1); ssd1306PrintInt(10, 45, "ADC12 = ", uhADCxConvertedValue_5, &Font_5x8); ssd1306Refresh(); HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, RESET); } }
void ADC_Stop(){ HAL_ADC_Stop_DMA(&AdcHandle); }
bool uni_adc_stop(void) { //if(HAL_ADC_Stop(&hadc1) != HAL_OK) return 0; if(HAL_ADC_Stop_DMA(&hadc1) != HAL_OK) return 0; return 1; }
void Syringe_Size_stop(void) { HAL_ADC_Stop_DMA(&AdcHandle); }