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);
}
}
static void acquisition_start(void)
{
HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)&wave_buff, WAVE_BUFF_LEN, DAC_ALIGN_12B_R);
HAL_ADC_Start_IT(&hadc2);
HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&mic_buff, WAVE_BUFF_LEN);
HAL_TIM_Base_Start(&htim2);
HAL_TIM_Base_Start_IT(&htim3);
}
adc::adc (void)
{
GPIO_InitTypeDef GPIO_InitStruct;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* ADC3 Periph clock enable */
ADCx_CLK_ENABLE()
;
/* Enable GPIO clock ****************************************/
ADCx_CHANNEL_GPIO_CLK_ENABLE()
;
/*##-2- Configure peripheral GPIO ##########################################*/
/* ADC3 Channel8 GPIO pin configuration */
GPIO_InitStruct.Pin = ADCx_CHANNEL_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init (ADCx_CHANNEL_GPIO_PORT, &GPIO_InitStruct);
/*##-3- Configure the NVIC #################################################*/
/* NVIC configuration for DMA transfer complete interrupt (USART1_TX) */
HAL_NVIC_SetPriority (ADCx_IRQn, 15, 0);
HAL_NVIC_EnableIRQ (ADCx_IRQn);
ADC_ChannelConfTypeDef sConfig;
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV8;
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if (HAL_ADC_Init (&AdcHandle) != HAL_OK)
asm("bkpt 0");
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel (&AdcHandle, &sConfig) != HAL_OK)
asm("bkpt 0");
/*##-3- Start the conversion process and enable interrupt ##################*/
if (HAL_ADC_Start_IT (&AdcHandle) != HAL_OK)
asm("bkpt 0");
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_ADC1_Init();
MX_USART6_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
HAL_ADC_Start_IT(&hadc1);
//Zonder DMA (op interrupt)
// while(counter < 2)HAL_GPIO_WritePin(GPIOD,LD6_Pin,GPIO_PIN_SET);
//HAL_GPIO_WritePin(GPIOD,LD6_Pin,GPIO_PIN_RESET);
if(counter == BUFFER_LENGTH * 2) {
Uart_transmit(BufferPin1);
Uart_transmit(BufferPin2);
counter = 0;
}
/*if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
{
HAL_Delay(500);
HAL_GPIO_WritePin(GPIOD,LD3_Pin,GPIO_PIN_SET);//GREEN
//zonder DMA Single Scan
sprintf(buffer,"pin a1: %05d ",val1);
HAL_UART_Transmit(&huart6,(uint8_t*) buffer,strlen(buffer),HAL_MAX_DELAY);
sprintf(buffer,"pin a2: %05d ",val2);
HAL_UART_Transmit(&huart6,(uint8_t*) buffer,strlen(buffer),HAL_MAX_DELAY);
HAL_UART_Transmit(&huart6,"\r\n",strlen("\r\n"),HAL_MAX_DELAY);
}*/
}
/* USER CODE END 3 */
}
void CAM_init()
{
/*
* Initialize hardware
*/
CAM_GPIO_init();
CAM_TIM_init(SLOW);
CAM_ADC_init();
/*
* Initial GPIO pins status
*/
RESET_high();
START_low();
LOAD_low();
SIN_low();
/*
* Configure NVIC (interrupts)
*/
HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(ADC_IRQn);
HAL_NVIC_SetPriority(TIM2_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
HAL_NVIC_SetPriority(EXTI1_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
/*
* Initialize library global variables
*/
imageCursor = 0;
flag_captureGoing = 0;
flag_captureEnd = 0;
clockPhase = 0;
acquiring = 0;
skip = PIXSKIP;
/*
* Start ADC
*/
HAL_ADC_Start_IT(&AdcHandle); // Providing ConvCplt Callback
/*
* Start TIM Base and TIM PWM
*/
HAL_TIM_Base_Start_IT(&htim); // Providing PeriodElapsed Callback
HAL_TIM_PWM_Start_IT(&htim, TIM_CHANNEL_2); // Providing PulseFinished Callback
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 216 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC peripheral ######################################*/
ADC_Config();
/*##-4- Start the conversion process and enable interrupt ##################*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
__HAL_RCC_DAC_CLK_ENABLE();
/*##-3- TIM counter enable ################################################*/
if (HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
int main(void)
{
/* USER CODE BEGIN 1 */
trace_printf("Hello\n");
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
/* USER CODE BEGIN 2 */
/* Initialize ADC */
BSP_ADC_Init(&hadc_bsp1,ADC_IN1,1,Indepenent_Mode);
/* Modify ADC resolution in init structure */
hadc_bsp1.Init.Resolution = ADC_RESOLUTION8b;
/* Initialize ADC again */
HAL_ADC_Init(&hadc_bsp1);
/* Start ADC */
HAL_ADC_Start_IT(&hadc_bsp1);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
int main(void)
{
/* USER CODE BEGIN 1 */
trace_printf("Hello\n");
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
/* USER CODE BEGIN 2 */
/* Initialize ADC */
BSP_ADC_Init(&hadc_bsp2,ADC_IN2,1,Indepenent_Mode);
/* Initialize LED */
BSP_LED_Init(LED5);
/* Initialize ADC Watchdog */
BSP_ADC_Thr_Init(&hadc_bsp2,3412, 682);
/* Start ADC */
HAL_ADC_Start_IT(&hadc_bsp2);
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC peripheral ######################################*/
ADC_Config();
/*##-4- Start the conversion process and enable interrupt ##################*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-3- TIM counter enable ################################################*/
if (HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 144 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
ADC_Config();
/*##-2- Start the conversion process and enable interrupt for regular channel #*/
if(HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-3- Wait one seconde before starting injected convertion ###############*/
HAL_Delay(1000);
/*##-4- Start the conversion process and enable interrupt for injected channel #*/
if(HAL_ADCEx_InjectedStart_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 144 Mhz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- TIM8 Peripheral Configuration ######################################*/
TIM_Config();
/*##-2- Configure the ADC3 peripheral ######################################*/
ADC_Config();
/*##-3- Start the conversion process and enable interrupt ##################*/
if(HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-4- TIM8 counter enable ################################################*/
if(HAL_TIM_Base_Start(&htim) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief ADC configuration
* @param None
* @retval None
*/
static void ADC_Config(void) {
ADC_ChannelConfTypeDef sConfig;
/* ADC Initialization */
AdcHandle.Instance = ADC3;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle.Init.Resolution = ADC_RESOLUTION10b;
AdcHandle.Init.ScanConvMode = ENABLE;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T8_TRGO;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = ENABLE;
AdcHandle.Init.EOCSelection = ENABLE;
if(HAL_ADC_Init(&AdcHandle) != HAL_OK) {
Error_Handler();
}
/* Configure ADC3 regular channel */
sConfig.Channel = ADC_CHANNEL_7;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if(HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) {
Error_Handler();
}
/* Start the conversion process and enable interrupt */
if(HAL_ADC_Start_IT(&AdcHandle) != HAL_OK) {
Error_Handler();
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* This sample code shows how to convert an analog input and read the converted
data using DMA transfer.
To proceed, 4 steps are required: */
/* STM32L0xx HAL library initialization:
- Configure the Flash prefetch, Flash preread and Buffer caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Low Level Initialization
*/
HAL_Init();
/* Configure the System clock to have a frequency of 2 MHz (Up to 32MHZ possible) */
SystemClock_Config();
/* ### - 1 - Initialize ADC peripheral #################################### */
/*
* Instance = ADC1.
* OversamplingMode = Disabled
* ClockPrescaler = PCLK clock with no division.
* LowPowerAutoOff = Disabled (For this exemple continuous mode is enabled with software start)
* LowPowerFrequencyMode = Enabled (To be enabled only if ADC clock is lower than 2.8MHz)
* LowPowerAutoWait = Enabled (New conversion starts only when the previous conversion is completed)
* Resolution = 12 bit (increased to 16 bit with oversampler)
* SamplingTime = 7.5 cycles od ADC clock.
* ScanDirection = Upward
* DataAlign = Right
* ContinuousConvMode = Enabled
* DiscontinuousConvMode = Enabled
* ExternalTrigConvEdge = None (Software start)
* EOCSelection = End Of Conversion event
* DMAContinuousRequests = DISABLE
*/
AdcHandle.Instance = ADC1;
AdcHandle.Init.OversamplingMode = DISABLE;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV1;
AdcHandle.Init.LowPowerAutoOff = DISABLE;
AdcHandle.Init.LowPowerFrequencyMode = ENABLE;
AdcHandle.Init.LowPowerAutoWait = ENABLE;
AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
AdcHandle.Init.SamplingTime = ADC_SAMPLETIME_7CYCLES_5;
AdcHandle.Init.ScanDirection = ADC_SCAN_DIRECTION_UPWARD;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIG_EDGE_NONE;
AdcHandle.Init.EOCSelection = EOC_SINGLE_CONV;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
/* Initialize ADC peripheral according to the passed parameters */
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
Error_Handler();
}
/* ### - 2 - Start calibration ############################################ */
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK)
{
Error_Handler();
}
/* ### - 3 - Channel configuration ######################################## */
/* Select Channel 0 to be converted */
sConfig.Channel = ADC_CHANNEL_0;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
Error_Handler();
}
/* ### - 4 - Start conversion in Interrupt mode ########################### */
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
Error_Handler();
}
/* Infinite Loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
/* Enable the CPU Cache */
CPU_CACHE_Enable();
/* STM32F7xx HAL library initialization:
- Configure the Flash ART accelerator on ITCM interface
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 216 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4;
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
AdcHandle.Init.ScanConvMode = DISABLE; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
AdcHandle.Init.ContinuousConvMode = ENABLE; /* Continuous mode disabled to have only 1 conversion at each conversion trig */
AdcHandle.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* Conversion start trigged at each external event */
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* ADC initialization Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADC_CHANNEL_8;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Start the conversion process #######################################*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/*## Configure peripherals #################################################*/
/* Initialize LEDs on board */
BSP_LED_Init(LED2);
BSP_LED_Init(LED1);
/* Configure User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Configure ADC */
/* Note: This function configures the ADC but does not enable it. */
/* To enable it (ADC activation and conversion start), use */
/* function "HAL_ADC_Start_xxx()". */
/* This is intended to optimize power consumption: */
/* 1. ADC configuration can be done once at the beginning */
/* (ADC disabled, minimal power consumption) */
/* 2. ADC enable (higher power consumption) can be done just before */
/* ADC conversions needed. */
/* Then, possible to perform successive "Activate_ADC()", */
/* "Deactivate_ADC()", ..., without having to set again */
/* ADC configuration. */
Configure_ADC();
#if defined(WAVEFORM_GENERATION)
/* Configure the DAC peripheral and generate a constant voltage of Vdda/2. */
Generate_waveform_SW_update_Config();
#endif /* WAVEFORM_GENERATION */
/*## Enable peripherals ####################################################*/
/* Note: ADC is enabled afterwards when starting ADC conversion using */
/* function "HAL_ADC_Start_xxx()". */
/* Infinite loop */
while (1)
{
/* Wait for event on push button to perform following actions */
while ((ubUserButtonClickEvent) == RESET)
{
}
/* Reset variable for next loop iteration */
ubUserButtonClickEvent = RESET;
#if defined(WAVEFORM_GENERATION)
/* Modifies modifies the voltage level, to generate a waveform circular, */
/* shape of ramp: Voltage is increasing at each press on push button, */
/* from 0 to maximum range (Vdda) in 5 steps, then starting back from 0V. */
/* Voltage is updated incrementally at each call of this function. */
Generate_waveform_SW_update();
#endif /* WAVEFORM_GENERATION */
/* Turn LED off before performing a new ADC conversion start */
BSP_LED_Off(LED1);
/* Reset status variable of ADC group regular unitary conversion before */
/* performing a new ADC group regular conversion start. */
if (ubAdcGrpRegularUnitaryConvStatus != 0)
{
ubAdcGrpRegularUnitaryConvStatus = 0;
}
/* Init variable containing ADC conversion data */
uhADCxConvertedData = VAR_CONVERTED_DATA_INIT_VALUE;
/*## Start ADC conversions ###############################################*/
/* Start ADC group regular conversion with IT */
/* Note: Perform initial ADC conversion start using driver HAL, */
/* then following ADC conversion start using driver LL. */
/* (mandatory to use driver LL after the first call of */
/* ADC IRQ handler, implemented with driver LL). */
if (LL_ADC_IsEnabled(ADCx) == 0)
{
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* ADC conversion start error */
Error_Handler();
}
}
/* ########## Starting from this point HAL API must not be used ########## */
else
{
/* Start ADC group regular conversion */
/* Note: Hardware constraint (refer to description of the functions */
/* below): */
/* On this STM32 serie, setting of these features are not */
/* conditioned to ADC state. */
/* However, in order to be compliant with other STM32 series */
/* and to show the best practice usages, ADC state is checked. */
/* Software can be optimized by removing some of these checks, if */
/* they are not relevant considering previous settings and actions */
/* in user application. */
if (LL_ADC_IsEnabled(ADCx) == 1)
{
LL_ADC_REG_StartConversionSWStart(ADCx);
}
else
{
/* Error: ADC conversion start could not be performed */
Error_Handler();
}
}
/* Note: Variable "ubUserButtonClickEvent" is set into push button */
/* IRQ handler, refer to function "HAL_GPIO_EXTI_Callback()". */
/* Note: ADC conversions data are stored into variable */
/* "uhADCxConvertedData". */
/* (for debug: see variable content into watch window). */
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 144 Mhz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if(HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if(HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Start the conversion process and enable interrupt ##################*/
if(HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/*## Configuration of peripherals ##########################################*/
/* Initialize LEDs on board */
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
/* Initialize the User Button in Interrupt mode */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
/* Configure external lines 9 to 5 in interrupt mode */
EXTILine9_5_Config();
/* Configuration of ADC peripheral */
ADC_Config();
/* Run the ADC calibration in differential mode */
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_DIFFERENTIAL_ENDED) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Configuration of DAC peripheral */
DAC_Config();
/*## Enable peripherals ####################################################*/
/* Set DAC Channel data register: channel corresponding to ADC channel ADCx_CHANNEL_DIFF_HIGH */
/* Set DAC output to 1/2 of full range (4095 <=> Vdda=3.3V): 2048 <=> 1.65V */
if (HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNEL_DIFF_HIGH, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Set DAC Channel data register: channel corresponding to ADC channel ADCx_CHANNEL_DIFF_LOW */
/* Set DAC output to minimum of full range (0 <=> ground 0V) */
if (HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNEL_DIFF_LOW, DAC_ALIGN_12B_R, 0) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel ADCx_CHANNEL_DIFF_HIGH */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNEL_DIFF_HIGH) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel ADCx_CHANNEL_DIFF_LOW */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNEL_DIFF_LOW) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with interruption */
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
/* Set DAC voltage on channel corresponding to ADC channel ADCx_CHANNEL_DIFF_LOW */
/* in function of user button clicks count. */
/* Set DAC output succesively to: */
/* - minimum of full range (0 <=> ground 0V) */
/* - 1/4 of full range (4095 <=> Vdda=3.3V): 1023 <=> 0.825V */
/* - 1/2 of full range (4095 <=> Vdda=3.3V): 2048 <=> 1.65V */
/* - 3/4 of full range (4095 <=> Vdda=3.3V): 3071 <=> 2.475V */
/* - maximum of full range (4095 <=> Vdda=3.3V) */
if (HAL_DAC_SetValue(&DacHandle,
DACx_CHANNEL_TO_ADCx_CHANNEL_DIFF_LOW, DAC_ALIGN_12B_R,
(RANGE_12BITS * uwUserButtonClickCount / USERBUTTON_CLICK_COUNT_MAX)
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* ADC Differential conversion result calculation: */
/* - An offset of half of full range is added to keep the full dynamic */
/* range of differential voltage. */
/* - Channels voltage is divided by 2, resolution is lowered of 1 bit. */
/* => Diff conversion result = mid-range + (channel_high-channel_low)/2 */
/* Turn-on/off LED2 in function of ADC differential conversion result */
/* - Turn-on LED2 if differential voltage is positive */
/* - Turn-off LED2 if differential voltage is negative */
if (uhADCxConvertedValue > RANGE_12BITS/2)
{
BSP_LED_On(LED2);
}
else
{
BSP_LED_Off(LED2);
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
ADC_ChannelConfTypeDef sConfig;
ADC_InjectionConfTypeDef sConfigInjected;
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization: global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure the system clock to 180 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the ADC peripheral #######################################*/
AdcHandle.Instance = ADCx;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV4;
AdcHandle.Init.Resolution = ADC_RESOLUTION_12B;
AdcHandle.Init.ScanConvMode = DISABLE;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.EOCSelection = DISABLE;
if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
{
/* ADC initialization Error */
Error_Handler();
}
/*##-2- Configure ADC regular channel ######################################*/
sConfig.Channel = ADCx_REG_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_56CYCLES;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Configure ADC injected channel ######################################*/
sConfigInjected.InjectedNbrOfConversion = 1;
sConfigInjected.InjectedChannel = ADCx_INJ_CHANNEL;
sConfigInjected.InjectedRank = 1;
sConfigInjected.InjectedSamplingTime = ADC_SAMPLETIME_56CYCLES;
sConfigInjected.InjectedOffset = 0;
sConfigInjected.ExternalTrigInjecConvEdge = ADC_EXTERNALTRIGINJECCONVEDGE_NONE;
sConfigInjected.ExternalTrigInjecConv = ADC_EXTERNALTRIGINJECCONV_T1_CC4;
sConfigInjected.AutoInjectedConv = DISABLE;
sConfigInjected.InjectedDiscontinuousConvMode = DISABLE;
if(HAL_ADCEx_InjectedConfigChannel(&AdcHandle, &sConfigInjected) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-4- Start the conversion process and enable interrupt for regular channel #*/
if (HAL_ADC_Start_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/*##-5- Wait one second before starting injected conversion ###############*/
HAL_Delay(1000);
/*##-6- Start the conversion process and enable interrupt for injected channel #*/
if(HAL_ADCEx_InjectedStart_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
int main(void)
{
/* USER CODE BEGIN 1 */
int teller=0;
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_ADC1_Init();
MX_USART6_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
HAL_ADC_Start_IT(&hadc1);
HAL_ADC_Start_DMA(&hadc1, &ADCBuffer3[0], ADC_BUFFER_LENGTH*4);
/* if(counter%2 == 0)
{
HAL_ADC_Start_DMA(&hadc1, &ADCBuffer1[0], ADC_BUFFER_LENGTH*2);
}
else
{
HAL_ADC_Start_DMA(&hadc1, &ADCBuffer2[0], ADC_BUFFER_LENGTH*2);
}
counter++;*/
// Uart_transmit(ADCBuffer);
// HAL_UART_Transmit(&huart6,"\r\n",strlen("\r\n"),HAL_MAX_DELAY);
// HAL_UART_Transmit(&huart6,"\r\n",strlen("\r\n"),HAL_MAX_DELAY);
//Zonder DMA (op interrupt)
//char buffer[50] = {"Empty.."};
//uint16_t val1;
//uint16_t val2;
/* while(counter < 2)HAL_GPIO_WritePin(GPIOD,LD6_Pin,GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOD,LD6_Pin,GPIO_PIN_RESET);
if(counter>= 2) {
val1 = a1;
val2 = a2;
…
}*/
if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
{
HAL_Delay(500);
HAL_GPIO_WritePin(GPIOD,LD3_Pin,GPIO_PIN_SET);//GREEN
//met DMA Continious Scan
DoubleUart_transmit(ADCBuffer1,ADCBuffer2);
Uart_transmit(ADCBuffer3);
// HAL_UART_Transmit(&huart6,(uint8_t*)"Buffer Pin 1\r\n",strlen("Buffer Pin 1\r\n"),HAL_MAX_DELAY);
// Uart_transmit(ADCBuffer1);
// HAL_UART_Transmit(&huart6,"Buffer Pin 2\r\n",strlen("Buffer Pin 2\r\n"),HAL_MAX_DELAY);
// Uart_transmit(ADCBuffer2);
// HAL_UART_Transmit(&huart6,"\r\n",strlen("\r\n"),HAL_MAX_DELAY);
// HAL_UART_Transmit(&huart6,(uint8_t*)"\r\n",strlen("\r\n"),HAL_MAX_DELAY);
//zonder DMA Single Scan
/* sprintf(buffer,"pin a1: %05d ",val1);
HAL_UART_Transmit(&huart6,(uint8_t*) buffer,strlen(buffer),HAL_MAX_DELAY);
sprintf(buffer,"pin a2: %05d ",val2);
HAL_UART_Transmit(&huart6,(uint8_t*) buffer,strlen(buffer),HAL_MAX_DELAY);
HAL_UART_Transmit(&huart6,"\r\n",strlen("\r\n"),HAL_MAX_DELAY);*/
}
}
/* USER CODE END 3 */
}
