Digital-to-Analog Converter (DAC): Signal Generator

Transforming digital code into continuous analog signals to build a custom waveform generator.

BeginnerFull instructions provided1 hour44

Digital-to-Analog Converter (DAC): Signal Generator

Things used in this project

Hardware components

RT-Thread RT-Spark Development Board

Jumper wires (generic)

Oscilloscope

Software apps and online services

STMicroelectronics STM32CUBEPROG

STM32CUBEMX

Story

1. Introduction

This laboratory exercise explored the practical use of a Digital-to-Analog Converter (DAC) to generate various continuous electrical signals. By connecting an RT-Spark Development Board to a digital oscilloscope, the physical behaviors of digital signal generation were observed in real-time. The primary objective was to generate, visualize, and analyze square, ramp, and sine waves. This activity provided a foundational understanding of how microcontrollers translate discrete digital data into measurable analog voltages.

2. Design and Testing

The execution of the experiment required a combination of precise hardware wiring and software configuration to successfully produce and measure the required waveforms.

Hardware Configuration The main device utilized was the RT-Thread RT-Spark Development Board, which contains an ARM-based STM32 microcontroller. To visualize the signals, a digital oscilloscope was connected directly to the development board. The positive probe of the oscilloscope was attached to the DAC_OUT pin to capture the signal output, while the ground clip was attached to the GND pin to provide a stable common reference point.

Software Configuration The software environment relied on STM32CubeIDE and STM32CubeMX. The shape of the waveform was controlled by modifying a specific parameter within the main program loop. By changing the final parameter in the tone_play function to SQUARE, RAMP, or SINE, the microcontroller was instructed to output the corresponding signal shapes. The updated code was then compiled and downloaded to the board for observation.

3. Documentation and Results

Measurements and visual observations were carefully recorded for the three generated waveforms using the digital oscilloscope. A notable difficulty encountered during this phase was operating the oscilloscope to extract accurate readings. Locating the exact signal measurements required careful navigation of the equipment's measurement menus and precise adjustments to the screen's time scale, which initially proved to be a challenging but valuable learning experience.

3.1 Square Wave Analysis The system was first configured to output a square wave. The following electrical characteristics were successfully extracted from the oscilloscope display:

The rise and fall times of 800 nanoseconds reflect the brief physical settling time required by the DAC to transition between logic states. The 0.133-millisecond period confirms that the wave was operating at a frequency of approximately 7.5 kHz.

3.2 Ramp Wave Analysis When the software was adjusted to output a ramp wave, the rising edge of the signal appeared jagged rather than perfectly smooth.

Cause of the Jagged Edge: This visual stepping is caused by the DAC's 8-bit resolution. An 8-bit system can only output 256 distinct voltage levels. Therefore, instead of a smooth, continuous slope, the voltage increases in tiny, discrete steps, creating a "staircase" visual effect.
Hardware Smoothing: To smooth this jagged edge physically, a low-pass RC filter (composed of a resistor and a capacitor) can be wired to the DAC output to blend the sharp voltage jumps together.
Software Smoothing: To achieve a smoother wave purely through coding, the DAC update rate can be increased while using smaller voltage increments per step. This minimizes the size of the "stairs, " making the wave appear more continuous.

3.3 Sine Wave Analysis The final test involved generating a continuous sine wave. Through software experimentation, it was determined that the absolute maximum frequency sine wave that the microcontroller's loop could generate was 15, 625 Hz.

4. Conclusion

The laboratory exercise successfully demonstrated the practical application of digital-to-analog conversion. While setting up the software and hardware was straightforward, extracting precise data proved to be a significant part of the learning curve. Navigating the digital oscilloscope to find exact values—especially the nanosecond transition times—was initially difficult but ultimately highlighted the importance of using proper measurement tools in electronics. Furthermore, observing the jagged edges of the ramp wave provided a clear, real-world visual of digital quantization limits. Overall, the activity reinforced key concepts in firmware programming, electronic signal analysis, and proper laboratory documentation.

Code

main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2026 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "tone.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
DAC_HandleTypeDef hdac;

TIM_HandleTypeDef htim6;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DAC_Init(void);
static void MX_TIM6_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
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();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DAC_Init();
  MX_TIM6_Init();
  /* USER CODE BEGIN 2 */
  tone_init(&hdac, &htim6);
  tone_play(SINE);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
	  uint32_t dummy = dac_value; // Forces compiler to keep the symbol
	  (void)dummy;                // Prevents "unused variable" warning

	  HAL_Delay(100);
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief DAC Initialization Function
  * @param None
  * @retval None
  */
static void MX_DAC_Init(void)
{

  /* USER CODE BEGIN DAC_Init 0 */

  /* USER CODE END DAC_Init 0 */

  DAC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN DAC_Init 1 */

  /* USER CODE END DAC_Init 1 */

  /** DAC Initialization
  */
  hdac.Instance = DAC;
  if (HAL_DAC_Init(&hdac) != HAL_OK)
  {
    Error_Handler();
  }

  /** DAC channel OUT1 config
  */
  sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
  sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DAC_Init 2 */

  /* USER CODE END DAC_Init 2 */

}

/**
  * @brief TIM6 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM6_Init(void)
{

  /* USER CODE BEGIN TIM6_Init 0 */

  /* USER CODE END TIM6_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM6_Init 1 */

  /* USER CODE END TIM6_Init 1 */
  htim6.Instance = TIM6;
  htim6.Init.Prescaler = 5;
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.Period = 15;
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM6_Init 2 */

  /* USER CODE END TIM6_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  /* USER CODE BEGIN MX_GPIO_Init_1 */

  /* USER CODE END MX_GPIO_Init_1 */

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* USER CODE BEGIN MX_GPIO_Init_2 */

  /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Credits

ARIANE MARTIN

5 projects • 0 followers

Paul Rodolf P. Castor

60 projects • 9 followers

Digital-to-Analog Converter (DAC): Signal Generator