CubeMX_ADC学习笔记——ADC（DMA模式）的使用

最新推荐文章于 2024-06-03 20:06:04 发布
最新推荐文章于 2024-06-03 20:06:04 发布
阅读量4.7k 收藏 38
点赞数 7
分类专栏： STM32 嵌入式 文章标签： stm32 嵌入式 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44907649/article/details/109409208
版权

CubeMX_ADC学习笔记——ADC（DMA模式）的使用


学生党，写博客的目的纯粹是为了记录自己的学习经历，方便以后翻看，所以写的不是很专业和规范。如有解释错误、理解错误、术语使用错误等问题，亦可指出。

一、在CubeMX上创建项目工程

1、创建工程

在这里插入图片描述

2、搜索芯片型号

在这里插入图片描述

3、双击选择芯片型号（STM32G071RBTX）

在这里插入图片描述

4、进入界面，选择串口SWD调试方式

在这里插入图片描述

5、选择外部陶瓷晶振

在这里插入图片描述

6、GPIO配置

在这里插入图片描述

7、ADC配置

在这里插入图片描述

注 需要关注的有：

在设置通道优先级时要对应住：
在这里插入图片描述

synchronous clock mode divided by   同步时钟模式分频
asynchronous clock mode divided    异步时钟模式分频
resolution分辨率
data alignment 数据对齐（右）

Sequencer 扫描顺序        
Sequencer fully configurable  描通道的顺序与通道号channel number无关
Sequencer not fully configurable  通道扫描的顺序由通道编号定义

scan conversion mode       扫描转换模式（需要选择Sequencer not fully configurable）
continuous conversion mode 自动连续扫描模式（需要选择Sequencer not fully configurable）
Discontinuous Conversion Mode   非连续转换模式
MDA continuous Requests   DMA连续请求
（在开启DMA连续请求前 需先开启DMA配置）

End of conversion selection 转换结束选择   
End of single conversion 单次转换结束 
End of sequence of conversion 转换序列结束

overrun behaviour  侵占行为   
overrun data preserved 溢出的数据保存  
overrun data overwritten 溢出的数据覆盖

external trigger conversion edge 外部触发机制

8、定时器配置

在这里插入图片描述

记得在NVIC里使能定时器中断：
在这里插入图片描述

注 需要关注的有：

定时器的定时时间计算公式：
在这里插入图片描述

这里配置定时器是为了每1ms取出一次DMA的值。

ARR: 自动重装载寄存器( AutoReload Register )（16位数据）
PSC：预分频器（16位数据）
TIM_CLK: ADC时钟频率

主要要修改的就是上面的参数，但计算的时候要注意TIM_CLK的单位是HZ不是MHZ

9、串口配置（默认配置即可，最后记得在NVIC里使能串口中断）

在这里插入图片描述

10、配置DMA

在这里插入图片描述

注 需要关注的有：

一定要选择Circular模式（循环模式）

11、时钟树配置

在这里插入图片描述

注 需要关注的有：

（由于芯片的特性，所以最大主频只能到64而不是下面的72。）

HSI：内部高速时钟，RC振荡器，频率为8MHz。可作为系统时钟或PLL锁相环的输入。
HSE：外部高速时钟，可通过外接一个频率范围是4-16MHz的时钟或者晶振，HSE可以作为系统时钟和PLL锁相环输入，还可以经过128分频后输入给RTC。
LSI：内部低速时钟，RC振荡器，频率大约为40K，可供独立看门狗和RTC使用，并且独立看门狗只能使用LSI时钟。
LSE：外部低速时钟，通常在外部低速时钟管脚上外接一个32.768KHz的晶振，供RTC使用。
PLL：锁相环，用于倍频输出，因为开发板外部高速晶振也只有8M，如果要使芯片的最大时钟频率是72M，可通过PLL锁相环来倍频。从图标5中可以看到，PLL时钟输入源可选择为HSI/2、HSE或者HSE/2，时钟源经过2-16倍频后输入给PLLCLK，如果系统时钟选择由PLLCLK提供，则PLLCLK最大值不要超过72M。
SYSCLK：系统时钟。它是STM32中绝大部分部件工作的时钟源。它的时钟来源可以由HSI、HSE、PLLCLK提供。
系统复位后， HSI振荡器被选为系统时钟，当时钟源被直接或通过PLL间接作为系统时钟时，它将不能被停止。只有当目标时钟源准备就绪了(经过启动稳定阶段的延迟或PLL稳定)，从一个时钟源到另一个时钟源的切换才会发生。在被选择时钟源没有就绪时，系统时钟的切换不会发生。直至目标时钟源就绪，才发生切换。

二、在MDK中修改CubeMX上创建的项目工程：

1、头文件、数据类型及函数声明的添加位置

在修改工程代码前需要先了解在MDK中把用户代码添加在什么位置才不会在再次生成CubeMX代码时被覆盖：
在这里插入图片描述

2、添加用户头文件（用于调用sprintf函数）

在这里插入图片描述

3、添加变量定义与声明

在这里插入图片描述

4、编写用户函数（求平均值函数）

在这里插入图片描述

5、串口打印函数

在这里插入图片描述

注意：

其中真实的电压值应该是ADC寄存器去除的值value*3.3/4096

6、重写ADC中断回调函数 和 定时器TIM1中断回调函数

在这里插入图片描述

注意：

我的ADC中断服务函数只用来记录ADC采集次数。
在定时器中断服务函数里是将MDA的缓存数据取出来传给待计算值channel1、channel2、channel3。即使用定时器每秒采集一个DMA的数据（ADC_MDA的频率远高于每毫秒1次）来实现精确的1KHZ的ADC采集频率其中channel3 2ms/次 即500KHZ。

7、定时器和DMA初始化

在这里插入图片描述

说明：

__HAL_TIM_CLEAR_IT(&htim1 ,TIM_IT_UPDATE ); 清除TIM1中断挂起
HAL_TIM_Base_Start_IT(&htim1 );              启动定时器TIM1中断
HAL_ADC_Start_DMA (&hadc1,buffer,6);         启动ADC_MDA

8、主函数循环体while（1）：

在这里插入图片描述

说明：

主函数使用average()函数求出ADC的平均值并每秒通过串口传输函数printf_ADCx()传输。

三、效果展示

1、未使用平均值函数的：（有明显突变和不稳定）

在这里插入图片描述

2、使用平均值函数的：（无明显突变）

在这里插入图片描述

对比数据可得出： 使用平均值的ADC更加平稳。ADC采集源稳定时，没有突变。

四、最后附加一张main.c完整的程序

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2020 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 <stdio.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 ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;

TIM_HandleTypeDef htim1;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

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




char TxData[10]={0};
uint16_t buffer[6]={0}; //DMA缓存
uint16_t count=0;  //ADC转换完成
uint16_t count1=0;//无用的
		uint16_t i=0; //定时器1ms中断
//float  average=0;//平均值
	uint32_t channel1[1000]={0};   //x
	uint32_t channel2[1000]={0};  //y
	uint32_t channel3[500]={0};  //z

	 
	//	tmp=HAL_ADC_GetValue (&hadc1);
 
/* USER CODE END PFP */

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


	uint32_t average(uint32_t*x,int len)
{

uint32_t sum =0;

for(int i=0;i<len;i++)//求总和

sum+=x[i];

return sum/len;//返回平均值
	
}

void printf_ADC1 (uint32_t value )
{
			sprintf(TxData,"%f\t\t",value*3.3/4096);
	HAL_UART_Transmit(&huart1, "ADC1: ",6,0xffff);
  HAL_UART_Transmit(&huart1,TxData,sizeof(TxData),0xffff);
	 
}

void printf_ADC2 (uint32_t value )
{
			sprintf(TxData,"%f\t\t",value*3.3/4096);
	HAL_UART_Transmit(&huart1, "ADC2: ",6,0xffff);
  HAL_UART_Transmit(&huart1,TxData,sizeof(TxData),0xffff);
	 
}

void printf_ADC3 (uint32_t value )
{
			sprintf(TxData,"%f\r\n",value*3.3/4096);
	HAL_UART_Transmit(&huart1, "ADC3: ",6,0xffff);
  HAL_UART_Transmit(&huart1,TxData,sizeof(TxData),0xffff);
	 
}

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
count++;
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance ==TIM1 )
	{
		channel1 [i]=buffer[0];
		channel2 [i]=buffer[1];
		if(i%2==0) 
		channel3 [(i)/2]=buffer[2];	
     i++;	
		if(i>1000)	
		{
						i=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_DMA_Init();
  MX_ADC1_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
	
__HAL_TIM_CLEAR_IT(&htim1 ,TIM_IT_UPDATE ) ;
	
HAL_TIM_Base_Start_IT(&htim1 );
//HAL_ADC_Start_IT(&hadc1);
HAL_ADC_Start_DMA (&hadc1,buffer,6);//***********************************************
//HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_4);


  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
//		char test[]="\t\t\t\thello\r\n";
//	HAL_UART_Transmit_IT(&huart1, test, sizeof(test));
  while (1)
  {

    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

			//	value=HAL_ADC_GetValue(&hadc1);
	
//	 
	 /未求平均值的
//				uint16_t tmp1,tmp2,tmp3;
//		 tmp1=channel1[0];
//	 	 tmp2=channel2[0];	 
//	 	 tmp3=channel3[0];
//		
//        printf_ADC1(tmp1);
//        printf_ADC2(tmp2);
//        printf_ADC3(tmp3);
//	HAL_Delay (1000);
//	
		/	求出平均值的
		uint32_t average1,average2,average3;	
		    average1=average(channel1,1000);
				average2=average(channel2,1000);
				average3=average(channel3,500); 
				
        printf_ADC1(average1);
        printf_ADC2(average2);
        printf_ADC3(average3);
		
	  	HAL_Delay (1000);
			
			


			
			
			
			
			
	 
  }
  /* USER CODE END 3 */
}

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

  /** Configure the main internal regulator output voltage
  */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1;
  RCC_OscInitStruct.PLL.PLLN = 16;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the peripherals clocks
  */
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_ADC
                              |RCC_PERIPHCLK_TIM1;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK;
  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_SYSCLK;
  PeriphClkInit.Tim1ClockSelection = RCC_TIM1CLKSOURCE_PCLK1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief ADC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_ADC1_Init(void)
{

  /* USER CODE BEGIN ADC1_Init 0 */

  /* USER CODE END ADC1_Init 0 */

  ADC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN ADC1_Init 1 */

  /* USER CODE END ADC1_Init 1 */
  /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.LowPowerAutoPowerOff = DISABLE;
  hadc1.Init.ContinuousConvMode = ENABLE;
  hadc1.Init.NbrOfConversion = 3;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_39CYCLES_5;
  hadc1.Init.SamplingTimeCommon2 = ADC_SAMPLETIME_39CYCLES_5;
  hadc1.Init.OversamplingMode = DISABLE;
  hadc1.Init.TriggerFrequencyMode = ADC_TRIGGER_FREQ_HIGH;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLINGTIME_COMMON_1;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */

  /* USER CODE END ADC1_Init 2 */

}

/**
  * @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};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 6400-1;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 10-1;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  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.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.BreakAFMode = TIM_BREAK_AFMODE_INPUT;
  sBreakDeadTimeConfig.Break2AFMode = TIM_BREAK_AFMODE_INPUT;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);

}

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

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

}

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

  /* 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,
     tex: 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****/
李某人_1
关注
  • 7
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【STM32】STM32CUBEMX + ADC(单通道，双通道DMA)
qq_38145331的博客
09-11 1万+
STM32CUBEMX + ADC(单通道，双通道DMA) 案例应用 ：使用ADC采集电压（单通道、单通道+DMA、双通道+DMA），并利用串口打印采集转换后的电压值 1.工具 IAR STM32CUBEMX 开发板STM32F411VET6 预备知识参见：STM32】HAL库 STM32CubeMX教程九—ADC 2.工程配置 2.1 单通道 2.1.1系统时钟RCC、SYS配置 2.1.2 ADC配置，这里强调2点， 使用ADC1——>IN4（通道4）,本案例使用F4开发版，在12bit
CUBEMX-STM32F030学习笔记
03-27
"CUBEMX-STM32F030学习笔记" 本笔记旨在详细介绍STM32F030的功能、原理、CUBE配置图片步骤、选项功能意义、加入的功能代码、性能范围和实践经验值。 一、STM32F030F4P6简介 STM32F030F4P6是一款32位微控制器，...
STM32CubeMX配置ADC采样（轮询、中断、DMA）
weixin_45682654的博客
02-01 2629
STM32 ADC常用方式汇总
STM32 cubemx 多路ADC+DMA
weixin_48420974的博客
08-07 3994
通过DMA采集6路ADC的值
STM32单片机-ADC和DMA
最新发布
m0_51319492的博客
06-03 1260
DMA可以提供外设数据寄存器和存储器(运行内存SRAM和程序存储器Flash)或存储器和存储器之间的高速数据传输，无需CPU干预，节省CPU资源12个DMA1(7个通道)，DMA2(5个通道)每个通道都支持软件(存储器与存储器之间)和特定的硬件触发(外设与存储器)DMA1(7个通道)下面给出存储器的地址Flash只读不可写，SRAM任意读写，外设寄存器看参考手册描述，但其中的数据寄存器是可以正常读写的。
STM32Cubemx——ADC采集+DMA传输
qq_45822269的博客
05-13 1万+
文章目录一、准备工具二、前置知识1.ADC简介2.DMA简介2.STM32Cubemx配置1.新建工程2.时钟源选择及时钟树配置3.时基选择调试接口选择4.配置ADC采集1.选择要配置为ADC采集的引脚2.开启DMA传输，非循环模式3.选择分辨率，使能ADC持续转换4.选择触发源5.生成工程3.Keil编写代码总结 一、准备工具 STM32F407VE核心板 STM32Cubemx 版本 6.0.1 Keil 版本 5.31 杜邦线 ST-Link 二、前置知识 1.ADC简介 12 位 ADC 是逐次
STM32CubeMX教程14 ADC - 多通道DMA转换
lc_guo的博客
12-31 5570
使用STM32CubeMX软件配置STM32F407开发板的ADC实现ADC多通道DMA采集，具体为使用ADC_IN5/6/7三个通道进行DMA连续ADC转换
STM32cubeMX:双通道ADC（DMA）
边疆与诗的博客
03-30 1万+
STM32cubeMX:双通道ADC（DMA） 1. ADC基础 说明： ①STM32f429BI ②keil5 ③stm32cubeMX 　　STM32f429中，有三个ADC（模拟/数字转换器），每个 ADC 有 12 位、 10 位、 8 位和 6 位可选，每个ADC有16个外部通道、2个内部通道和一个VBAT 通道的信号。下面，将根据单个的ADC框图来依次说明一下ADC的几个主要参数，手册...
STM32CubeMX学习笔记十二《ADC轮询采集八路》
06-25
这篇“STM32CubeMX学习笔记十二《ADC轮询采集八路》”主要探讨如何使用STM32CubeMX配置STM32F767IG芯片，实现ADC对八路输入信号的轮询采集。 首先，我们需要了解STM32F767IG是一款高性能的ARM Cortex-M7内核微控制...
STM32学习笔记-用ADC和片内温度传感器测温
05-11
"STM32学习笔记-用ADC和片内温度传感器测温" 本篇笔记主要介绍了如何使用STM32的ADC模块和片内温度传感器来测温。下面是相关的知识点： 一、ADC的单次与连续转换 * ADC的单次转换和连续转换是两种不同的工作模式...
沁恒CH32V30X学习笔记06-串口dma接收+空闲中断组合接收数据
02-18
"03usart dma idle v303"可能是本次学习笔记的源代码文件，包含了实现上述功能的具体代码示例。通过分析和学习这个文件，可以更直观地了解如何在CH32V30X上实现串口DMA和空闲中断的组合应用。 总之，利用串口的DMA...
stm32学习笔记：实验五ADC采集（DMA）电压串口屏显示
01-11
7. 代码实现：在C语言编程环境中，我们需要编写相应的初始化函数，如`init_ADCDMA()`、`init_UART()`，以及处理ADC转换完成中断的服务函数。在中断服务函数中，更新串口屏显示内容。 8. 实时性和精度：通过DMA与ADC...
STM32单片机ADC规则组多通道转换-DMA模式
chenxr的博客
11-11 7950
模数转换器（Analog To Digital Converter）简称ADC（也可以写成A/D），是指将连续变化的模拟信号转换为离散的数字信号的器件。 直接存储器存取技术（Direct Memory Access）简称DMA。DMA用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU干预，数据可以通过DMA快速地移动，这就节省CPU的资源可以做...
STM32 笔记 02：如何使用 CubeMX 配置 ADC 和 DMA，以使用多通道扫描的方式采集多路电压
zhrjyl的博客
04-20 2680
文章目录一. 前言二. CubeMX 配置1 . ADC 配置2. DMA 配置3. 时钟配置三. 主要代码1. 在 .h 中定义 ADC 控制类，以及相关宏2. 在 .c 中创建 ADC 控制类对象，并声明需要实现的方法3. 在 .c 中实现具体方法4. 在 .h 中声明全局变量和方法四. 功能测试1. 测试代码1.1 在 main 中调用初始化方法1.2 在 while 中输出电压值2. 测试效果五. 注意事项 一. 前言 测试时所使用的 MCU 是：STM32F103C8TX 测试时所使用的 Cub
STM32 CubeMX配置ADC+DMA进行FFT（1）
ANNOLRA的博客
07-29 8543
STM32 cubeMX配置ADC+DMA，计算采样率和ADC电压 最近，因为项目需要处理音频信号，对AD采集的音频信号进行FFT运算，记录一下学习过程。 主要内容： 1.ADC和DMA各配置有什么实际意义 2.配置好的ADC如何计算采样率和电压值 cubeMX配置ADC+DMA 这里我用的是STM32F407处理器，与其他的处理器思路大体一致 ADC配置 Mode是ADC工作模式 我们设置为independent mode（独立模式）因为只需要单独ADC使用，如果是多个ADC联合使用才需要更改。 Clo
STM32Cube教程系列 - ADCDMA篇
飞天小象的博客
11-09 2847
STM32Cube教程系列 - ADCDMA篇一、为什么要出这个教程？二、配置方法1.Cube配置ADC部分2.Cube配置DMA部分3.代码内容添加总结 一、为什么要出这个教程？ 之所以想着出这么一个教程，是希望帮助那些初学嵌入式同时又是以ST的硬件进行学习的小伙伴。大佬们直接忽视就好。因为最近身边老是有人问我Cube中这个该怎么选啊，那里又该怎么点，没办法公司嵌入式人员太少，好多没学过编程的为了维护老产品也被迫加入了写代码的行列。我们废话不多说直接开始。 二、配置方法 1.Cube配置ADC部分 第一步
CubeMX DMA+ADC输出
IoTEgr的博客
08-19 111
CubeMX DMA+ADC输出
STM32H750驱动ADC的一些知识与经验
weixin_42371603的博客
02-07 3193
STM32H750驱动ADC的一些知识与经验
STM32 ADC转换+DMA传输（详解）
热门推荐
sherlock_cp的博客
12-16 3万+
由定时器触发的ADC采样，并使用DMA总线大批量传输到内存，通过中断告知一轮传输完毕
msp430f5529学习笔记4ADC12
07-11
好的，我会为您提供关于 MSP430F5529 的 ADC12 学习笔记。 MSP430F5529 是德州仪器（Texas Instruments）公司推出的一款低功耗微控制器，它具有 12 位的模数转换器（ADC12）模块，可以用于采集模拟信号。 ADC12 模块具有多个配置选项和功能，下面是一些相关的学习笔记： 1. ADC12 基本配置：首先，您需要对 ADC12 进行基本的配置。这包括选择参考电压源、设置采样保持时间、选择转换时钟源等。可以通过配置控制寄存器（ADC12CTL0 和 ADC12CTL1）来完成这些设置。 2. 通道选择：ADC12 可以选择多个输入通道进行采样。您可以使用 ADC12MCTLx 寄存器来选择所需的输入通道，并进行相关的配置，如参考电压源、输入通道的输入方式（单端或差分）等。 3. 触发方式：ADC12 可以通过软件触发或外部触发进行转换。您可以使用 ADC12CTL0 寄存器来选择触发方式，并设置相应的触发源。 4. 转换结果：ADC12 转换后的结果可以通过 ADC12MEMx 寄存器进行读取。对于 12 位的转换结果，您可以直接读取 ADC12MEMx 寄存器的值。 5. 中断和DMA：ADC12 可以使用中断或 DMA 来处理转换完成后的结果。通过配置 ADC12CTL0、ADC12CTL1 和相关中断/ DMA 控制寄存器，您可以实现转换完成后的中断或 DMA 传输。 请注意，上述仅为一些基本的学习笔记，MSP430F5529 的 ADC12 模块还有更多高级功能和配置选项。您可以参考 MSP430F5529 的用户手册和相关文档，以深入了解 ADC12 模块的更多细节和应用。 希望这些笔记能对您有所帮助！如果您对其他问题感兴趣，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值