单片机存储芯片 W25QXX、AT24C02

已于 2024-08-21 22:54:48 修改
阅读量415 收藏 17
点赞数 15
分类专栏： 兆易创新 STM32 文章标签： 单片机 嵌入式硬件
于 2024-08-21 21:55:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61973119/article/details/141401658
版权

一、FLASH W25QXX

(1) W25QXX芯片简介

        W25Q128是华邦公司推出的一款SPI接口的NOR Flash芯片，其存储空间为128Mbit，相当于16M字节。W25Q128V芯片是串行闪存，可以通过标准/两线/四线SPI控制。W25Q128一次最多可编程256个字节。页面可以按扇区擦除、块擦除、整个芯片擦除。

        W25Q128 的擦写周期多达 10W 次，具有 20 年的数据保存期限，支持电压为 2.7~3.6V，W25Q128 支持标准的 SPI，还支持双输出/四输出的 SPI，最大 SPI 时钟可以到 80Mhz（双输出时相当于 160Mhz，四输出时相当于 320M）。

W25Q128存储容量共128M-bit/ 16M-byte。

  • 1页 = 256bytes 
  • 1 扇区 = 16页
  • 1 块 = 16扇区

W25Q64存储容量共64M-bit/ 8M-byte。

  • 1页 = 256bytes 
  • 1 扇区 = 16页
  • 1 块 = 16扇区

(2) W25QXX芯片引脚说明

  1. 第1脚CS是SPI总线的片选使能接口，SPI总线支持在一条总线上连接多个芯片，为了区分当前通信的是哪个芯片，就为每个芯片连接一个独立的CS片选接口，单片机想和哪个芯片通信，就向哪个芯片的CS引脚输出低电平。
  2. 第2脚D0是SPI总线的数据输出接口。
  3. 第3脚WP是硬件写保护接口，当向此引脚输入低电平，芯片将禁止写入数据。反之，可正常写入数据。
  4. 第4脚GND是公共地。
  5. 第5脚DI是SPI总线的数据输入接口。
  6. 第6脚CLK是SPI总线的时钟输入接口。
  7. 第7脚HOLD是状态保持接口。当向此引脚输入低电平，芯片将禁止任何操作，当向此引脚输入高电平，可正常操作芯片。
  8. 第8脚VCC是电源供电接口，输入2.7-3.6V的电源。

(3) W25QXX芯片读错误原因

  1. 写数据之前Flash里面的数据不是0xFF就必须先擦除，然后才能写数据。擦除即将Flash里面的数据恢复为0xFF的过程。
  2. 上电后设备自动处于写禁用状态（Write Enable Latch, WEL为0，WEL是只读位）。在Page Program, Sector Erase, Block Erase, Chip Erase or Write Status Register instruction（页编程、区擦除、块擦除、芯片擦除或者写状态寄存器指令）之前必须先进行写使能指令。在编程、擦除、写状态寄存器指令完成后，WEL自动变成0。
  3. 　W25Q64BV是使用四线SPI兼容总线：串行时钟：（CLK），片选（CS），串行数据输入（DI），串行数据输出（DO）。标准SPI指令是MCU在CLK的上升沿使用DI输入引脚串行写指令，地址，数据到设备。在CLK的下降沿用DO输出引脚从设备读取数据或状态。

  4. W25Q128芯片第一次接收指令集的时候不会做出响应，所以在初始化时向芯片随便发送一个指令集（如0xFF），芯片才能正常响应。（针对部分单片机）

    spi_start();//读取ID前向芯片发送一个FF指令
    spi_swapByte(0xFF);
    spi_stop();
    w25q128_readID(&ID);//正常读取ID

  5. 配置SPI：SPI的工作模式配置为 0，即 CPOL = 0，CPHA = 0
  6. 写内存时需要注意Flash的一个要点，Flash编程只能将1写为0，而不能将0写成1，写1靠擦除。所以需要在写内存的时候将内存擦除，使用内存擦除指令擦除内存（擦除的最小单位是扇区），内存变为0xFF，然后再写内存。
  7. Flash的写的有个特性跟EEPROM一样，就是它的一页是256个Byte，也就是在写入的时候，一次最多可以写入256个字节的数据，超过了需要自行在代码中处理，一次最多编程256字节，写超的话会对当前页的前面数据进行覆盖。
  8. 写入完成之后必须要等待一定的时间，不然马上写入第二次写入会失败W25Q128_Wait_Busy();  //等待写入结束
  9. 芯片可以从当前位置读完整个芯片数据；芯片只能单页写，写之前内容需要被擦除；
  10. 写入数据程序进入硬件中断  可能是堆栈溢出，比如FReeRTOS里面每一个任务分配的空间是128BYTE,超过内存卡死

(4) STM32CubeMX配置SPI通信（HAL库）

        以stm32F407战舰版举例，由于战舰版和W25QXX芯片引脚已经连接完成，分别是PB3-PB5，使用cubemx配置SPI1时，但是软件会默认选择PA4-PA6复用SPI1,但是我们需要使用PB3-PB5怎么处理

硬件片选和软件片选的区别
所谓硬件片选指的是SPI本身具有片选信号，当我们通过SPI发送数据时，SPI外设自动拉低CS信号使能从机，发送完成后自动拉高CS信号释放从机，这个过程是不需要软件操作的。而软件片选则是需要使用GPIO作为片选信号，SPI在发送数据之前，需要先通过软件设置作为片选信号的GPIO输出低电平，发送完成之后再设置该GPIO输出高电平。一般选择软件片选。

(5) 写W25QXX驱动代码

二、FRAM MB85RC16

(1) MB85RC16芯片引脚介绍

(2) 单片机如何读多块MB85RC16

即，当主机和一个EEPROM通信时，从机地址为1010 000+WR，如果主机和多个EEPROM通信时，从机地址为1010 A2 A1 A0 + WR

(3) IIC时序分析

a. 从机地址

b. 写单个字节

c. 写一页

一页的大小是8K,写入字节长度超过8K,将会覆盖之前写入内容

d. 当前地址读

e. 指定地址读

(4) STM32CubeMX配置IIC通信（HAL库）

标准模式，100KHz时钟，7位地址

(5) MB85RC16驱动代码

#define MB85RC16_Default_I2C_Addr 0xA0


void MB85RC16_Write(uint32_t addr, uint8_t * data, uint32_t len)
{
	uint8_t MB85RC16_I2C_Addr;

	MB85RC16_I2C_Addr = MB85RC16_Default_I2C_Addr | ((addr>>8)<<1); //high 3-bit access address placed into I2C address

	uint8_t TD[len+1];
	TD[0] = addr & 0x00FF;  //low 8-bit access address placed into I2C first data

	memcpy(TD+1, data, len);
	HAL_I2C_Master_Transmit(&hi2c1, MB85RC16_I2C_Addr, TD, len+1, 2700);  //Write data
}

void MB85RC1M_Read(uint32_t addr, uint8_t * data, uint32_t len)
{
	uint8_t MB85RC16_I2C_Addr;

	MB85RC16_I2C_Addr = MB85RC16_Default_I2C_Addr | ((addr>>8)<<1); //high 3-bit access address placed into I2C address

	uint8_t RA[1];
	RA[0] = addr & 0x00FF;  //low 8-bit access address placed into I2C first data

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

}

三、AT24CXX

(1)引脚介绍

A0,A1,A2接到GND上，地址固定为0；SCL、SDA引脚内部为开漏输出，所以需接上拉电阻；WP引脚接GND，表示芯片可读可写。

(2) GD32F470使用IIC读写AT24C02

 iic.h

#ifndef __IIC_H
#define __IIC_H

#include "head.h"

#define I2C1_SPEED              400000
#define I2C1_SLAVE_ADDRESS7     0xA0
#define I2C_PAGE_SIZE           8

void i2c1_config(void);

#endif

iic.c

#include "iic.h"

void i2c1_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOF);/* enable GPIOF clock */
    rcu_periph_clock_enable(RCU_I2C1);/* enable I2C1 clock */

    gpio_af_set(GPIOF, GPIO_AF_4, GPIO_PIN_1);/* connect PF1 to I2C1_SCL */
    gpio_af_set(GPIOF, GPIO_AF_4, GPIO_PIN_0);/* connect PF0 to I2C1_SDA */
    gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_PULLUP,GPIO_PIN_0);
    gpio_output_options_set(GPIOF, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ,GPIO_PIN_0);
    gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_PULLUP,GPIO_PIN_1);
    gpio_output_options_set(GPIOF, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ,GPIO_PIN_1);
	
    gpio_mode_set(GPIOF, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE,GPIO_PIN_2);
    gpio_output_options_set(GPIOF, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,GPIO_PIN_2);
	gpio_bit_write(GPIOF,GPIO_PIN_2,RESET);//写使能
	
    rcu_periph_clock_enable(RCU_I2C1);/* enable I2C clock */
    i2c_clock_config(I2C1,I2C1_SPEED,I2C_DTCY_2);/* configure I2C clock */
    i2c_mode_addr_config(I2C1,I2C_I2CMODE_ENABLE,I2C_ADDFORMAT_7BITS,I2C1_SLAVE_ADDRESS7);/* configure I2C address */
    
    i2c_enable(I2C1);/* enable I2C1 */
    i2c_ack_config(I2C1,I2C_ACK_ENABLE);/* enable acknowledge */
}

eeprom.h

#ifndef __EEPROM_H
#define __EEPROM_H

#include "head.h"

#define EEP_FIRST_PAGE 0x00
#define I2C_OK         0
#define I2C_FAIL       1

/* I2C read and write functions */
uint8_t i2c_24c02_test(void);
/* initialize peripherals used by the I2C EEPROM driver */
void i2c_eeprom_init(void);
/* write buffer of data to the I2C EEPROM */
void eeprom_buffer_write(uint8_t *p_buffer, uint8_t write_address, uint16_t number_of_byte);
/* write one byte to the I2C EEPROM */
void eeprom_byte_write(uint8_t *p_buffer, uint8_t write_address);
/* write more than one byte to the EEPROM with a single write cycle */
void eeprom_page_write(uint8_t *p_buffer, uint8_t write_address, uint8_t number_of_byte);
/*  read data from the EEPROM */
void eeprom_buffer_read(uint8_t *p_buffer, uint8_t read_address, uint16_t number_of_byte);
/* wait for EEPROM standby state */
void eeprom_wait_standby_state(void);

#endif

eeprom.c

#include "eeprom.h"
#define EEPROM_BLOCK0_ADDRESS    0xA0
#define BUFFER_SIZE              256
uint16_t eeprom_address;

/*!
    \brief      I2C read and write functions
    \param[in]  none
    \param[out] none
    \retval     I2C_OK or I2C_FAIL 
*/
uint8_t i2c_24c02_test(void)
{
    uint16_t i;
    uint8_t i2c_buffer_write[BUFFER_SIZE];
    uint8_t i2c_buffer_read[BUFFER_SIZE];
    
    for(i = 0;i < BUFFER_SIZE;i++){ i2c_buffer_write[i]=i;}
    eeprom_buffer_write(i2c_buffer_write,EEP_FIRST_PAGE, BUFFER_SIZE); 

    eeprom_buffer_read(i2c_buffer_read,EEP_FIRST_PAGE, BUFFER_SIZE); 
    for(i = 0;i < BUFFER_SIZE;i++){printf("0x%02X ", i2c_buffer_read[i]);}
	
    return I2C_OK;
}
void i2c_eeprom_init(void)
{
    eeprom_address = EEPROM_BLOCK0_ADDRESS;
}

void eeprom_buffer_write(uint8_t* p_buffer, uint8_t write_address, uint16_t number_of_byte)
{
    uint8_t number_of_page = 0, number_of_single = 0, address = 0, count = 0;
    
    address = write_address % I2C_PAGE_SIZE;
    count = I2C_PAGE_SIZE - address;
    number_of_page =  number_of_byte / I2C_PAGE_SIZE;
    number_of_single = number_of_byte % I2C_PAGE_SIZE;
    
    /* if write_address is I2C_PAGE_SIZE aligned  */
    if(0 == address){
        while(number_of_page--){
            eeprom_page_write(p_buffer, write_address, I2C_PAGE_SIZE); 
            eeprom_wait_standby_state();
            write_address +=  I2C_PAGE_SIZE;
            p_buffer += I2C_PAGE_SIZE;
        }
        if(0 != number_of_single){
            eeprom_page_write(p_buffer, write_address, number_of_single);
            eeprom_wait_standby_state();
        }      
    }else{
       /* if write_address is not I2C_PAGE_SIZE aligned */
        if(number_of_byte < count){ 
            eeprom_page_write(p_buffer, write_address, number_of_byte);
            eeprom_wait_standby_state();
        }else{
            number_of_byte -= count;
            number_of_page =  number_of_byte / I2C_PAGE_SIZE;
            number_of_single = number_of_byte % I2C_PAGE_SIZE;
            
            if(0 != count){
                eeprom_page_write(p_buffer, write_address, count);
                eeprom_wait_standby_state();
                write_address += count;
                p_buffer += count;
            } 
            /* write page */
            while(number_of_page--){
                eeprom_page_write(p_buffer, write_address, I2C_PAGE_SIZE);
                eeprom_wait_standby_state();
                write_address +=  I2C_PAGE_SIZE;
                p_buffer += I2C_PAGE_SIZE;
            }
            /* write single */
            if(0 != number_of_single){
                eeprom_page_write(p_buffer, write_address, number_of_single); 
                eeprom_wait_standby_state();
            }
        }
    }  
}

void eeprom_byte_write(uint8_t* p_buffer, uint8_t write_address)
{
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C1, I2C_FLAG_I2CBSY));

    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C1);
    
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_SBSEND));
    
	/* send slave address to I2C bus */
    i2c_master_addressing(I2C1, eeprom_address, I2C_TRANSMITTER);
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    
    /* clear the ADDSEND bit */
    i2c_flag_clear(I2C1,I2C_FLAG_ADDSEND);
    
    /* wait until the transmit data buffer is empty */
    while(SET != i2c_flag_get(I2C1, I2C_FLAG_TBE));
    
    /* send the EEPROM's internal address to write to : only one byte address */
	i2c_data_transmit(I2C1, 0x00);
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    i2c_data_transmit(I2C1, write_address);
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
   
    /* send the byte to be written */
    i2c_data_transmit(I2C1, *p_buffer); 
    
    /* wait until BTC bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));

    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C1);
    
    /* wait until the stop condition is finished */
    while(I2C_CTL0(I2C1)&I2C_CTL0_STOP);
}

void eeprom_page_write(uint8_t* p_buffer, uint8_t write_address, uint8_t number_of_byte)
{
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C1, I2C_FLAG_I2CBSY));
    
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C1);
    
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_SBSEND));
    
	/* send slave address to I2C bus */
    i2c_master_addressing(I2C1, eeprom_address, I2C_TRANSMITTER);
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    
    /* clear the ADDSEND bit */
    i2c_flag_clear(I2C1,I2C_FLAG_ADDSEND);
    
    /* wait until the transmit data buffer is empty */
    while( SET != i2c_flag_get(I2C1, I2C_FLAG_TBE));
    /* send the EEPROM's internal address to write to : only one byte address */
	i2c_data_transmit(I2C1, 0x00);
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    i2c_data_transmit(I2C1, write_address);
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    
    /* while there is data to be written */
    while(number_of_byte--){  
        i2c_data_transmit(I2C1, *p_buffer);
        
        /* point to the next byte to be written */
        p_buffer++; 
        
        /* wait until BTC bit is set */
        while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    }
    /* send a stop condition to I2C bus */
    i2c_stop_on_bus(I2C1);
    
    /* wait until the stop condition is finished */
    while(I2C_CTL0(I2C1)&I2C_CTL0_STOP);
}

void eeprom_buffer_read(uint8_t* p_buffer, uint8_t read_address, uint16_t number_of_byte)
{  
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C1, I2C_FLAG_I2CBSY));

    if(2 == number_of_byte){
        i2c_ackpos_config(I2C1,I2C_ACKPOS_NEXT);
    }
    
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C1);
    
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_SBSEND));
    
	/* send slave address to I2C bus */
    i2c_master_addressing(I2C1, eeprom_address, I2C_TRANSMITTER);
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    
    /* clear the ADDSEND bit */
    i2c_flag_clear(I2C1,I2C_FLAG_ADDSEND);
    
    /* wait until the transmit data buffer is empty */
    while(SET != i2c_flag_get( I2C1 , I2C_FLAG_TBE));

    /* enable I2C1*/
    i2c_enable(I2C1);
    
    /* send the EEPROM's internal address to write to */
	i2c_data_transmit(I2C1, 0x00);  
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    i2c_data_transmit(I2C1, read_address);  
    while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
    
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C1);
    
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_SBSEND));
    
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C1, eeprom_address, I2C_RECEIVER);

    if(number_of_byte < 3){
        /* disable acknowledge */
        i2c_ack_config(I2C1,I2C_ACK_DISABLE);
    }
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C1, I2C_FLAG_ADDSEND));
    
    /* clear the ADDSEND bit */
    i2c_flag_clear(I2C1,I2C_FLAG_ADDSEND);
    
    if(1 == number_of_byte){
        /* send a stop condition to I2C bus */
        i2c_stop_on_bus(I2C1);
    }
    
    /* while there is data to be read */
    while(number_of_byte){
        if(3 == number_of_byte){
            /* wait until BTC bit is set */
            while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));

            /* disable acknowledge */
            i2c_ack_config(I2C1,I2C_ACK_DISABLE);
        }
        if(2 == number_of_byte){
            /* wait until BTC bit is set */
            while(!i2c_flag_get(I2C1, I2C_FLAG_BTC));
            
            /* send a stop condition to I2C bus */
            i2c_stop_on_bus(I2C1);
        }
       /* wait until the RBNE bit is set and clear it */
        if(i2c_flag_get(I2C1, I2C_FLAG_RBNE)){
            /* read a byte from the EEPROM */
            *p_buffer = i2c_data_receive(I2C1);
            
            /* point to the next location where the byte read will be saved */
            p_buffer++; 
            
            /* decrement the read bytes counter */
            number_of_byte--;
        } 
    }
    
    /* wait until the stop condition is finished */
    while(I2C_CTL0(I2C1)&I2C_CTL0_STOP);
    /* enable acknowledge */
    i2c_ack_config(I2C1,I2C_ACK_ENABLE);

    i2c_ackpos_config(I2C1,I2C_ACKPOS_CURRENT);
}

void eeprom_wait_standby_state(void)
{
    __IO uint32_t val = 0;
    
    while(1){
        /* wait until I2C bus is idle */
        while(i2c_flag_get(I2C1, I2C_FLAG_I2CBSY));
        
        /* send a start condition to I2C bus */
        i2c_start_on_bus(I2C1);
        
        /* wait until SBSEND bit is set */
        while(!i2c_flag_get(I2C1, I2C_FLAG_SBSEND));
        
        /* send slave address to I2C bus */
        i2c_master_addressing(I2C1, eeprom_address, I2C_TRANSMITTER);
        
        /* keep looping till the Address is acknowledged or the AE flag is set (address not acknowledged at time) */
        do{
            /* get the current value of the I2C_STAT0 register */
            val = I2C_STAT0(I2C1);
            
        }while(0 == (val & (I2C_STAT0_ADDSEND | I2C_STAT0_AERR)));
        /* check if the ADDSEND flag has been set */
        if(val & I2C_STAT0_ADDSEND){
            
            /* clear ADDSEND flag */
            i2c_flag_clear(I2C1,I2C_FLAG_ADDSEND);
            
            /* send a stop condition to I2C bus */
            i2c_stop_on_bus(I2C1);
            
            /* exit the function */
            return ;
        } else {
            /* clear the bit of AERR */
            i2c_flag_clear(I2C1, I2C_FLAG_AERR);
        }
        
        /* send a stop condition to I2C bus */
        i2c_stop_on_bus(I2C1);
        /* wait until the stop condition is finished */
        while(I2C_CTL0(I2C1)&I2C_CTL0_STOP);
    }
}

四、总结

EEPROM和FLASH区别

相同点：

  1. 非易失性：两者都可以在没有电源的情况下保存数据。
  2. 电可擦除：都可以通过电信号擦除和重新编程。
  3. 用途：两者都用于存储固件、配置数据等。

不同点：

  1. 擦除单位：

    • EEPROM：可以逐个字节擦除和写入。
    • Flash：通常以块（通常是数KB到数MB）的方式擦除，不能逐个字节擦除。

  2. 写入速度：

    • EEPROM：写入速度相对较慢，通常是字节级写入。
    • Flash：写入速度较快，可以在一个块中并行写入。

  3. 使用寿命：

    • EEPROM：通常具有更高的擦写耐久性，通常为10万次擦写。
    • Flash：擦写次数一般较少，通常为1万到10万次，但近年来的发展使得一些Flash类型的耐久性有所提高。

  4. 成本和密度：

    • EEPROM：相对较贵，存储密度较低。
    • Flash：更便宜，存储密度更高，因此在大容量存储解决方案中更受欢迎。

  5. 应用场景：

    • EEPROM：常用于需要频繁更新的小规模数据，典型应用包括配置存储、校准数据等。
    • Flash：被广泛用于USB闪存驱动器、SD卡、固态硬盘（SSD）等大容量存储设备。
m0_61973119
关注
  • 15
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
W25qxx(STM32 SPI HAL库).rar
06-20
在本文中，我们将深入探讨如何使用STM32的HAL库来驱动W25QXX系列的SPI闪存芯片，特别是W25Q64、W25Q128和W25Q512。...通过理解这些概念和实现细节，开发者可以有效地在STM32平台上利用这些存储芯片进行数据持久化。
STM32H7 OCTOSPI驱动W25qxx （可开启内存映射，程序可在w25qxx学习内运行）
01-21
对于STM32H7B0VBT6这个特定的芯片，它的内存映射功能强大，可以有效地利用W25qxx的大容量存储。通过内存映射，程序可以直接运行在外部存储器上，这对于执行大型代码或需要扩展程序存储空间的应用非常有利。 最后，...
片外FLASH(W25Q)和EEPROM(AT24c02)比较
qq_36314279的博客
06-18 5169
FLASH 待更新
51单片机I2C通信（AT24C02）
weixin_69561921的博客
07-09 1737
本篇介绍的是以51单片机开发板上的AT24C02存储芯片为例的I2C通信，文中大量篇幅会倾向于介绍I2C的通信协议，逻辑时序和开发方法。先来简短地介绍下存储器，存储器主要分为两类：易失性存储器（RAM）和非易失性存储器（ROM），也就是存储器中的数据掉电丢失和掉电不丢失的区别。RAM的读写速度要远大于ROM，容量较小且成本昂贵，典型的如单片机的内存，手机内存电脑内存等。
Winbond W25QXX SPI Flash使用笔记
热门推荐
欢迎光临
07-20 3万+
相较于EEPROM而言，SPI Flash的存储空间简直就是打开了一个新世界。以W25Q16为例，16Mb也就是2MB的空间，是AT24C08芯片的1KB空间的2048倍，价格也没有相差很多。同时使用SPI总线可以实现更高的读写速度，W25Qxx的SPI总线可以达到80MHz，这是IIC总线望尘莫及的，而且我比较喜欢用的STM32单片机的IIC总线总是让人那么揪心，所以我一直都是用的软件模拟IIC...
stm32入门-----W25Q64存储器
m0_73633088的博客
08-06 1152
​本期我们就来学习W25Q64存储器的相关知识点，W25Qxx系列的存储器是使用SPI通讯方式来进行数据传输的，在我们学习51单片机的时候也学习过类似的存储器芯片也就是AT24C02，这两者都是属于外接的存储器，可以保证掉电不丢失很好的存储数据（Flash闪存），下面就一起来看看吧（视频：[11-2] W25Q64简介_哔哩哔哩_bilibili） ​
你必须知道的单片机存储器的那些事！
果果小师弟的博客
01-11 3068
摘要：在单片机开发板上或者是核心板上通常会看到除了MCU之外的的芯片—EEPROM和FLASH，一般是AT24CXX、W25QXX这两颗芯片。但在利用单片机做一些项目的时候，比如做一个小车，驱动一些外设、显示一些温湿度信息等，却发现一般没有用到这些芯片。在做一些显示的时候却会用到。他们与单片机之间的通信方式就是IIC和SPI通信，在单片机的开发中用到的非常多。很多小伙伴就会说了，用OLED来显示一些数据，IIC通信直接用别人的代码，驱动SD卡或者NRF24L01直接拿别人的SPI代码就可以啊，难道我还自己去
W25Q256被写保护如何修改
03-02 2685
W25Q256被写保护如何修改
【STM32】软件SPI读写W25Q64芯片
weixin_63135906的博客
02-18 2441
W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储字库存储固件程序存储等场景存储介质：Nor Flash（闪存）时钟频率：80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)存储容量（24位地址）：在51单片机中学过一款比较经典的存储芯片AT24C02（I2C通信协议），蓝桥杯嵌入式板子上用的也是AT24C02（I2C通信协议），容量一般是kb级别的。
firefly-rk3288开发板Linux驱动——W25Q32 SPI驱动
分享嵌入式Linux技术知识
09-08 1750
一、Linux SPI驱动框架   Linux下的spi驱动和i2c驱动十分类似，也可以分为三个部分：SPI核心，spi主机控制器（i2c中叫做i2c适配器），spi设备。 1.spi核心   spi核心提供了主机控制器的注册与注销方法、spi设备注册与注销方法、以及spi通信方法。源码位置位于kernel/drivers/spi/spi.c 2.spi主机控制器   spi的主机控制器用spi_master结构体描述： //有部分删减 struc
关于W25QXX系列的FLASH
weixin_47171809的博客
08-11 507
制造/器件ID和 JEDEC ID的执行过程及时序图是一样的。“读制造/器件号”指令不同于“释放掉电/器件ID指令”，“读制造/器件号”指令读出的数据包含JEDEC标准制造号和特殊器件ID号。先把/CS引脚拉低，然后把指令90h通过引脚DIO送到芯片，然后接着把24位地址000000h送到芯片，然后芯片会先后把“生产D”和“器件D”通过DO引脚在CLK的上升沿发送出去。如果把24位地址写为000001h，ID号的发送顺序会颠倒，即先发“器件 ID”后发“生产ID”。ID号都是8位数据。
W25Qxx全系列数据手册(超详细)
10-14
W25Qxx系列就是一款常见的SPI接口Flash芯片，由旺宏电子（Winbond）生产，适用于各种需要非易失性存储的应用场景。本篇将深入探讨这一系列产品的特性和应用。 首先，W25Qxx系列涵盖多种容量，包括W25Q80（8MB）、...
W25QXX系列W25Q128 SPI_Flash存储模块驱动C源码.zip
03-14
W25QXX系列W25Q128 SPI_Flash存储模块驱动C源码： //初始化SPI FLASH void W25QXX_Init(void) { RCC->APB2ENR|=1; //PORTB时钟使能 GPIOB->CRH&=0XFFF0FFFF; GPIOB->CRH|=0X00030000; //PB12推挽输出 ...
w25qxx.zip
08-13
W25Qxx系列是旺宏电子（Winbond）推出的一系列串行闪存芯片，包括W25Q80、W25Q16、W25Q32等不同容量的型号。这些芯片主要通过SPI（Serial Peripheral Interface）接口与MCU进行通信，提供高容量的数据存储解决方案。...
模电实验3 - 单电源集成运放交流耦合放大器
硬禾科技的博客
08-15 797
掌握交流耦合单电源集成运放放大器的测试方法。
单片机学习笔记概述
最新发布
probably121的博客
08-20 517
由于其体积小、成本低、功耗低、易于编程和扩展等优点，单片机被广泛应用于各种嵌入式系统中，如家用电器、工业控制、仪器仪表、汽车电子等领域。1.汇编语言编程：汇编语言是单片机编程的基础，它可以直接操作单片机的硬件资源，实现对单片机的控制。单片机可以实现对各种物理量的测量、显示和处理。1.程序无法下载到单片机：检查单片机与编程器的连接是否正常，检查编程器的配置是否正确，检查单片机的电源电压是否正常。4.传感器数据不准确：检查传感器的安装位置是否正确，检查传感器的电源电压是否正常，检查传感器的信号线是否受到干扰。
GPT4o编写步进电机控制代码
zd845101500的博客
08-14 723
基于STM32F407 HAL库，写一个步进电机控制程序，需要控制8个步进电机，我会给出描述步进电机的结构体变量，基于这些变量需要你做出以下功能，电机脉冲通过定时器中断翻转脉冲引脚的电平实现，零点位置在最小限位和最大限位中间，运行的距离根据脉冲数而定。要能够实现多个电机同时运行动作，给我一份完整的程序，C文件和H文件，包括8路电机参数、定时器和引脚的初始化，total_steps这个变量表示电机最大能够运行的步数，在复位或者其他动作时，如果运行超过这个步数还是没有接收到限位传感器信号则立即停止电机。
什么是GD32 MCU读保护？
聚沃科技&GD32 MCU开发者社区
08-18 403
这时候有小伙伴就会问了，那既然读保护状态可以解除，别人拿到我的芯片，先解除保护，再读出来不就可以了？实际上这个问题完全不用担心，当MCU被加读保护后，MCU内部同时也给Flash上的数据增加了一个“自毁装置”，当有人对芯片进行解保护操作的时候，这个“自毁装置”就会将Flash上所有的数据都清空，这时候从芯片读出来的数据就是没有用的“空”数据啦。所以加读保护和解除读保护的操作就很好理解了，实际上就是对选项字节进行操作，将0x1fff f800地址的值设置为保护值/非保护值就可以了。
W25QXX 存储芯片
05-09
W25QXX 是一种串行闪存存储芯片，由Winbond生产。它有多种型号，如W25Q16、W25Q32、W25Q64等，存储容量从16Mb到64Mb不等。它采用SPI接口进行通讯，具有快速访问、高速传输、低功耗等特点。W25QXX广泛应用于嵌入式系统中，如智能家居、工业控制等领域，用于存储程序代码、配置信息、日志等数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值