嵌入式硬件实战基础篇(一)-STM32+DAC0832 可调信号发生器-产生方波-三角波-正弦波

8位分辨率：DAC0832能够将8位数字输入（从0到255）转换成相应的模拟电压输出。分辨率为8位，意味着它有256个不同的输出级别。
输入接口：
- 并行输入：DAC0832的输入接口是并行型的，它通过8个数据输入引脚（D0-D7）接收8位数字信号。
- 输入信号是由外部系统提供的数字信号，DAC0832将这些信号转换成相应的模拟电压。
模拟输出：
- 输出端为模拟电压，电压范围通常取决于芯片的电源电压。假设工作电压为5V，则输出电压范围通常是0V到5V，具体取决于输入数字的值。
输出类型：DAC0832提供一个双极性输出，允许其在输出端产生正负电压。默认情况下，它使用外部的运算放大器来对输出进行增益调整，以适应不同的应用需求。
工作电压：
- Vcc：通常为5V，但也有部分版本支持3V电源。
- Vref：参考电压，通常与Vcc相同。它决定了转换输出的最大电压值。
转换速率：
- DAC0832具有较高的转换速率，通常为1MSPS（每秒百万次采样），适用于大多数需要快速模拟信号转换的应用。
控制引脚：
- LDAC：加载数据的控制引脚。当LDAC为低时，DAC将输入数据加载到其内部寄存器中并进行转换。
- CS (Chip Select)：芯片选择引脚，低电平有效，用来选择DAC进行操作。
- WR (Write)：写控制信号，用来触发数据输入到DAC内部。
- SYNC：同步信号，用于将多个DAC设备同步工作。
内置运算放大器：DAC0832内部具有一个高输入阻抗的运算放大器，用于对输出电压进行缓冲和驱动，输出信号能够驱动外部负载。
低功耗：DAC0832采用CMOS技术，具备低功耗特点，适用于需要低功耗的便携式设备。

更多内容还是需要在数据手册搜寻自己所需的信息内容才行。

1.2.DCDC 电路原理分析

由于波形发生器利用了 LM324 正负电源有包含 +10V -10V的正负电压，并且MCU等相关模块都是3.3V电压，且输入电压为12V，因此我们需要多方面的DCDC转换，具体如下：

在Power_VIN中为12V，因此我们要 DCDC 12V-24V to 10.00V 我们利用 TPS62933 来完成此需求，具体内容如下图所示：

下图为案例电路图参考：

由于我们得到+10V之后 LM324 还需要 -10V 才可行，因此需要 DCDC 10V-12V to -10.00V，我们利用 LMZM33606 来实现需求，具体手册参考图如下所示：

更多的详情内容还需要看手册来设计，由于篇幅有限，就只展示部分内容。

最后，我们需要 DCDC 10V-12V to 3.30V 供给 MCU 电压，我们选用 TPS82140 ，相关手册如下所示：

案例如下所示：

综上我们对于原理进行了需求分析，现在可以开始进行原理图设计了。

2.原理图与PCB设计

2.1.原理图分析

总图总览如下所示：

有了前面的相关分析，上述原理图也非常的容易理解了。

2.2.PCB分析

2D图如下所示：

3D预览图如下所示：

二、软件设计

重点讲一下下述的功能点，频率可调、波形可选的信号发生器，使用 STM32 的定时器、GPIO 和中断机制来输出正弦波、三角波和方波信号。下面我们逐步分析代码。

1. `sine_wave` 函数（输出正弦波）

static void sine_wave(uint8_t location) // 输出正弦波
{
  static uint8_t i = 0;
  
  location = location * 256 / 100;  // 将 location 转换为 0 到 255 的范围

  GPIOA->ODR = tab[location];  // 从预定义的正弦波查找表 tab 中读取对应的波形数据并输出到 GPIOA

  ++i;  // 每次调用增加计数器

  if(i >= 64)  // 如果 i 达到 64，则重置 i
  {
    i = 0;
  }
}

sine_wave 函数根据 location 值来输出正弦波信号。location 是波形的当前位置。
location 会乘以 256 / 100 来转换为适合查找表 tab[] 的索引。tab[] 存储了正弦波的采样值。
每次 sine_wave 被调用时，i 增加，i 用于周期性地从 tab[] 查找表中获取波形数据并通过 GPIOA->ODR 输出。
i 被限制为小于 64，这意味着正弦波的查找表周期为 64 次，当 i 达到 64 时，i 会被重置为 0。

2. `tri_wave` 函数（输出三角波）

static void tri_wave(uint8_t location) // 输出三角波
{
  uint8_t y;
  if(location < 50)
    y = (50 - location) * 255 / 50;  // 前半部分，下降的三角波
  else
    y = (location - 50) * 255 / 50;  // 后半部分，上升的三角波
  GPIOA->ODR = y;  // 输出计算结果到 GPIOA
}

tri_wave 函数生成一个三角波形。location 控制波形的当前位置。
如果 location 小于 50，波形从最大值下降；如果 location 大于 50，波形从最小值上升。
y 的值会在 0 到 255 之间变化，表示三角波的振幅。
通过 GPIOA->ODR 输出计算得到的三角波信号。

3. `squ_wave` 函数（输出方波）

void squ_wave(uint8_t location) // 输出方波
{
  if(location < 50)
    GPIOA->ODR = 255;  // 输出高电平（方波的上升沿）
  else
    GPIOA->ODR = 0x0;  // 输出低电平（方波的下降沿）
}

squ_wave 函数生成一个方波。location 控制波形的当前位置。
如果 location 小于 50，输出高电平（255）；如果 location 大于等于 50，输出低电平（0）。
方波的周期是 100 个时钟周期，GPIOA->ODR 控制方波的输出。

4. `set_time` 函数（设置定时器周期）

static void set_time(void) // 设置定时器时间
{
  uint32_t Period;
  
  Period = 10000 / freq - 1;  // 根据频率计算定时器的周期

  htim1.Init.Period = Period;  // 设置定时器周期
  
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();  // 如果定时器初始化失败，调用错误处理函数
  }
  
  // 启动定时器
  HAL_TIM_Base_Start_IT(&htim1);
}

set_time 根据全局变量 freq 计算定时器周期。freq 是输出波形的频率，Period 是定时器的周期值。
htim1.Init.Period 设置定时器的周期，10000 / freq - 1 表示定时器的溢出时间。
定时器初始化成功后，通过 HAL_TIM_Base_Start_IT 启动定时器。

5. `HAL_GPIO_EXTI_Callback` 函数（外部中断回调）

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_PIN_10 == GPIO_Pin) // 频率加
  {
    HAL_TIM_Base_Stop(&htim1);
    if(freq < 20000)
      freq += 10;
    set_time();  // 重新设置定时器
    sprintf((char *)display_buf, "Freq:%dHz     ", freq);  // 显示频率
    lcd1602_display_string(0, 0, display_buf);  // LCD 显示频率
    HAL_TIM_Base_Start_IT(&htim1);  // 启动定时器
  }
  
  if(GPIO_PIN_11 == GPIO_Pin) // 频率减
  {
    HAL_TIM_Base_Stop(&htim1);
    if(freq > 20)
      freq -= 10;
    set_time();  // 重新设置定时器
    sprintf((char *)display_buf, "Freq:%dHz     ", freq);  // 显示频率
    lcd1602_display_string(0, 0, display_buf);  // LCD 显示频率
    HAL_TIM_Base_Start_IT(&htim1);  // 启动定时器
  }

  if(GPIO_PIN_12 == GPIO_Pin) // 切换波形
  {
    HAL_TIM_Base_Stop(&htim1);
    if(mode == 1)
    {
      mode = 2;
      lcd1602_display_string(0, 1, (uint8_t *)"Triangle wave");
    }
    else if(mode == 2)
    {
      mode = 3;
      lcd1602_display_string(0, 1, (uint8_t *)"Square wave  ");
    }
    else if(mode == 3)
    {
      mode = 1;
      lcd1602_display_string(0, 1, (uint8_t *)"Sine wave  ");
    }
    HAL_TIM_Base_Start_IT(&htim1);  // 启动定时器
  }
}

该回调函数处理外部中断，响应不同的按键或开关操作。
GPIO_PIN_10 和 GPIO_PIN_11 用于增加或减少频率，每次按下时，freq 变量会增减 10，并重新设置定时器。
GPIO_PIN_12 用于切换波形模式。按下时，波形从正弦波（W_SINE）切换到三角波（W_TRI）再到方波（W_SQU），并在 LCD 屏上显示当前波形。

6. `HAL_TIM_PeriodElapsedCallback` 函数（定时器溢出回调）

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  static uint8_t times;
  
  if(htim == &htim1)
  {
    switch(mode)
    {
      case W_SINE: sine_wave(times); break;  // 正弦波
      case W_TRI:  tri_wave(times); break;   // 三角波
      case W_SQU:  squ_wave(times); break;   // 方波
    }
    
    times++;
    if(times >= 100) // 计数到 100 后重置
      times = 0;
  }
}

当定时器溢出时，HAL_TIM_PeriodElapsedCallback 被调用。
根据当前的波形模式（mode），调用相应的波形生成函数（sine_wave、tri_wave、squ_wave）。
times 用于控制波形的位置，每次计数达到 100 时，重置为 0。

如下直接贴出main.c代码，代码非常的简单。

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdarg.h"
#include "stdio.h"
#include "string.h"

/* USER CODE END Includes */

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

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
///LCD1602使能端口控制
#define BSP_LCD1602_EN_HHAL_GPIO_WritePin(LCD1602_EN_GPIO_Port, LCD1602_EN_Pin, GPIO_PIN_SET)
#define BSP_LCD1602_EN_LHAL_GPIO_WritePin(LCD1602_EN_GPIO_Port, LCD1602_EN_Pin, GPIO_PIN_RESET)

///LCD1602读/写端口控制
#define BSP_LCD1602_RW_HHAL_GPIO_WritePin(LCD1602_RW_GPIO_Port, LCD1602_RW_Pin, GPIO_PIN_SET)
#define BSP_LCD1602_RW_LHAL_GPIO_WritePin(LCD1602_RW_GPIO_Port, LCD1602_RW_Pin, GPIO_PIN_RESET)

///LCD1602指令/数据端口控制
#define BSP_LCD1602_RS_HHAL_GPIO_WritePin(LCD1602_RS_GPIO_Port, LCD1602_RS_Pin, GPIO_PIN_SET)
#define BSP_LCD1602_RS_LHAL_GPIO_WritePin(LCD1602_RS_GPIO_Port, LCD1602_RS_Pin, GPIO_PIN_RESET)

#define W_SINE 1
#define W_TRI 2
#define W_SQU 3

/* USER CODE END PD */

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;

/* USER CODE BEGIN PV */
static uint8_t display_buf[16];

static unsigned char tab[256]=     //正弦表
{
  0x80,0x83,0x86,0x89,0x8d,0x90,0x93,0x96,0x99,0x9c,0x9f,0xa2,0xa5,0xa8,0xab,0xae,0xb1,0xb4,0xb7,0xba,0xbc,0xbf,0xc2,0xc5,
  0xc7,0xca,0xcc,0xcf,0xd1,0xd4,0xd6,0xd8,0xda,0xdd,0xdf,0xe1,0xe3,0xe5,0xe7,0xe9,0xea,0xec,0xee,0xef,0xf1,0xf2,0xf4,0xf5,
  0xf6,0xf7,0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfd,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0xfd,
  0xfd,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,0xf6,0xf5,0xf4,0xf2,0xf1,0xef,0xee,0xec,0xea,0xe9,0xe7,0xe5,0xe3,0xe1,0xde,0xdd,0xda,
  0xd8,0xd6,0xd4,0xd1,0xcf,0xcc,0xca,0xc7,0xc5,0xc2,0xbf,0xbc,0xba,0xb7,0xb4,0xb1,0xae,0xab,0xa8,0xa5,0xa2,0x9f,0x9c,0x99,
  0x96,0x93,0x90,0x8d,0x89,0x86,0x83,0x80,0x80,0x7c,0x79,0x76,0x72,0x6f,0x6c,0x69,0x66,0x63,0x60,0x5d,0x5a,0x57,0x55,0x51,
  0x4e,0x4c,0x48,0x45,0x43,0x40,0x3d,0x3a,0x38,0x35,0x33,0x30,0x2e,0x2b,0x29,0x27,0x25,0x22,0x20,0x1e,0x1c,0x1a,0x18,0x16,
  0x15,0x13,0x11,0x10,0x0e,0x0d,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x02,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0d,0x0e,0x10,0x11,0x13,0x15,
  0x16,0x18,0x1a,0x1c,0x1e,0x20,0x22,0x25,0x27,0x29,0x2b,0x2e,0x30,0x33,0x35,0x38,0x3a,0x3d,0x40,0x43,0x45,0x48,0x4c,0x4e,
  0x51,0x55,0x57,0x5a,0x5d,0x60,0x63,0x66,0x69,0x6c,0x6f,0x72,0x76,0x79,0x7c,0x80
};

static uint8_t mode = 1;
static uint16_t freq = 20;

/* USER CODE END PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void  delay_us(uint16_t nus)//us延时
{
__HAL_TIM_SetCounter(&htim2,0);
__HAL_TIM_ENABLE(&htim2);

while(__HAL_TIM_GetCounter(&htim2)<nus);

__HAL_TIM_DISABLE(&htim2);
}
/*---------------------------------------------------------------------------*/
static void lcd1602_delay_1us(void)
{
  delay_us(1);
}
/*---------------------------------------------------------------------------*/
void lcd1602_delay_1ms(void)
{
HAL_Delay(1);
}
/*---------------------------------------------------------------------------*/
static void lcd1602_port_write(uint8_t val)//1602写入数据
{
  if(val & 0x80){
    HAL_GPIO_WritePin(LCD1602_D7_GPIO_Port, LCD1602_D7_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D7_GPIO_Port, LCD1602_D7_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x40){
    HAL_GPIO_WritePin(LCD1602_D6_GPIO_Port, LCD1602_D6_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D6_GPIO_Port, LCD1602_D6_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x20){
    HAL_GPIO_WritePin(LCD1602_D5_GPIO_Port, LCD1602_D5_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D5_GPIO_Port, LCD1602_D5_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x10){
    HAL_GPIO_WritePin(LCD1602_D4_GPIO_Port, LCD1602_D4_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D4_GPIO_Port, LCD1602_D4_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x08){
    HAL_GPIO_WritePin(LCD1602_D3_GPIO_Port, LCD1602_D3_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D3_GPIO_Port, LCD1602_D3_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x04){
    HAL_GPIO_WritePin(LCD1602_D2_GPIO_Port, LCD1602_D2_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D2_GPIO_Port, LCD1602_D2_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x02){
    HAL_GPIO_WritePin(LCD1602_D1_GPIO_Port, LCD1602_D1_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D1_GPIO_Port, LCD1602_D1_Pin, GPIO_PIN_RESET);
  }

  if(val & 0x01){
    HAL_GPIO_WritePin(LCD1602_D0_GPIO_Port, LCD1602_D0_Pin, GPIO_PIN_SET);
  }else{
    HAL_GPIO_WritePin(LCD1602_D0_GPIO_Port, LCD1602_D0_Pin, GPIO_PIN_RESET);
  }
}
/*---------------------------------------------------------------------------*/
static uint8_t lcd1602_read_state(void)//1602读取状态
{
 uint8_t state;
  
  ///下面为lcd操作时序
  BSP_LCD1602_RS_L;
  BSP_LCD1602_RW_H;
  BSP_LCD1602_EN_H;
  lcd1602_delay_1us();
state = HAL_GPIO_ReadPin(LCD1602_D7_GPIO_Port, LCD1602_D7_Pin);
BSP_LCD1602_EN_L;
  lcd1602_delay_1us();
  
return state;
}
/*---------------------------------------------------------------------------*/
static void lcd1602_busy_wait(void)//1602空闲判断
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  uint16_t timeout;

  GPIO_InitStruct.Pin = LCD1602_D7_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LCD1602_D7_GPIO_Port, &GPIO_InitStruct);

  timeout  = 0xffff;
 while((lcd1602_read_state() & 0x80) == 0x80){
    timeout--;
    if(timeout == 0){
      break;
    }
  }
lcd1602_delay_1us();
  
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  HAL_GPIO_Init(LCD1602_D7_GPIO_Port, &GPIO_InitStruct);
}

/*---------------------------------------------------------------------------*/
static void lcd1602_write_data(uint8_t dat)//1602写数据
{
  ///下面为lcd1602操作时序
 lcd1602_busy_wait();
BSP_LCD1602_RS_H;
  BSP_LCD1602_RW_L;
  BSP_LCD1602_EN_L;
  lcd1602_port_write(dat);
  BSP_LCD1602_EN_H;
  lcd1602_delay_1us();
  BSP_LCD1602_EN_L;
}
/*---------------------------------------------------------------------------*/
static void lcd1602_write_command(uint8_t cmd)//1602写命令
{
  ///下面为lcd1602操作时序
 lcd1602_busy_wait();
BSP_LCD1602_RS_L;
  BSP_LCD1602_RW_L;
  BSP_LCD1602_EN_L;
  lcd1602_port_write(cmd);
  BSP_LCD1602_EN_H;
  lcd1602_delay_1us();
  BSP_LCD1602_EN_L;
}
/*---------------------------------------------------------------------------*/
void lcd1602_init(void)//1602初始化
{
 lcd1602_write_command(0x38); ///<设置16 X 2显示, 5 X 7点阵, 8位数据接口
lcd1602_delay_1ms();
lcd1602_write_command(0x01); ///<显示清0,数据指针清0
lcd1602_delay_1ms();
lcd1602_write_command(0x06); ///<设置写一个字符后地址加1
lcd1602_delay_1ms();
lcd1602_write_command(0x0c); ///<设置开显示,不显示光标
lcd1602_delay_1ms();
}
/*---------------------------------------------------------------------------*/
void lcd1602_display_char(    uint8_t      x, uint8_t y, uint8_t ch )//1602输入字符
{
  if(x > 15 || y > 1){
    return;
  }
  if(y == 0){
    lcd1602_write_command(x | 0x80);///<设置LCD1602第一行要显示的光标位置
  }else if(y == 1){
    lcd1602_write_command(x | 0x80 | 0x40);///<设置LCD1602第二行要显示的光标位置
  }
  lcd1602_write_data( ch );
}
/*---------------------------------------------------------------------------*/
void lcd1602_display_string( uint8_t x, uint8_t y, const uint8_t * str )//1602输入字符串
{
  while(*str != '\0'){
    lcd1602_display_char(x, y, *str); ///<显示一个字符
    str++;  ///<显示下一个字符
    x++;    ///<显示下一个位置
    if(x > 15){
      break;
    }
  }
}
/*---------------------------------------------------------------------------*/
void lcd1602_clear_display(void)//1602清屏
{
  lcd1602_write_command(0x01);
  HAL_Delay(5);
}
/*---------------------------------------------------------------------------*/
static void sine_wave(uint8_t location)//输出正弦波
{
  static uint8_t i = 0;
  
  location = location * 256 / 100;

  GPIOA->ODR = tab[location];
  ++i;
  if(i>=64)
  {
    i = 0;
  }
}
static void tri_wave(uint8_t location)//三角波
{
uint8_t y;
if(location<50)
y=(50-location)*255/50;
else
y=(location-50)*255/50;
GPIOA->ODR = y;
}

void squ_wave(uint8_t location)//方波
{
if(location<50)
GPIOA->ODR=255;
else
GPIOA->ODR=0x0;
}

static void set_time(void)//
{
  uint32_t Period;

  Period = 10000 / freq - 1;
  
  htim1.Init.Period = Period;
  
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  
}


void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  if(GPIO_PIN_10 == GPIO_Pin)//频率加
  {
    HAL_TIM_Base_Stop(&htim1);
    if(freq < 20000)
      freq += 10;
    set_time();
    sprintf((char *)display_buf, "Freq:%dHz     ", freq);
    lcd1602_display_string(0, 0, display_buf);
    HAL_TIM_Base_Start_IT(&htim1);
  }
  
  if(GPIO_PIN_11 == GPIO_Pin)//频率减
  {
    HAL_TIM_Base_Stop(&htim1);
    if(freq > 20)
      freq -= 10;
    set_time();
    sprintf((char *)display_buf, "Freq:%dHz     ", freq);
    lcd1602_display_string(0, 0, display_buf);
    HAL_TIM_Base_Start_IT(&htim1);
  }

  if(GPIO_PIN_12 == GPIO_Pin)//锯齿波
  {
    HAL_TIM_Base_Stop(&htim1);
    if(mode == 1)
    {
      mode = 2;
      lcd1602_display_string(0, 1, (uint8_t *)"Triangle wave");
    }
    else if(mode == 2)
    {
      mode = 3;
      lcd1602_display_string(0, 1, (uint8_t *)"Square wave  ");
    }
    else if(mode == 3)
    {
      mode = 1;
      lcd1602_display_string(0, 1, (uint8_t *)"Sine wave  ");
    }
    HAL_TIM_Base_Start_IT(&htim1);
  }
}


void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  static uint8_t times;
  
  if(htim == &htim1)
  {
    switch(mode)
  {
  case W_SINE: sine_wave(times);break;//计算出波的位置
  case W_TRI:  tri_wave(times);break;
      case W_SQU:  squ_wave(times);break;
  }
    
  times++;
  if(times>=100)//计数100次
  times=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_TIM2_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
  lcd1602_init();//1602初始化

  sprintf((char *)display_buf, "Freq:%dHz     ", freq);
  lcd1602_display_string(0, 0, display_buf);

  lcd1602_display_string(0, 1, (uint8_t *)"Sine wave");
  
  HAL_TIM_Base_Start_IT(&htim1);

  set_time();
  
  /* 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 System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** 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 TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 7;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 1000-1;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}

/**
  * @brief TIM2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 7;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 65535;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
                          |LCD1602_EN_Pin|LCD1602_RW_Pin|LCD1602_RS_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, LCD1602_D0_Pin|LCD1602_D1_Pin|LCD1602_D2_Pin|LCD1602_D3_Pin
                          |LCD1602_D4_Pin|LCD1602_D5_Pin|LCD1602_D6_Pin|LCD1602_D7_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA0 PA1 PA2 PA3
                           PA4 PA5 PA6 PA7
                           LCD1602_EN_Pin LCD1602_RW_Pin LCD1602_RS_Pin */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
                          |LCD1602_EN_Pin|LCD1602_RW_Pin|LCD1602_RS_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : LCD1602_D0_Pin LCD1602_D1_Pin LCD1602_D2_Pin LCD1602_D3_Pin
                           LCD1602_D4_Pin LCD1602_D5_Pin LCD1602_D6_Pin LCD1602_D7_Pin */
  GPIO_InitStruct.Pin = LCD1602_D0_Pin|LCD1602_D1_Pin|LCD1602_D2_Pin|LCD1602_D3_Pin
                          |LCD1602_D4_Pin|LCD1602_D5_Pin|LCD1602_D6_Pin|LCD1602_D7_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PB10 PB11 PB12 */
  GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

}

/* 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 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

三、仿真验证

下图为仿真图：

如下为正弦波：

如下为三角波：

如下为方波：

频率也是可以增加减少的（20HZ-20KHZ）

原文地址：https://blog.csdn.net/weixin_64593595/article/details/143666664

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Flink独立集群+Flink整合yarn
下一篇：wordpress站外调用指定ID分类下的推荐内容

11.15 机器学习-集成学习方法-随机森林
机器学习中有一种大类叫**集成学习**（Ensemble Learning），集成学习的基本思想就是将多个分类器组合，从而实现一个预测效果更好的集成分类器。# 就是把多个分类器组合起来用每个分类器都
阅读更多2024-11-16
Linux之vim全选，全部复制，全部删除
（区分大小写！！！全部删除：按esc键后，先按gg（到达顶部），然后dG全部复制：按esc键后，先按gg，然后ggyG全选高亮显示：按esc键后，先按gg，然后ggvG或者ggVG单行复制：按esc键
阅读更多2024-11-16
机器学习 ---线性回归
文章主要介绍了线性回归相关内容，包括简单线性回归与多元线性回归的概念及示例，阐述了残差的定义、在理想与非理想模型中的情况及意义，还讲解了线性回归的正规方程解，涵盖其适用场景、公式推导与代码实现，提及衡
阅读更多2024-11-16
机器学习day5-随机森林和线性代数1
在坐标轴上画出对应的点（离散或者连续），如果是离散的点，需要找一条直线使得这些点尽可能多地在这条直线上，或者能够尽可能均匀地分布在这条直线的两边，达到损失值最小的目标，使其尽可能地接近能够进行准确预测
阅读更多2024-11-16
AUTOSAR COM修改PDU发送周期不生效
首先当前是其他PDU都是能正常发送的，且发送的周期都符合通信矩阵DBC中的定义。经过分析是COM模块使能了MDT的周期发送功能，且该I-PDU配置了MDT（即下图中的Minimum Delay Tim
阅读更多2024-11-16
计算机网络：运输层 —— TCP 的 “三次握手” 与 “四次挥手”
TCP是面向连接的协议，它基于运输连接来传送TCP报文段。TCP运输连接的建立和释放，是每一次面向连接的通信中必不可少的过程。TCP运输连接有以下三个阶段：通过“三报文握手”来建立TCP连接。基于已建
阅读更多2024-11-16
数据结构-5.二叉树
本篇博客给大家带来的是二叉树的知识点, 其中包括面试经常会提问的真题 ArrayList 和 LinkedList 的区别 .文章专栏:Java-数据结构若有问题评论区见如果你不知道分享给谁,那就分
阅读更多2024-11-16
NotePad++中安装XML Tools插件
作为开发人员，日常开发中大部的数据是标准的json格式，但是对于一些古老的应用，例如webservice接口，由于其响应结果是xml，那么我们拿到xml格式的数据后，常常会对其进行格式化，以便阅读。。
阅读更多2024-11-16
在 Unix 和类 Unix 操作系统中，信号是一种异步的通知机制，用于通知进程发生了一些特定的事件。
SIGINT：中断信号，通常由Ctrl+C产生。SIGTERM：终止信号，用于优雅地终止进程。SIGKILL：强制终止信号，立即终止进程。SIGHUP：挂断信号，通常由终端会话结束产生。SIGQUIT
阅读更多2024-11-16
常见查找排序算法
printf("元素 %d 在数组中的下标是 %d\n", key, mid);printf("元素 %d 在数组中的下标是 %d\n", key, i);pr
阅读更多2024-11-16

嵌入式硬件实战基础篇(一)-STM32+DAC0832 可调信号发生器-产生方波-三角波-正弦波

一、硬件设计

1.电路原理分析

1.1.DAC0832 电路原理分析

1.2.DCDC 电路原理分析

2.原理图与PCB设计

2.1.原理图分析

2.2.PCB分析

二、软件设计

1. sine_wave 函数（输出正弦波）

2. tri_wave 函数（输出三角波）

3. squ_wave 函数（输出方波）

4. set_time 函数（设置定时器周期）

5. HAL_GPIO_EXTI_Callback 函数（外部中断回调）

6. HAL_TIM_PeriodElapsedCallback 函数（定时器溢出回调）