STM32存储左右互搏 I2C总线读写EEPROM ZD24C1MA

STM32存储左右互搏 I2C总线读写EEPROM ZD24C1MA

在较低容量存储领域，EEPROM是常用的存储介质，不同容量的EEPROM的地址对应位数不同，在发送字节的格式上有所区别。EEPROM是非快速访问存储，因为EEPROM按页进行组织，在连续操作模式，当跨页时访问地址不是跳到下一页到开始，而是跳到当前页的首地址，因此跨页时要重新指定起始地址。而在控制端发送写操作I2C数据后还需要有等待EEPROM内部操作完成的时间才能进行下一次操作。ZD24C1MA是1M bit / 128K Byte容量的EEPROM,ZD24C1MA的管脚定义为：
在这里插入图片描述
这里介绍STM32访问1Mbit EEPROM ZD24C1MA的例程。采用STM32CUBEIDE开发平台，以STM32F401CCU6芯片为例，通过STM32 I2C硬件电路实现读写操作，通过UART串口进行控制。

STM32工程配置

首先建立基本工程并设置时钟：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
配置硬件I2C接口：
在这里插入图片描述
在这里插入图片描述
配置UART1作为通讯串口：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
保存并生成初始工程代码：
在这里插入图片描述

STM32工程代码

这里的测试逻辑比较简单：
当串口收到指令0x01时向EEPROM 地址0写入预设的256个字节0x00~0xFF（不跨页），然后读出并通过串口打印出
当串口收到指令0x02时向EEPROM 地址600写入预设的256个字节0xFF~0x00（跨页），然后读出并通过串口打印出

ZD24C1MA的设备默认访问地址为0xA0， ZD24C1MA的存储单元地址访问略为特殊，17位地址分为两部分，最高位的1位放置于I2C设备默认访问地址的第1位，I2C设备默认访问地址第0位仍然为读写控制位，由于采用硬件I2C控制，库函数自行通过识别调用的是发送还是接收函数对第0位进行发送前设置，因此，不管是调用库函数的I2C写操作还是读操作，提供的地址相同。17位地址的低16位通过在发送设备地址后的作为跟随的第一，二个字节发送。

建立ZD24C1MA.h库头文件

#ifndef INC_ZD24C1MA_H_
#define INC_ZD24C1MA_H_

#include "main.h"

void PY_Delay_us_t(uint32_t Delay);
void ZD24C1MA_Read(uint32_t addr, uint8_t * data, uint32_t len);
void ZD24C1MA_Write(uint32_t addr, uint8_t * data, uint32_t len);

#endif

建立ZD24C1MA.c库源文件：


#include <string.h>
#include <ZD24C1MA.h>

#define Page_Size 256
#define Delay_Param 5
extern I2C_HandleTypeDef hi2c1;
extern uint8_t ZD24C1MA_Default_I2C_Addr ;


void ZD24C1MA_Read(uint32_t addr, uint8_t * data, uint32_t len)
{
	uint8_t ZD24C1MA_I2C_Addr;

	ZD24C1MA_I2C_Addr = ZD24C1MA_Default_I2C_Addr | ((addr>>16)<<1); //highest 1-bit access address placed into I2C address

	uint8_t RA[2];
	RA[0] = (addr & 0xFF00)>>8; //high 8-bit access address placed into I2C first data
	RA[1] =addr & 0x00FF; //low 8-bit access address placed into I2C first data

	HAL_I2C_Master_Transmit(&hi2c1, ZD24C1MA_I2C_Addr, &RA[0], 2, 2700); //Write address for read
	HAL_I2C_Master_Receive(&hi2c1, ZD24C1MA_I2C_Addr, data, len, 2700); //Read data

}

void ZD24C1MA_Write(uint32_t addr, uint8_t * data, uint32_t len)
{

	uint8_t ZD24C1MA_I2C_Addr;

	uint32_t addr_page = addr/Page_Size;
	uint32_t addr_index = addr%Page_Size;
	uint32_t TLEN;
    uint8_t TAD[Page_Size+2];
    uint32_t i=0;

    if(len<=(Page_Size-addr_index))
    {
    	TAD[0] = (addr & 0xFF00) >> 8;
    	TAD[1] = addr & 0x00FF ;
    	memcpy(TAD+2, data, len);

    	ZD24C1MA_I2C_Addr = ZD24C1MA_Default_I2C_Addr | ((addr>>16)<<1); //highest 1-bit access address placed into I2C address
    	HAL_I2C_Master_Transmit(&hi2c1, ZD24C1MA_I2C_Addr, TAD, len+2, 2700);  //Write data
    	PY_Delay_us_t(Delay_Param*1000);
    }
    else
    {
    	TAD[0] = (addr & 0xFF00) >> 8;
    	TAD[1] = addr & 0x00FF ;
    	memcpy(TAD+2, data, (Page_Size-addr_index));

    	ZD24C1MA_I2C_Addr = ZD24C1MA_Default_I2C_Addr | ((addr>>16)<<1); //highest 1-bit access address placed into I2C address
    	HAL_I2C_Master_Transmit(&hi2c1, ZD24C1MA_I2C_Addr, TAD, (Page_Size-addr_index)+2, 2700);  //Write data
    	PY_Delay_us_t(Delay_Param*1000);

    	TLEN = (len-(Page_Size-addr_index));
    	while( TLEN >= Page_Size )
    	{
    		addr_page += 1;

        	TAD[0] = ((addr_page*Page_Size) & 0xFF00 ) >> 8;
        	TAD[1] = (addr_page*Page_Size) & 0x00FF ;
        	memcpy(TAD+2, data + (Page_Size-addr_index) + i*Page_Size, Page_Size);

        	ZD24C1MA_I2C_Addr = ZD24C1MA_Default_I2C_Addr | (((addr_page*Page_Size)>>16)<<1); //highest 1-bit access address placed into I2C address
        	HAL_I2C_Master_Transmit(&hi2c1, ZD24C1MA_I2C_Addr, TAD, Page_Size+2, 2700);  //Write data
        	HAL_Delay(Delay_Param);

        	i++;
        	TLEN -= Page_Size;
        	PY_Delay_us_t(Delay_Param*1000);
    	}

    	if(TLEN>0)
    	{
    		addr_page += 1;

        	TAD[0] = ((addr_page*Page_Size) & 0xFF00 ) >> 8;
        	TAD[1] = (addr_page*Page_Size) & 0x00FF ;
        	memcpy(TAD+2, data + (Page_Size-addr_index) + i*Page_Size, TLEN);

        	ZD24C1MA_I2C_Addr = ZD24C1MA_Default_I2C_Addr | (((addr_page*Page_Size)>>16)<<1); //highest 1-bit access address placed into I2C address
        	HAL_I2C_Master_Transmit(&hi2c1, ZD24C1MA_I2C_Addr, TAD, TLEN+2, 2700);  //Write data
        	PY_Delay_us_t(Delay_Param*1000);
    	}


    }

}

完成的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>
#include <ZD24C1MA.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 */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

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_I2C1_Init(void);
static void MX_USART1_UART_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
uint8_t cmd=0;          //for status control
uint8_t * RData;        //USB rx data pointer
uint32_t RDataLen;      //USB rx data length
uint8_t * TData;        //USB tx data pointer
uint32_t TDataLen;      //USB tx data length

uint8_t ZD24C1MA_Default_I2C_Addr =  0xA0; //Pin A2=A1=0

uint32_t ZD24C1MA_Access_Addr = 0;   //ZD24C1MA access address (17-bit)

uint8_t testdata[256];

uint8_t URX;
/* 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_I2C1_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();

  HAL_UART_Receive_IT(&huart1, &URX, 1);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		if(cmd==1)
		{
			cmd=0;

			  for(uint32_t j=0; j<256; j++)
			  {
				   testdata[j] = j;
			  }

				ZD24C1MA_Access_Addr = 0;  //Set access address here
				ZD24C1MA_Write(ZD24C1MA_Access_Addr, testdata, 256); //Write data

				memset(testdata, 0, 256);

				ZD24C1MA_Read(ZD24C1MA_Access_Addr, testdata, 256); //Read data
				HAL_UART_Transmit(&huart1, testdata, 256, 2700);

		}

		if(cmd==2)
		{
			cmd=0;

			  for(uint32_t j=0; j<256; j++)
			  {
				   testdata[j] = 255-j;
			  }

				ZD24C1MA_Access_Addr = 600;  //Set access address here
				ZD24C1MA_Write(ZD24C1MA_Access_Addr, testdata, 256); //Write data

				memset(testdata, 0, 256);

				ZD24C1MA_Read(ZD24C1MA_Access_Addr, testdata, 256); //Read data
				HAL_UART_Transmit(&huart1, testdata, 256, 2700);
		}

		PY_Delay_us_t(100);
    /* 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_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE2);

  /** 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 = 25;
  RCC_OscInitStruct.PLL.PLLN = 336;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 7;
  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_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

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

/**
  * @brief I2C1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_I2C1_Init(void)
{

  /* USER CODE BEGIN I2C1_Init 0 */

  /* USER CODE END I2C1_Init 0 */

  /* USER CODE BEGIN I2C1_Init 1 */

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 400000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C1_Init 2 */

  /* USER CODE END I2C1_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;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_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_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

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

/* USER CODE BEGIN 4 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart1)
	{
      cmd = URX;
      HAL_UART_Receive_IT(&huart1, &URX, 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 */

STM32范例测试

上述范例的测试效果如下：
指令0x01不跨页写读：
在这里插入图片描述
指令0x02跨页写读：
在这里插入图片描述

STM32例程下载

STM32F401CCU6 I2C总线读写EEPROM ZD24C1MA例程

–End–

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/55409.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

一文搞懂Redis架构演化之路

一文搞懂Redis架构演化之路

目录 从最简单的开始&#xff1a;单机版 Redis 数据持久化&#xff1a;有备无患 主从复制&#xff1a;多副本 哨兵&#xff1a;故障自动切换 分片集群&#xff1a;横向扩展 总结 这篇文章我想和你聊一聊 Redis 的架构演化之路。 现如今 Redis 变得越来越流行&#xff0c;…
阅读更多...
图为科技加入深圳市智能交通行业协会 ，打 …

图为科技加入深圳市智能交通行业协会 ，打 …

图为科技加入深圳市智能交通行业协会&#xff0c;打造智能交通新生态&#xff01; 交通是国民经济发展的“大动脉”&#xff0c;交通拥堵、事故频发等问题不仅影响了人们的出行体验&#xff0c;也对经济的发展产生了负面影响。安全、高效、便捷的出行&#xff0c;一直是人们的…
阅读更多...
【Unity实用插件篇】| 学会使用 可编程瓦片Tile Map，快速搭建2D地图

【Unity实用插件篇】| 学会使用 可编程瓦片Tile Map，快速搭建2D地图

前言【Unity 实用插件篇】| 学会使用 可编程瓦片Tile Map，快速搭建2D地图一、导入 Tile Map Editor二、创建调色板 Tile Palette三、快速绘制地图四、TilePalette 调色板功能介绍五、TileMap 相关组件属性介绍GirdTilemapTilemap Renderer 瓦片地图渲染器Tile Assets 瓦片资源…
阅读更多...
【Git】分支管理策略

【Git】分支管理策略

文章目录 分支策略bug分支-master分支出现bug怎么办删除临时分⽀小结 分支策略 在实际开发中&#xff0c;我们应该按照⼏个基本原则进⾏分⽀管理&#xff1a; 1.master分⽀应该是⾮常稳定的&#xff0c;也就是仅⽤来发布新版本&#xff0c;平时不能在上⾯⼲活 2.⼲活都在dev…
阅读更多...
Reinforcement Learning with Code 【Code 2. Tabular Sarsa】

Reinforcement Learning with Code 【Code 2. Tabular Sarsa】

Reinforcement Learning with Code 【Code 2. Tabular Sarsa】 This note records how the author begin to learn RL. Both theoretical understanding and code practice are presented. Many material are referenced such as ZhaoShiyu’s Mathematical Foundation of Rei…
阅读更多...
Elasticsearch 全文检索 分词检索-Elasticsearch文章四

Elasticsearch 全文检索 分词检索-Elasticsearch文章四

文章目录 官方文档地址refercence文档全文搜索体系match简单查询match 多词/分词单字段分词match多个词的逻辑控制match的匹配精度match_pharse_prefix分词前缀方式match_bool_prefixmulti_match多字段匹配 query string类型Interval类型DSL查询之Term详解聚合查询之Bucket聚合…
阅读更多...
RTT（RT-Thread）线程管理（1.2W字详细讲解）

RTT（RT-Thread）线程管理（1.2W字详细讲解）

目录 RTT线程管理 线程管理特点 线程工作机制 线程控制块 线程属性 线程状态之间切换 线程相关操作 创建和删除线程 创建线程 删除线程 动态创建线程实例 启动线程 初始化和脱离线程 初始化线程 脱离线程 静态创建线程实例 线程辅助函数 获得当前线程 让出处…
阅读更多...
【LeetCode】446. 等差数列划分II -- 子序列

【LeetCode】446. 等差数列划分II -- 子序列

题目链接 文章目录 1. 思路讲解1.1 dp表的创建1.2 状态转移方程1.3 使用哈希表找到k1.4 初始化1.5 返回值1.6 该题坑爹的一点 2. 代码编写 1. 思路讲解 我们要知道以某个位置为结尾的子序列的数量&#xff0c;可以通过它的以上一位置的为结尾的子序列的数量得知&#xff0c;也…
阅读更多...
css3 hover border 流动效果

css3 hover border 流动效果

/* Hover 边线流动 */.hoverDrawLine {border: 0 !important;position: relative;border-radius: 5px;--border-color: #60daaa; } .hoverDrawLine::before, .hoverDrawLine::after {box-sizing: border-box;content: ;position: absolute;border: 2px solid transparent;borde…
阅读更多...
Linux第八章之进程概念

Linux第八章之进程概念

一、冯诺依曼体系结构 关于冯诺依曼&#xff0c;必须强调几点&#xff1a; 这里的存储器指的是内存不考虑缓存情况&#xff0c;这里的CPU能且只能对内存进行读写&#xff0c;不能访问外设(输入或输出设备)外设(输入或输出设备)要输入或者输出数据&#xff0c;也只能写入内存或…
阅读更多...
加强Web应用程序安全：防止SQL注入

加强Web应用程序安全：防止SQL注入

数据库在Web应用程序中存储和组织数据时起着至关重要的作用&#xff0c;它是存储用户信息、内容和其他应用程序数据的中央存储库。而数据库实现了高效的数据检索、操作和管理&#xff0c;使Web应用程序能够向用户提供动态和个性化的内容。然而&#xff0c;数据库和网络应用程序…
阅读更多...
SQL Developer中的Active Data Guard

SQL Developer中的Active Data Guard

这篇文章 Display Data Guard configuration in SQL Developer 中&#xff0c;用SQL Developer展示了多种ADG的拓扑。 今天自己也试了一下&#xff0c;还蛮简单的&#xff0c;其实最麻烦的部分在于搭建一个ADG环境。 假设我已有一个ADG环境&#xff0c;即最典型的环境&#x…
阅读更多...
简要介绍 | 生成模型的演进：从自编码器(AE)到变分自编码器(VAE)和生成对抗网络(GAN)，再到扩散模型

简要介绍 | 生成模型的演进：从自编码器(AE)到变分自编码器(VAE)和生成对抗网络(GAN)，再到扩散模型

注1：本文系“简要介绍”系列之一，仅从概念上对生成模型（包括AE, VAE, GAN，以及扩散模型）进行非常简要的介绍，不适合用于深入和详细的了解。 生成模型的演进：从自编码器(AE)到变分自编码器(VAE)和生成对抗网络(GAN)，再到扩散模型 一、背景介绍 生成模型在机器学习领域…
阅读更多...
数据结构 | 线性数据结构——双端队列

数据结构 | 线性数据结构——双端队列

目录 一、何谓双端队列 二、双端队列抽象数据类型 三、用Python实现双端队列 四、回文检测器 一、何谓双端队列 双端队列是与队列类似的有序集合。它有一前、一后两端&#xff0c;元素在其中保持自己的位置。与队列不同的是&#xff0c;双端队列对在哪一端添加和移除元素没…
阅读更多...
Flask-SocketIO

Flask-SocketIO

一、简介&#xff1a; Flask-SocketIO使Flask应用程序可以实现客户端和服务器之间的低延迟双向通信。客户端应用程序可以使用 Javascript、Python、C、Java和Swift中的任何SocketIO客户端库或任何其他兼容客户端来建立与服务器的永久连接。 二、安装&#xff1a; pip instal…
阅读更多...
《吐血整理》进阶系列教程-拿捏Fiddler抓包教程(18)-Fiddler如何接口测试，妈妈再也不担心我不会接口测试了

《吐血整理》进阶系列教程-拿捏Fiddler抓包教程(18)-Fiddler如何接口测试，妈妈再也不担心我不会接口测试了

1.简介 Fiddler最大的优势在于抓包&#xff0c;我们大部分使用的功能也在抓包的功能上&#xff0c;fiddler做接口测试也是非常方便的。 领导或者开发给你安排接口测试的工作任务&#xff0c;但是没有给你接口文档&#xff08;由于开发周期没有时间出接口文档&#xff09;&…
阅读更多...
【13】STM32·HAL库-正点原子SYSTEM文件夹 | SysTick工作原理、寄存器介绍 | printf函数使用、重定向

【13】STM32·HAL库-正点原子SYSTEM文件夹 | SysTick工作原理、寄存器介绍 | printf函数使用、重定向

目录 1.sys文件夹介绍&#xff08;掌握&#xff09;2.deley文件夹介绍&#xff08;掌握&#xff09;2.1deley文件夹函数简介2.2SysTick工作原理2.3SysTick寄存器介绍2.4delay_init()函数&#xff08;F1&#xff09;2.5delay_us()函数&#xff08;F1&#xff09;2.6delay_ms()函…
阅读更多...
这次，常温超导能否变为现实？

这次，常温超导能否变为现实？

关注科研和技术的朋友近几天应当都听到韩国研发常温超导材料的消息了&#xff0c;作为攻城狮的我自然也是非常感兴趣&#xff0c;经过一番思想斗争还是放下了手上的单片机&#xff0c;想要一看这个常温超导的究竟&#xff0c;毕竟印象之中之前已经搞过好几次乌龙了。常温超导要…
阅读更多...
el-table点击表格某一行添加到URL参数，访问带参URL加载表格内容并滚动到选中行位置 [Vue3] [Element-plus 2.3]

el-table点击表格某一行添加到URL参数，访问带参URL加载表格内容并滚动到选中行位置 [Vue3] [Element-plus 2.3]

写在最前 需求&#xff1a;有个表格列出了一些行数据&#xff0c;每个行数据点击后会加载出对应的详细数据&#xff0c;想要在点击了某一行后&#xff0c;能够将该点击反应到URL中&#xff0c;这样我复制这个URL发给其他人&#xff0c;他们打开时也能看到同样的行数据。 url会根…
阅读更多...
ABB机器人RAPID编程常用指令介绍1

ABB机器人RAPID编程常用指令介绍1

ABB机器人RAPID编程常用指令介绍1 1. 运动控制指令 AccSet 语法格式：AccSet Acc,Ramp; Acc：机器人加速度百分比（num），默认值为100，最小为20 Ramp：机器人加速度斜坡比例（num），默认值为100，最小为10 应用：当机器人运行速度改变时，对所产生的相应加速度进行限制，使…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站