STM32读取24位模数转换（24bit ADC）芯片ADS1231数据

已于 2023-06-05 20:09:02 修改
阅读量3.4k 收藏 26
点赞数 1
分类专栏： STM32 文章标签： stm32 ADC 24-BIT ADS1231 24位
于 2023-05-29 13:41:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hwytree/article/details/130926002
版权
本文详细介绍了如何使用STM32微控制器读取24位模数转换器ADS1231的数据。文章涵盖了ADS1231的特性，如采样速率控制和低功耗模式，并提供了STM32与ADS1231的硬件连接图以及读取数据的时序控制代码。通过STM32CUBEIDE配置工程，实现了串口通信和微秒级延时函数，以支持10Hz和80Hz的输出测试。
摘要由CSDN通过智能技术生成

STM32读取24位模数转换（24bit ADC）芯片ADS1231数据

ADS1231是一款TI公司出品的24位ADC芯片，常用于与称重传感器配合实现体重计的应用。这里介绍STM32读取ADS1231的电路和代码实现。ADS1231的特点为通过硬件管脚可控制两种采样速率（10SPS和80SPS），及可以控制芯片上下电以实现低功耗过程控制。

ADS1231的内部原理如下图所示（固定128倍输入信号放大增益）：
在这里插入图片描述

STM32电路连接

ADS1231与STM32的连接关系设计如下图所示：
在这里插入图片描述
ADS1231的采样模拟接口可以工作在和数字接口不同的电压，如模拟供电 AVDD采用 5V，数字供电采用3.3V,从而与STM32的接口直接连接即可。

ADS1231测试电路

ADS1231典型的应用连接到惠斯通电桥，接收差分电压，由于内部已固定为128倍信号放大，所以对于5V供电（AVDD），最大检测差分电压范围为±20mV。需要注意输入差分信号有共模电压范围要求：
在这里插入图片描述
简单测试可以采用如下方式：
在这里插入图片描述
当可调电阻器为10欧姆时，IN+和IN-差分电压为(5/(4700+4700+10))*10 = 5.31mV。而IN-端电压为2.49734V，IN+端电压为2.50265V，共模和差模电压都在手册电气范围内，可以微调可调电位器的阻值，调整输出差模电压。

ADS1231访问协议

ADS1231可以通过硬件管脚SPEED控制采样速率, 及通过/PWRDONW管脚控制芯片上下电：
在这里插入图片描述
读取数据的时序则为：

  1. 检测nRDY管脚（也是Dout管脚）状态，如为低电平则可以读取数据，如为高电平则不能读取数据 ；
  2. 当数据可读取时， 发送24个时钟，并在每个时钟的下降沿获得采样数据的24位中的各个位，高位优先接收到
  3. 24个时钟之后，多发一个时钟，使得nRDY管脚回到输出高电平状态，在下一次数据可读取时，ADS1231会将信号拉低

STM32工程配置

这里采用STM32G031F8P6和STM32CUBEIDE开发环境，实现ADS1231的ADC数据读取。

首先配置基本工程和时钟系统：
在这里插入图片描述
在这里插入图片描述
配置UART2作为通讯口。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
配置与ADS1231连接的4个管脚：
在这里插入图片描述
保存并生成初始工程代码：
在这里插入图片描述

STM32工程代码

代码主要实现微秒级的时序控制，采用的微秒延时函数参考： STM32 HAL us delay（微秒延时）的指令延时实现方式及优化

测试逻辑采用以下方式:

  1. 串口收到0x01命令，进行10Hz输出测试
  2. 串口收到0x02命令，进行80Hz输出测试

main.c文件完整代码如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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.
  *
  ******************************************************************************
  */
//Written by Pegasus Yu in 2023
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

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

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

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
__IO float usDelayBase;
void PY_usDelayTest(void)
{
  __IO uint32_t firstms, secondms;
  __IO uint32_t counter = 0;

  firstms = HAL_GetTick()+1;
  secondms = firstms+1;

  while(uwTick!=firstms) ;

  while(uwTick!=secondms) counter++;

  usDelayBase = ((float)counter)/1000;
}

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

void PY_usDelayOptimize(void)
{
  __IO uint32_t firstms, secondms;
  __IO float coe = 1.0;

  firstms = HAL_GetTick();
  PY_Delay_us_t(1000000) ;
  secondms = HAL_GetTick();

  coe = ((float)1000)/(secondms-firstms);
  usDelayBase = coe*usDelayBase;
}


void PY_Delay_us(uint32_t Delay)
{
  __IO uint32_t delayReg;

  __IO uint32_t msNum = Delay/1000;
  __IO uint32_t usNum = (uint32_t)((Delay%1000)*usDelayBase);

  if(msNum>0) HAL_Delay(msNum);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define ads1231_rdy (HAL_GPIO_ReadPin(GPIOA,  GPIO_PIN_7)==0)?1:0

#define ads1231_clk_h HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_SET)
#define ads1231_clk_l HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_RESET)
#define ads1231_dout HAL_GPIO_ReadPin(GPIOA,  GPIO_PIN_7)

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
UART_HandleTypeDef huart2;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t cmd=0;
uint32_t ads1231_data;

uint32_t counter=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_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();

  //hardware reset of ADS1231
  HAL_GPIO_WritePin(ADS1231_nPDWN_GPIO_Port, ADS1231_nPDWN_Pin, GPIO_PIN_RESET);
  PY_Delay_us_t(1000000);
  HAL_GPIO_WritePin(ADS1231_nPDWN_GPIO_Port, ADS1231_nPDWN_Pin, GPIO_PIN_SET);

  __HAL_UART_CLEAR_FLAG(&huart2, UART_FLAG_RXNE);
  HAL_UART_Receive_IT(&huart2, (uint8_t *)&cmd, 1);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	  if(cmd==0x01) //10SPS
	  {
		  HAL_GPIO_WritePin(ADS1231_SPEED_GPIO_Port, ADS1231_SPEED_Pin, GPIO_PIN_RESET);

	      while(ads1231_rdy) PY_Delay_us_t(1);
	      while(!ads1231_rdy) PY_Delay_us_t(1);
	      ads1231_data = 0;
		  PY_Delay_us_t(1);

		  for(uint8_t i=1;i<=24;i++)
		  {
			  ads1231_clk_h;
			  PY_Delay_us_t(1);
			  ads1231_clk_l;
			  ads1231_data |=  (ads1231_dout<<(24-i));
			  PY_Delay_us_t(1);
		  }

		  ads1231_clk_h;
		  PY_Delay_us_t(1);
		  ads1231_clk_l;
		  PY_Delay_us_t(1);

	      HAL_UART_Transmit(&huart2, &ads1231_data, 3, 2700);

	      counter++;
	      if(counter%10==0) PY_Delay_us_t(1000000);
	  }

	  if(cmd==0x02) //80SPS
	  {
		  HAL_GPIO_WritePin(ADS1231_SPEED_GPIO_Port, ADS1231_SPEED_Pin, GPIO_PIN_SET);

	      while(ads1231_rdy) PY_Delay_us_t(1);
	      while(!ads1231_rdy) PY_Delay_us_t(1);
	      ads1231_data = 0;
		  PY_Delay_us_t(1);

		  for(uint8_t i=1;i<=24;i++)
		  {
			  ads1231_clk_h;
			  PY_Delay_us_t(1);
			  ads1231_clk_l;
			  ads1231_data |=  (ads1231_dout<<(24-i));
			  PY_Delay_us_t(1);
		  }

		  ads1231_clk_h;
		  PY_Delay_us_t(1);
		  ads1231_clk_l;
		  PY_Delay_us_t(1);

		  HAL_UART_Transmit(&huart2, &ads1231_data, 3, 2700);

	      counter++;
	      if(counter%80==0) PY_Delay_us_t(1000000);
	  }


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

  /** 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_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV1;
  RCC_OscInitStruct.PLL.PLLN = 8;
  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_DIV1;

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

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */

  /* USER CODE END USART2_Init 2 */

}

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

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, ADS1231_SPEED_Pin|ADS1231_SCK_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(ADS1231_nPDWN_GPIO_Port, ADS1231_nPDWN_Pin, GPIO_PIN_SET);

  /*Configure GPIO pins : ADS1231_SPEED_Pin ADS1231_nPDWN_Pin */
  GPIO_InitStruct.Pin = ADS1231_SPEED_Pin|ADS1231_nPDWN_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 pin : ADS1231_SCK_Pin */
  GPIO_InitStruct.Pin = ADS1231_SCK_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  HAL_GPIO_Init(ADS1231_SCK_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : ADS1231_nDRDY_DOUT_Pin */
  GPIO_InitStruct.Pin = ADS1231_nDRDY_DOUT_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(ADS1231_nDRDY_DOUT_GPIO_Port, &GPIO_InitStruct);

/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
	HAL_UART_Receive_IT(&huart2, (uint8_t *)&cmd, 1);
}
/* 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 */

代码实现十六进制数据输出，如果要切换为串口printf打印输出，可以参考：
STM32 UART串口printf函数应用及浮点打印代码空间节省 (HAL)

输出的24位数据为补码格式，进行绝对值提取时按照如下规则：
在这里插入图片描述

测试效果

串口命令0x01输出（间隔1秒输出10个采样值）：
在这里插入图片描述
串口命令0x02输出（间隔1秒输出80个采样值）：
在这里插入图片描述

例程下载

STM32G031F8P6-ADS1231例程

–End–

PegasusYu
关注
专栏目录
AD1256之STM32程序——STM32测试高精度ADC篇（四）
cherrymcu的博客
06-28 4万+
ADS1256是TI(TexasInstruments)公司推出的一款低噪声高分辨率的24位Sigma-Delta(E-v)模数转换器(ADC)。E-vADC与传统的逐次逼近型和积分型ADC相比有转换误差小而价格低廉的优点,但由于受带宽和有效采样率的限制,E-vADC不适用于高频数据采集的场合。该款ADS1256可适合于采集最高频率只有几千赫兹的模拟数据的系统中,数据输出速率最高可为30K采样点/秒(SPS),4路差分与8路伪差分输入,有完善的自校正和系统校正系统,SPI串行数据传输接口。本文结合笔者自己的
24位ADC芯片7190 STM32程序
04-25
24位ADC芯片7190 STM32F407程序 中断写的 24位ADC芯片7190 STM32F407程序 中断写的
1231
qq_39866776的博客
04-20 346
TI 【ads131m02】DSP TMS320F280049C调试与学习笔记
最新发布
在校计算机学生，知识分享与学习笔记总结，欢迎指点
07-18 1260
ADS131M02 是一款 two 通道、同步采样、24 位、ΔΣ 模数转换器 (ADC)，具有宽动态范围、低功耗和电能测量特定功能，因此非常适合电能计量、功率计量和断路器应用。 ADS131M02 同属于ADS131M0x系列，x代表通道位数，M02为2通道，M08为8通道。 DSP使用的也是TI的 TMS320F280049C，通讯方式为SPI
STC15系列内部SPI驱动24位ADC芯片ADS1256
08-06
利用STC15系列单片机内置SPI功能与24位ADS1256芯片通信。 TI公司的ADS1256芯片属Σ 一△型，可支持单端输入和拆分输入，8路通道采样 晶振选用7.80MHz，为佳，采样速度最好控制在2.5~10sps为佳 经过实际电压监测，误差可以减小到0.00001V之内 对适用于高精度监测仪器很有帮助！
24位ADC芯片AD7190讲解和代码编写（基于STM32模板的硬件软件SPI）
qq_43547520的博客
10-08 7143
ADC芯片AD7190应用
ADS1248/1247(TI) 24位ADC详细配置说明
热门推荐
weixin_43405473的博客
06-28 1万+
ADS1248是TI的一款 24位delta-sigma(ΔΣ) 、2KSPS、8通道（4通道差分）ADC芯片，通讯协议为SPI。可编程数据速率高达2ksps。低噪声PGA：48nVRMS在PGA=128。低漂移内部2.048-V参考值：10ppm/°C（最大值）。模拟电源：单极（2.7V至5.25V）和双极（±2.5V）工作。ADS1248/1247一共有15个寄存器，寄存器列表如下： 所以我们按照手册的方法来写： 我们先定义一个cmd的数组，然后将CS片选拉低，START置高，然后进行数据的拼接，在
STM32模拟SPI协议获取24位模数转换（24bit ADC）芯片AD7791电压采样数据
Pegasus的软件博客
02-20 5674
STM32大部分芯片只有12位的ADC采样性能，如果要实现更高精度的模数转换如24位ADC采样，则需要连接外部ADC实现。AD7791是亚德诺(ADI)半导体一款用于低功耗、24位Σ-Δ型模数转换器(ADC) ,适合低频测量应用，提供50 Hz/60 Hz同步抑制。这里介绍基于AD7791的24位ADC采样实现。
STM32F103C6T6-ADS1220.rar
02-24
STM32模拟SPI协议读取双通道24位模数转换（24bit ADC）芯片ADS1220数据例程。采用STM32CUBEIDE开发环境，以STM32F103C6T6为例的HAL库例程。ADS1220是TI(德州仪器)公司一款功能比较丰富的双路24位模数转换器(ADC) ,...
STM32G031F8P6-ADS1231.rar
05-29
STM32读取24位模数转换（24bit ADC）芯片ADS1231数据范例。采用STM32CUBEIDE开发环境的HAL库例程。以STM32G031F8P6为例，通过模拟协议进行采样数据读取。具体介绍见CSDN博文《STM32读取24位模数转换（24bit ADC）...
STM32F401CCU6-ADS1271.rar
06-16
STM32控制读取24位ADC芯片ADS1271例程，采用STM32CUBEIDE...具体介绍见CSDN博文《STM32 MCO+SPI获取24位模数转换（24bit ADC）高速芯片ADS1271采样数据》：https://blog.csdn.net/hwytree/article/details/131130670 。
24BIT高精度ADC
02-11
24BIT高精度ADC，双通道差分输入，内部可选择参考电压
高精密快速ADC(24bit/100ksps以上)
07-14
These are rapidly quick ADCs。It can be used instrument and industry。
ADS1256中文资料24位AD模块高精度ADC采集卡说明书
10-10
24位高精度AD采集卡，ADS1256的AD转化，带单片机和stm32程序，8路输入，标准电源处理模块，精度高，开发学习，测试转化的最好板块！
基于Delta-Alfa的24位ADC LTC2449数据手册
10-31
8通道(差分)或16通道(单端)输入的基于Delta-Alfa的高精度AD转换器。可用于微弱信号检测。
ADS1256 STM32程序
02-21
ADS1256是一款具有24位分辨率、内置PGA（可编程增益放大器）的高速ADC芯片，适用于需要高精度和高稳定性的应用场合。通过SPI（串行外设接口）协议与STM32连接，可以实现对模拟信号的精确采集和处理。 #### 硬件接口...
STM32 MCO+SPI获取24位模数转换（24bit ADC）高速芯片ADS1271采样数据
Pegasus的软件博客
06-19 7185
STM32大部分芯片只有12位的ADC采样性能，如果要实现更高精度的模数转换如24位ADC采样，则需要连接外部ADC实现。ADS1271是 TI公司一款高速24位Σ-Δ型模数转换器(ADC) ,数据率达到105K SPS, 即一秒可以采样105000次。这里介绍基于ADS1271的24位ADC采样实现。采用STM32CUBEIDE开发工具，以STM32F401CCU6为例。
STM32配置读取双路24位模数转换（24bit ADC）芯片CS1238数据
Pegasus的软件博客
02-13 5065
CS1238是一款国产双路24位ADC芯片，与CS1238对应的单路24位ADC芯片是CS1237，功能上相当于HX711和TM7711的组合。
vue-ueditor-wrap. 上传照片
09-13
对于使用vue-ueditor-wrap上传照片，你可以按照以下步骤进行操作： 1. 在你的Vue项目中安装vue-ueditor-wrap组件：可以通过npm或yarn进行安装，具体命令如下： ```bash npm install vue-ueditor-wrap --save # 或 yarn add vue-ueditor-wrap ``` 2. 在需要使用该组件的Vue文件中引入并注册该组件： ```javascript import VueUeditorWrap from 'vue-ueditor-wrap' export default { components: { VueUeditorWrap }, // ... } ``` 3. 在模板中使用vue-ueditor-wrap组件，并为其绑定一个v-model来处理上传的图片数据： ```html <template> <div> <vue-ueditor-wrap v-model="content" :config="editorConfig"></vue-ueditor-wrap> </div> </template> ``` 4. 在Vue实例中定义`content`和`editorConfig`变量，在`editorConfig`中配置上传图片的相关参数： ```javascript data() { return { content: '', // 绑定编辑器内容的变量 editorConfig: { // 其他配置项... serverUrl: '/your-upload-url' // 设置图片上传的接口地址 } } } ``` 在`serverUrl`中你需要设置一个服务器端的接口地址来处理图片上传请求，具体的接口实现需要根据你的后端技术栈来确定。 请注意，这只是一个简单的示例，你可能还需要根据自己的实际需求进行进一步的配置和处理。希望对你有所帮助！如有更多问题，请继续提问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PegasusYu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值