static inline void dac_write(dac_t *obj, int value) {
if (obj->pin == PA_4) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_1, DAC_ALIGN_12B_R, (value & DAC_RANGE));
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_1);
} else if (obj->pin == PA_5) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_2, DAC_ALIGN_12B_R, (value & DAC_RANGE));
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_2);
}
}
static inline void dac_write(dac_t *obj, uint16_t value)
{
if (obj->pin == PA_4) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value);
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_1);
} else { // PA_5
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_2, DAC_ALIGN_12B_R, value);
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_2);
}
}
static inline void dac_write(dac_t *obj, uint16_t value)
{
if (obj->channel == 1) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value);
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_1);
}
if (obj->channel == 2) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_2, DAC_ALIGN_12B_R, value);
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_2);
}
}
/**
* @brief Configures the DAC channel 1 with output buffer enabled.
* @param None
* @retval None
*/
static void DAC_Config(void)
{
/*##-1- Configure the DAC peripheral #######################################*/
DacHandle.Instance = DACx;
if(HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Error */
ErrorHandler();
}
/*##-2- Configure DAC channel1 #############################################*/
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
if(HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL) != HAL_OK)
{
/* Channel configuration Error */
ErrorHandler();
}
/*##-3- Set DAC Channel1 DHR register ######################################*/
if(HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL, DAC_ALIGN_12B_R, 868) != HAL_OK)
{
/* Setting value Error */
ErrorHandler();
}
/*##-4- Enable DAC Channel1 ################################################*/
if(HAL_DAC_Start(&DacHandle, DACx_CHANNEL) != HAL_OK)
{
/* Start Error */
ErrorHandler();
}
}
/**
* @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 LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the DAC peripheral #######################################*/
DacHandle.Instance = DACx;
if (HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure DAC channel1 #############################################*/
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL) != HAL_OK)
{
/* Channel configuration Error */
Error_Handler();
}
/*##-3- Set DAC Channel1 DHR register ######################################*/
if (HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL, DAC_ALIGN_8B_R, 0xFF) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/*##-4- Enable DAC Channel1 ################################################*/
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
int dacOutAdcIn(int dacValue, uint32_t adcChannel)
{
HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, dacValue);
HAL_Delay(DAC_OUT_TO_ADC_IN_DELAY); // ms
int adcValue = readAdcChannel(adcChannel);
HAL_DAC_Stop(&hdac, DAC_CHANNEL_1);
return adcValue;
}
void DAC_Init(DAC_HandleTypeDef* hdac)
{
hdac->Instance = DAC; // DAC base address, only one DAC address
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
HAL_DAC_ConfigChannel(hdac, &sConfig, DAC1_CHANNEL_1 );
HAL_DAC_Start(hdac, DAC1_CHANNEL_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 180 MHz */
SystemClock_Config();
/* Configure LED3 */
BSP_LED_Init(LED3);
/*##-1- Configure the DAC peripheral #######################################*/
DacHandle.Instance = DACx;
if(HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure DAC channel1 #############################################*/
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
if(HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL) != HAL_OK)
{
/* Channel configuration Error */
Error_Handler();
}
/*##-3- Set DAC Channel1 DHR register ######################################*/
if(HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL, DAC_ALIGN_8B_R, 0xFF) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/*##-4- Enable DAC Channel1 ################################################*/
if(HAL_DAC_Start(&DacHandle, DACx_CHANNEL) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
}
}
void dac_output()
{
float v0 = dac[0], v1 = dac[1];
if( v0 < 0 ) {
v0 = 0;
}
if( v0 > vref_out ) {
v0 = vref_out;
}
if( v1 < 0 ) {
v1 = 0;
}
if( v1 > vref_out ) {
v1 = vref_out;
}
HAL_DAC_SetValue( &hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, (int)( v0 / vref_out * 4095 ) );
HAL_DAC_SetValue( &hdac, DAC_CHANNEL_2, DAC_ALIGN_12B_R, (int)( v1 / vref_out * 4095 ) );
HAL_DAC_Start( &hdac, DAC_CHANNEL_1 );
HAL_DAC_Start( &hdac, DAC_CHANNEL_2 );
}
void analogout_init(dac_t *obj, PinName pin)
{
uint32_t channel ;
HAL_StatusTypeDef status;
// Get the peripheral name (DAC_1, ...) from the pin and assign it to the object
obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC);
// Get the functions (dac channel) from the pin and assign it to the object
uint32_t function = pinmap_function(pin, PinMap_DAC);
MBED_ASSERT(function != (uint32_t)NC);
// Save the channel for the write and read functions
obj->channel = STM_PIN_CHANNEL(function);
if (obj->dac == (DACName)NC) {
error("DAC pin mapping failed");
}
// Configure GPIO
pinmap_pinout(pin, PinMap_DAC);
__GPIOA_CLK_ENABLE();
__DAC_CLK_ENABLE();
DacHandle.Instance = DAC;
status = HAL_DAC_Init(&DacHandle);
if (status != HAL_OK) {
error("HAL_DAC_Init failed");
}
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
if (obj->channel == 1) {
channel = DAC_CHANNEL_1;
} else {
channel = DAC_CHANNEL_2;
}
if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, channel) != HAL_OK) {
error("HAL_DAC_ConfigChannel failed");
}
if (HAL_DAC_Start(&DacHandle, channel) != HAL_OK) {
error("HAL_DAC_Start failed");
}
if (HAL_DAC_SetValue(&DacHandle, channel, DAC_ALIGN_12B_R, 0x000) != HAL_OK) {
error("HAL_DAC_SetValue failed");
}
}
/// \method write(value)
/// Direct access to the DAC output (8 bit only at the moment).
STATIC mp_obj_t pyb_dac_write(mp_obj_t self_in, mp_obj_t val) {
pyb_dac_obj_t *self = self_in;
if (self->state != 1) {
DAC_ChannelConfTypeDef config;
config.DAC_Trigger = DAC_TRIGGER_NONE;
config.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
self->state = 1;
}
HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_8B_R, mp_obj_get_int(val));
HAL_DAC_Start(&DAC_Handle, self->dac_channel);
return mp_const_none;
}
/**
* @brief This function will set the DAC to the required value
* @param port : the gpio port to use
* @param pin : the gpio pin to use
* @param value : the value to push on the adc output
* @param do_init : if set to 1 the initialization of the adc is done
* @retval None
*/
void dac_write_value(PinName pin, uint32_t value, uint8_t do_init)
{
DAC_HandleTypeDef DacHandle = {};
DAC_ChannelConfTypeDef dacChannelConf = {};
uint32_t dacChannel;
DacHandle.Instance = pinmap_peripheral(pin, PinMap_DAC);
if (DacHandle.Instance == NP) return;
dacChannel = get_dac_channel(pin);
if (!IS_DAC_CHANNEL(dacChannel)) return;
if(do_init == 1) {
if (HAL_DAC_DeInit(&DacHandle) != HAL_OK)
{
/* DeInitialization Error */
return;
}
/*##-1- Configure the DAC peripheral #######################################*/
g_current_pin = pin;
if (HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Initialization Error */
return;
}
dacChannelConf.DAC_Trigger = DAC_TRIGGER_NONE;
dacChannelConf.DAC_OutputBuffer=DAC_OUTPUTBUFFER_ENABLE;
/*##-2- Configure DAC channel1 #############################################*/
if (HAL_DAC_ConfigChannel(&DacHandle, &dacChannelConf, dacChannel) != HAL_OK)
{
/* Channel configuration Error */
return;
}
}
/*##-3- Set DAC Channel1 DHR register ######################################*/
if (HAL_DAC_SetValue(&DacHandle, dacChannel, DAC_ALIGN_12B_R, value) != HAL_OK)
{
/* Setting value Error */
return;
}
/*##-4- Enable DAC Channel1 ################################################*/
HAL_DAC_Start(&DacHandle, dacChannel);
}
/**
* @brief For this example, generate a waveform voltage on a spare DAC
* channel, so user has just to connect a wire between DAC channel
* (pin PA.04) and ADC channel (pin PA.04) to run this example.
* (this prevents the user from resorting to an external signal generator)
* This function configures the DAC and generates a constant voltage of Vdda/2.
* To modify the voltage level, use function "WaveformVoltageGenerationForTest_Update"
* @param None
* @retval None
*/
static void WaveformVoltageGenerationForTest_Config(void)
{
static DAC_ChannelConfTypeDef sConfig;
/*## Configure peripherals #################################################*/
/* Configuration of DACx peripheral */
DacHandle.Instance = DACx;
if (HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* DAC initialization error */
Error_Handler();
}
/* Configuration of DAC channel */
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)
{
/* Channel configuration error */
Error_Handler();
}
/*## Enable peripherals ####################################################*/
/* Set DAC Channel data register: channel corresponding to ADC channel CHANNELa */
/* 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_CHANNELa, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel CHANNELa */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
}
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();
/* System interrupt init*/
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_0);
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_ADC1_Init();
MX_DAC_Init();
MX_TIM2_Init();
/* USER CODE BEGIN 2 */
HAL_ADC_Start(&hadc1);
HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
/* USER CODE END 2 */
/* USER CODE BEGIN 3 */
/* Infinite loop */
while (1)
{
}
/* USER CODE END 3 */
}
/**
* @brief DAC Channel1 Triangle Configuration
* @param None
* @retval None
*/
static void DAC_Ch1_TriangleConfig(void)
{
/*##-1- Initialize the DAC peripheral ######################################*/
if(HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- DAC channel2 Configuration #########################################*/
sConfig.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
if(HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL1) != HAL_OK)
{
/* Channel configuration Error */
Error_Handler();
}
/*##-3- DAC channel2 Triangle Wave generation configuration ################*/
if(HAL_DACEx_TriangleWaveGenerate(&DacHandle, DACx_CHANNEL1, DAC_TRIANGLEAMPLITUDE_1023) != HAL_OK)
{
/* Triangle wave generation Error */
Error_Handler();
}
/*##-4- Enable DAC Channel1 ################################################*/
if(HAL_DAC_Start(&DacHandle, DACx_CHANNEL1) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/*##-5- Set DAC channel1 DHR12RD register ##################################*/
if(HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL1, DAC_ALIGN_12B_R, 0x100) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
}
/// \method noise(freq)
/// Generate a pseudo-random noise signal. A new random sample is written
/// to the DAC output at the given frequency.
STATIC mp_obj_t pyb_dac_noise(mp_obj_t self_in, mp_obj_t freq) {
pyb_dac_obj_t *self = self_in;
// set TIM6 to trigger the DAC at the given frequency
TIM6_Config(mp_obj_get_int(freq));
if (self->state != DAC_STATE_BUILTIN_WAVEFORM) {
// configure DAC to trigger via TIM6
DAC_ChannelConfTypeDef config;
config.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
config.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
self->state = DAC_STATE_BUILTIN_WAVEFORM;
}
// set noise wave generation
HAL_DACEx_NoiseWaveGenerate(&DAC_Handle, self->dac_channel, DAC_LFSRUNMASK_BITS10_0);
HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_12B_L, 0x7ff0);
HAL_DAC_Start(&DAC_Handle, self->dac_channel);
return mp_const_none;
}
/// \method triangle(freq)
/// Generate a triangle wave. The value on the DAC output changes at
/// the given frequency, and the frequence of the repeating triangle wave
/// itself is 256 (or 1024, need to check) times smaller.
STATIC mp_obj_t pyb_dac_triangle(mp_obj_t self_in, mp_obj_t freq) {
pyb_dac_obj_t *self = self_in;
// set TIM6 to trigger the DAC at the given frequency
TIM6_Config(mp_obj_get_int(freq));
if (self->state != 2) {
// configure DAC to trigger via TIM6
DAC_ChannelConfTypeDef config;
config.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
config.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
self->state = 2;
}
// set triangle wave generation
HAL_DACEx_TriangleWaveGenerate(&DAC_Handle, self->dac_channel, DAC_TRIANGLEAMPLITUDE_1023);
HAL_DAC_SetValue(&DAC_Handle, self->dac_channel, DAC_ALIGN_12B_R, 0x100);
HAL_DAC_Start(&DAC_Handle, self->dac_channel);
return mp_const_none;
}
/**
* @brief Configure DACx
* @param None
* @retval None
*/
static void DACx_Config(void)
{
/*##-1- Configure the DAC peripheral #######################################*/
DacHandle.Instance = DACx;
if(HAL_DAC_Init(&DacHandle) != HAL_OK)
{
/* Initiliazation Error */
Error_Handler();
}
/*##-2- Configure DAC channel1 #############################################*/
sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
if(HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DACx_CHANNEL) != HAL_OK)
{
/* Channel configuration Error */
Error_Handler();
}
/*##-3- Set DAC Channel1 DHR register ######################################*/
/* VREF ~ 3.3 V */
/* DAC_OUT = (3.3 * 2588) / 4095 ~ 2.086 V = 3.3*(1-exp(-t/R*C)) with t=R*C */
/* Set DAC Value = 2588 */
if(HAL_DAC_SetValue(&DacHandle, DACx_CHANNEL, DAC_ALIGN_12B_R, 2588) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/*##-4- Enable DAC Channel1 ################################################*/
if(HAL_DAC_Start(&DacHandle, DACx_CHANNEL) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
}
static inline void dac_write(dac_t *obj, uint16_t value) {
HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value);
HAL_DAC_Start(&DacHandle, DAC_CHANNEL_1);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F3xx HAL library initialization:
- Configure the Flash prefetch
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 64 MHz */
SystemClock_Config();
/*## Configure peripherals #################################################*/
/* Initialize LED on board */
BSP_LED_Init(LED2);
/* Configure User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Configure the ADC peripheral */
ADC_Config();
/* Run the ADC calibration in single-ended mode */
if (HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
/* Configure the TIM peripheral */
TIM_Config();
/* Configure the DAC peripheral */
DAC_Config();
/*## Enable peripherals ####################################################*/
/* Timer counter enable */
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
/* Set DAC Channel data register: channel corresponding to ADC channel CHANNELa */
/* 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_CHANNELa, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel CHANNELa */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with transfer by DMA */
if (HAL_ADC_Start_DMA(&AdcHandle,
(uint32_t *)aADCxConvertedValues,
ADCCONVERTEDVALUES_BUFFER_SIZE
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* Infinite loop */
while (1)
{
/* Turn-on/off LED2 in function of ADC conversion result */
/* - Turn-off if voltage is into AWD window */
/* - Turn-on if voltage is out of AWD window */
/* Variable of analog watchdog status is set into analog watchdog */
/* interrupt callback */
if (ubAnalogWatchdogStatus == RESET)
{
BSP_LED_Off(LED2);
}
else
{
BSP_LED_On(LED2);
/* Reset analog watchdog status for next loop iteration */
ubAnalogWatchdogStatus = RESET;
}
/* For information: ADC conversion results are stored into array */
/* "aADCxConvertedValues" (for debug: check into watch window) */
/* Wait for event on push button to perform following actions */
while ((ubUserButtonClickEvent) == RESET)
{
__NOP();
}
/* Reset variable for next loop iteration */
ubUserButtonClickEvent = RESET;
/* Set DAC voltage on channel corresponding to ADCx_CHANNELa */
/* in function of user button clicks count. */
/* Set DAC output successively 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_CHANNELa,
DAC_ALIGN_12B_R,
(RANGE_12BITS * ubUserButtonClickCount / USERBUTTON_CLICK_COUNT_MAX)
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
}
}
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_DMA_Init();
MX_ADC_Init();
APP_ADC_Init(&hadc);
#ifdef USE_COMPARATORS
MX_COMP1_Init();
MX_COMP2_Init();
#endif
MX_DAC_Init();
MX_USART2_UART_Init();
/* USER CODE BEGIN 2 */
HAL_UART_Transmit(&huart2,str,strlen((const char *) str),1000);
HAL_UART_Transmit(&huart2,heading,strlen((const char *) heading),1000);
dacConfig.DAC_Trigger = DAC_TRIGGER_NONE;
dacConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
HAL_DAC_ConfigChannel(&hdac,&dacConfig,DAC_CHANNEL_1);
HAL_DAC_SetValue(&hdac,DAC_CHANNEL_1,DAC_ALIGN_12B_R,2048);
HAL_DAC_Start(&hdac,DAC_CHANNEL_1);
/* Initialize ADC peripheral according to the passed parameters */
if (HAL_ADC_Init(&hadc) != HAL_OK)
{
while(-1);
}
/* ### - 2 - Start calibration ############################################ */
if (HAL_ADCEx_Calibration_Start(&hadc, ADC_SINGLE_ENDED) != HAL_OK)
{
while(-1);
}
/* ### - 3 - Channel configuration ######################################## */
/* Select Channel 0 to be converted */
///sConfig.Channel = ADC_CHANNEL_0;
//if (HAL_ADC_ConfigChannel(&hadc, &sConfig) != HAL_OK)
//{
// Error_Handler();
//}
/* ### - 4 - Start conversion in DMA mode ################################# */
if (HAL_ADC_Start_DMA(&hadc, (uint32_t *) adcBuf,ADC_BUFSIZE) != HAL_OK)
{
while(-1);
}
compValues[0]= '-';
compValues[1]= '-';
#ifdef USE_COMPARATORS
HAL_COMP_Start_IT(&hcomp1);
HAL_COMP_Start_IT(&hcomp2);
#endif
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
uint16_t cnt=0;
uint16_t dacValue = 0;
memset(dataline, ' ', sizeof(dataline));
dataline[sizeof(dataline)-1] = 0;
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
HAL_DAC_SetValue(&hdac,DAC_CHANNEL_1,DAC_ALIGN_12B_R,dacValue);
#ifdef WAIT_BEFORE_READING
int i;
for(i=0; i < 10000; i++);
#endif
itoa (cnt,(char *) &dataline[0],5);
itoa (dacValue,(char *)&dataline[10],5);
itoa (adcBuf[0],(char *)&dataline[20],4);
dataline[25] = '/';
itoa (adcBuf[2],(char *)&dataline[25],4);
itoa (adcBuf[1],(char *)&dataline[40],4);
dataline[45] = '/';
itoa (adcBuf[3],(char *)&dataline[45],4);
#ifdef USE_COMPARATORS
dataline[60] = compValues[0];
dataline[65] = compValues[1];
#else
// memcpy("Not Used",dataline[60],8);
#endif
dataline[70] = (HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_6)==GPIO_PIN_SET)?'X':'0';
dataline[75] = (HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_7)==GPIO_PIN_SET)?'X':'0';
dataline[87] = '\r';
dataline[88] = '\n';
dataline[89] = 0;
HAL_UART_Transmit(&huart2,dataline,strlen((const char *) dataline),1000);
cnt++;
dacValue = (dacValue >= (4096-DAC_STEPSIZE))?0:dacValue+DAC_STEPSIZE;
}
/* USER CODE END 3 */
}
/**
* @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)
{
/* STM32F103xG 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();
/*## Configure peripherals #################################################*/
/* Initialize LEDs on board */
BSP_LED_Init(LED3);
BSP_LED_Init(LED1);
/* Configure Key push-button in Interrupt mode */
BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
/* Configure the ADC peripheral */
ADC_Config();
/* Run the ADC calibration */
if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)
/* Configure the DAC peripheral */
DAC_Config();
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/*## Enable peripherals ####################################################*/
#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)
/* Set DAC Channel data register: channel corresponding to ADC channel CHANNELa */
/* 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_CHANNELa, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel CHANNELa */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with transfer by DMA */
if (HAL_ADC_Start_DMA(&AdcHandle,
(uint32_t *)aADCxConvertedValues,
ADCCONVERTEDVALUES_BUFFER_SIZE
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* 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_VOLTAGE_GENERATION_FOR_TEST)
/* Set DAC voltage on channel corresponding to ADCx_CHANNELa */
/* in function of user button clicks count. */
/* Set DAC output successively 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_CHANNELa,
DAC_ALIGN_12B_R,
(RANGE_12BITS * ubUserButtonClickCount / USERBUTTON_CLICK_COUNT_MAX)
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/* Wait for DAC settling time */
HAL_Delay(1);
/* Start ADC conversion */
/* Since sequencer is enabled in discontinuous mode, this will perform */
/* the conversion of the next rank in sequencer. */
/* Note: For this example, conversion is triggered by software start, */
/* therefore "HAL_ADC_Start()" must be called for each conversion. */
/* Since DMA transfer has been initiated previously by function */
/* "HAL_ADC_Start_DMA()", this function will keep DMA transfer */
/* active. */
HAL_ADC_Start(&AdcHandle);
/* Wait for conversion completion before conditional check hereafter */
HAL_ADC_PollForConversion(&AdcHandle, 1);
/* Turn-on/off LED1 in function of ADC sequencer status */
/* - Turn-off if sequencer has not yet converted all ranks */
/* - Turn-on if sequencer has converted all ranks */
if (ubSequenceCompleted == RESET)
{
BSP_LED_Off(LED1);
}
else
{
BSP_LED_On(LED1);
/* Computation of ADC conversions raw data to physical values */
/* Note: ADC results are transferred into array "aADCxConvertedValues" */
/* in the order of their rank in ADC sequencer. */
uhADCChannelToDAC_mVolt = COMPUTATION_DIGITAL_12BITS_TO_VOLTAGE(aADCxConvertedValues[0]);
uhVrefInt_mVolt = COMPUTATION_DIGITAL_12BITS_TO_VOLTAGE(aADCxConvertedValues[2]);
wTemperature_DegreeCelsius = COMPUTATION_TEMPERATURE_STD_PARAMS(aADCxConvertedValues[1]);
/* Reset variable for next loop iteration */
ubSequenceCompleted = RESET;
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/* STM32F1xx 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 24 MHz */
SystemClock_Config();
/*## Configure peripherals #################################################*/
/* Initialize LEDs on board */
BSP_LED_Init(LED4);
BSP_LED_Init(LED3);
/* Configure User push-button in Interrupt mode */
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
/* Configure the ADC peripheral */
ADC_Config();
/* Run the ADC calibration */
if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
{
/* Calibration Error */
Error_Handler();
}
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Configure the TIM peripheral */
TIM_Config();
#endif /* ADC_TRIGGER_FROM_TIMER */
#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)
/* Configure the DAC peripheral */
DAC_Config();
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/*## Enable peripherals ####################################################*/
#if defined(ADC_TRIGGER_FROM_TIMER)
/* Timer enable */
if (HAL_TIM_Base_Start(&TimHandle) != HAL_OK)
{
/* Counter Enable Error */
Error_Handler();
}
#endif /* ADC_TRIGGER_FROM_TIMER */
#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)
/* Set DAC Channel data register: channel corresponding to ADC channel CHANNELa */
/* 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_CHANNELa, DAC_ALIGN_12B_R, RANGE_12BITS/2) != HAL_OK)
{
/* Setting value Error */
Error_Handler();
}
/* Enable DAC Channel: channel corresponding to ADC channel CHANNELa */
if (HAL_DAC_Start(&DacHandle, DACx_CHANNEL_TO_ADCx_CHANNELa) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/*## Start ADC conversions #################################################*/
/* Start ADC conversion on regular group with transfer by DMA */
if (HAL_ADC_Start_DMA(&AdcHandle,
(uint32_t *)aADCxConvertedValues,
ADCCONVERTEDVALUES_BUFFER_SIZE
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
/* 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;
/* Start ADC conversion on injected group */
if (HAL_ADCEx_InjectedStart_IT(&AdcHandle) != HAL_OK)
{
/* Start Conversation Error */
Error_Handler();
}
#if defined(WAVEFORM_VOLTAGE_GENERATION_FOR_TEST)
/* Set DAC voltage on channel corresponding to ADCx_CHANNELa */
/* in function of user button clicks count. */
/* Set DAC output successively 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_CHANNELa,
DAC_ALIGN_12B_R,
(RANGE_12BITS * ubUserButtonClickCount / USERBUTTON_CLICK_COUNT_MAX)
) != HAL_OK)
{
/* Start Error */
Error_Handler();
}
#endif /* WAVEFORM_VOLTAGE_GENERATION_FOR_TEST */
/* Wait for acquisition time of ADC samples on regular and injected */
/* groups: */
/* wait time to let 1/2 buffer of regular group to be filled (in ms) */
HAL_Delay(16);
/* Turn-on/off LED3 in function of ADC conversion result */
/* - Turned-off if voltage measured by injected group is below voltage */
/* measured by regular group (average of results table) */
/* - Turned-off if voltage measured by injected group is above voltage */
/* measured by regular group (average of results table) */
/* Variables of conversions results are updated into ADC conversions */
/* interrupt callback. */
if (uhADCxConvertedValue_Injected < *puhADCxConvertedValue_Regular_Avg)
{
BSP_LED_Off(LED3);
}
else
{
BSP_LED_On(LED3);
}
/* For information: ADC conversion results are stored into array */
/* "aADCxConvertedValues" (for debug: check into watch window) */
}
}
