精华内容
下载资源
问答
  • W25Q32 PDF

    2015-11-28 12:26:10
    W25Q32 PDF数据手册 winbind
  • 资源为W25Q32HVSNIQ的中文数据手册 文件名w25q32jv revh 01072019 plus
  • 1. W25Q80 (8M-bit)、W25Q16 (16M-bit)和W25Q32 (32M-bit)串行闪存为空间、引脚和电源有限的系统提供了存储解决方案。25Q系列提供的灵活性和性能远远超过普通的串行闪存设备。他们是理想的代码隐藏到RAM,执行代码...
  • 华邦flash数据手册w25q32fv
  • w25q32jv spi revf 05112017.pdf
  • W25Q32JVSSIQ-cn.pdf

    2020-10-15 16:28:45
    W25Q32JV (32M-bit)串行闪存为有限空间、引脚和电源的系统提供了存储解决方案。25Q系列提供的灵活性和性能远远超过普通的串行闪存设备。 他们是理想的代码隐藏到RAM,执行代码直接从双/四SPI (XIP)和存储声音,文本...
  • W25Q32FVSSIG详细手册

    2018-05-23 20:21:18
    W25Q32的详细手册,完整英文版本。该芯片最大支持104MHz的时钟,供电电压范围在2.7~3.6V,SPI的片选信号CS低有效,在操作芯片的时候,需要将/WP和/HOLD管脚接电源。 发送地址或数据到设备时,MOSI管脚数据采样在CLK...
  • W25Q32共32M-bit(4MB字节),它可划分为64块,每块64KB;每块又可划分为16个扇区,每个扇区4KB;每个扇区又可划分16页,每页256B。 本文档详细讲解了其内部存储结构,从字节地址、页地址、扇区地址和块地址详细介绍...
  • winbond W25Q32BV datasheet

    2011-08-02 17:49:54
    winbond W25Q32BV datasheet 英文版
  • W25Q32的使用

    千次阅读 2015-06-04 10:06:00
    一、W25Q32简介  W25Q32是华邦公司推出的大容量“SPI FLASH” 产品。 1、容量 32M-Bit/4M-byte(4,194,304) 2、存储结构 页:256-bytes 扇区:4K-bytes 块:64K_bytes 是故: 页:16384个 扇区...

    一、W25Q32简介

      W25Q32是华邦公司推出的大容量“SPI  FLASH” 产品。

    1、容量

    • 32M-Bit/4M-byte(4,194,304)

    2、存储结构

    • 页:256-bytes
    • 扇区:4K-bytes
    • 块:64K_bytes

    是故:

    • 页:16384个
    • 扇区:1024个
    • 块:64个

    3、速度

    • 时钟速度最高:80MHz

    4、特性

    • 擦除、写次数:高达100,000次
    • 数据保存时间:20年

    二、指令表

    三、操作注意

    1、页为编程单位,可以一次性编程1个到256个字节;超过256个字节肯定要分多次写入

    2、在编程之前,必须对对应的区域进行擦除操作,否则有可能写入错误。

    3、擦除的最小单位是“扇区”,也可以以“块”为单位进行擦除(此时块可以为32K-bytes 或者 64K-bytes),最大可以整块擦除。

    4、读操作比编程操作容易的多,没有以上的细节考虑。可以一次性读一个字节,也可以多个字节,甚至从头读到尾。

     

    参考资料:

         《W25Q32 Datasheet》  

          STM32驱动W25X64存储器

    展开全文
  • 华邦存储器W25Q80, W25Q16, W25Q32系列与stm32f1系列单片机的spi通讯 2020.4.9 spi通讯在配置好之后一定要开启spi使能,和串口的配置是一样的 2020.4.13 华邦存储器的spi通讯调试完成。 总结,在调试的过程中出现了...

    华邦存储器W25Q80, W25Q16, W25Q32系列与stm32f1系列单片机的spi通讯

    2020.4.9 spi通讯在配置好之后一定要开启spi使能,和串口的配置是一样的
    2020.4.13 华邦存储器的spi通讯调试完成。
    总结,在调试的过程中出现了两次大的问题,第一次是没法得到读到的数据,因此也无法确定写入是否正确,这个过程直如摸瞎。第二次是可以读数据了,但读回来的三个数据中第一个数有问题,但是用示波器看读入数据的波形,是正确的,但第一个数就是有问题。
    第一个问题,当我遇到这个问题的时候,真的是一次次对比了华邦存储器手册的读写操作,又到网上搜索了相关的资料,然后又检查了自己配置的spi参数。先是发现自己gpio引脚配置有问题,只需把引脚设置成复用引脚就好了,不用开启复用时钟。然后又是发现spi未启动,于是使能spi外设。等配置好了引脚之后,又配置spi的相关参数,波特率分频,软片选,时钟采集设置(当开始传输时,是上升沿还是下降沿采集数据),时钟极性设置(不传输时时钟是高电平还是低电平)。都设置好了,我再开始写入数据,先从简单的开始,读取状态寄存器的值,这个读到了,确定可以写入数据并且可以收到数据了。然后开始读取某个存储地址的值。从这个时候开始就进入第二个困难了。
    我发现读出的数据一点都不对,于是我开始检查我写入的数据是不是存在什么问题,一步一步的来,结合网上搜索到的资料程序(最后发现有些地方是对的,有些地方是错的),然后纠正,写使能之后要读状态寄存器判断是否可以写入操作了,整个写完动作完成后(片选引脚被拉高),还有读状态寄存器的值,看看是否busy(busy为0,则写操作完成)。擦除操作也是完成之后要判断状态寄存器中的busy位是否为0,,等我把这些判断操作加入好了之后,发现读回来的数,第一个数始终有问题。
    我开始使用示波器观察波形,发现正确的数据是回来了,波形正确,,但单片机在读的时候就出现了错误,而且只是第一个数据出错。在这个地方被困了两天,最后查资料,查到单片机上的spi->DR
    寄存器,有可能是dr寄存器没有为空的时候就有数据进来了,突然想到网上搜的华邦存储器的程序中出现过一段这样的代码,说是写数据的子程序中,将数据给到spi->DR寄存器之后,有一个“接收缓冲器非空”的判断,然后我把这段代码加入到我自己的写入数据的子程序中,然后就可以正确读出数据了。就这样一个鬼过程。。。
    然后当我吃完午饭之后再回来想多做几次测试时发现,读回来的数据中,第一个又变成0xff了,我这才发现我上午的在写操作后面加的那句接收缓冲器非空的判断,不是根本原因。我又开始找问题在哪里,我想问题应该就是SPi->DR寄存器,,,我想起了一句话,DR寄存器在使用的时候要先读一次数据将DR寄存器清空,这样才能使用DR寄存器,于是我新建了一个变量,用来在读数据的时候,先将DR里的数据读出来以清空DR寄存器,果然,立竿见影的效果,现在完全可以了。

    展开全文
  • Android下使用W25Q32

    千次阅读 2016-06-14 14:35:08
    刚开始是想着自己写spi驱动,操作W25Q32的寄存器,本来已经读到芯片的ID了,后来因为cs脚的原因,以为自己写的程序有问题,转而找其他的方法,发现linux驱动中是支持这个系列的,路径在\drivers\mtd\devices\m25p80....
    一路做下来,感觉过程还是满复杂的,特意写一篇文章,方便大家用到类似的外设。
    刚开始是想着自己写spi驱动,操作W25Q32的寄存器,本来已经读到芯片的ID了,后来因为cs脚的原因,以为自己写的程序有问题,转而找其他的方法,发现linux驱动中是支持这个系列的,路径在\drivers\mtd\devices\m25p80.c。具体操作为打开CONFIG_MTD_M25P80驱动,打开MTD相关的驱动,在dtd中加入
    m25p80{
    	compatible = "m25p80,w25q32";
    	status = "okay";
    	partition@0 {
    		label = "JEDEC";
    		reg = <0x0 0x1000>;
    		read-only;
    	};
    	
    	partition@1000 {
    		label = "user";
    		reg = <0x1000 0x3ff000>;
    	};
    };
    内容精简掉了一些与平台相关的。
    其实linux是把这种存储外设映射成mtd设备,我把它再分区一下,因为第一个块里存储着设备的id,所以设置成只读。
    确认spi通信没问题,正常的话,就像下面这样
    ls dev/block/mtdblock
    ls dev/mtd/mtd

    cat proc/mtd                                                 
    dev:    size   erasesize  name
    mtd0: 00001000 00001000 "JEDEC"
    mtd1: 003ff000 00001000 "user"

    接下来是在应用中操作/dev/mtd/mtd1节点。linux程序网上有很多,这里只给出android应用如何操作的具体代码
    首先是jni里的
    #include <stdio.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <string.h>
    #include <unistd.h>
    #include <sys/ioctl.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <mtd/mtd-user.h>
    #include <jni.h>
    
    #include "android/log.h"
    static const char *TAG="25q32";
    #define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
    #define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
    #define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)
    
    int fd=-1;
    
    JNIEXPORT void JNICALL Java_w25q32_open
            (JNIEnv *env, jclass thiz)
    {
        /* Opening device */
        const char *path_utf = "/dev/mtd/mtd1";
        LOGD("Opening %s with flags 0x%x", path_utf, O_SYNC | O_RDWR);
        fd = open(path_utf, O_SYNC | O_RDWR);
        LOGD("open() fd = %d", fd);
        if (fd == -1)
        {
            /* Throw an exception */
            LOGE("Cannot open 25q32");
            /* TODO: throw an exception */
        }
    }
    
    JNIEXPORT void JNICALL Java_w25q32_close
    (JNIEnv *env, jobject thiz)
    {
        LOGD("close(fd = %d)", fd);
        if (fd != -1)
        {
            close(fd);
        }
    }
    
    #define BUF_SIZE	(64 * 1024)
    
    JNIEXPORT jint JNICALL JNICALL Java_w25q32_eraseFlash
    (JNIEnv *env, jclass thiz, jint offset, jint bytes)
    {
        int err;
        struct erase_info_user erase;
        erase.start = offset;
        erase.length = bytes;
        err = ioctl (fd,MEMERASE,&erase);
        if (err < 0)
        {
            LOGE ("MEMERASE");
            return 1;
        }
        LOGD ("Erased %d bytes from address 0x%.8x in flash\n",bytes,offset);
        return 0;
    }
    
    JNIEXPORT jbyteArray JNICALL JNICALL Java_w25q32_readFlash
     (JNIEnv *env, jclass thiz, jint offset, jint len)
    {
        jbyte *buf = NULL;
        int size = len;
        int err;
        jbyteArray result;
    
    retry:
        if ((buf = (jbyte *) malloc (size)) == NULL)
        {
            LOGD ("%s: malloc(%#x)\n", __FUNCTION__, size);
            if (size != BUF_SIZE) {
                size = BUF_SIZE;
                LOGE ("%s: trying buffer size %#x\n", __FUNCTION__, size);
                goto retry;
            }
            LOGE ("malloc()");
            goto err0;
        }
    
        if (offset != lseek (fd,offset,SEEK_SET))
        {
            LOGE ("lseek()");
            goto err1;
        }
    
        err = read (fd,buf,len);
        LOGD ("read %d", err);
        if (err < 0)
        {
            goto err1;
        }
    
        result = (*env)->NewByteArray(env, err);
        if (result == NULL)
        {
            LOGE ("NewByteArray()");
            goto err1;
        }
    
        (*env)->SetByteArrayRegion(env, result, 0, err, buf);
    
        LOGD ("Copied %zu bytes from address 0x%.8x in flash\n",err,offset);
        free (buf);
        return result;
    
    err1:
        if (buf != NULL)
            free (buf);
    
    err0:
        return NULL;
    }
    
    JNIEXPORT jint JNICALL JNICALL Java_w25q32_writeFlash
    (JNIEnv *env, jclass thiz, jint offset, jbyteArray array, jint len)
    {
        jbyte *buf = NULL;
        int err;
        int size = len;
    
        if (offset != lseek (fd,offset,SEEK_SET))
        {
            LOGE ("lseek()");
            goto err0;
        }
    
        buf = (*env)->GetByteArrayElements(env, array, NULL);
        err = write (fd,buf,len);
        if (err < 0)
        {
            LOGE ("%s: write, size %#x\n", __FUNCTION__, err);
            LOGE ("write()");
            goto err1;
        }
    
        LOGD ("Copied %d bytes to address 0x%.8x in flash\n", err, offset);
        (*env)->ReleaseByteArrayElements(env, array, buf, 0);
        return err;
    
    err1:
        (*env)->ReleaseByteArrayElements(env, array, buf, 0);
    err0:
        return -1;
    }
    

    然后是java里的
    public class w25q32 {
        /*
    	 * Do not remove or rename the field mFd: it is used by native method
    	 * close();
    	 */
        final int ROM_SIZE = 4190208;//0x3ff000
        final int PAGE_SIZE = 4096;//0x1000
    
        public w25q32() throws SecurityException
        {
            open();
        }
    
        public int w25q32_erase(String addr, int len){
            String hex = addr.replace("0x", "");
            int offset = Integer.parseInt(hex, 16);
            if(offset+len > ROM_SIZE)
                return -1;
    
            int times = len/PAGE_SIZE + (len%PAGE_SIZE>0?1:0);
            int erase_size = times*PAGE_SIZE;
    
            return eraseFlash(offset, erase_size);
        }
    
        public byte[] w25q32_read(String addr, int len){
            if(len<1)
                return null;
    
            String hex = addr.replace("0x", "");
            int offset = Integer.parseInt(hex, 16);
            int size = len;
            if(offset+size > ROM_SIZE) {
                size = ROM_SIZE - offset;
            }
    
            return readFlash(offset, size);
        }
    
        public int w25q32_write(String addr, byte[] buf, int len){
            if(buf == null)
                return -1;
    
            int ret = w25q32_erase(addr, len);
            if(ret != 0)
                return ret;
    
            String hex = addr.replace("0x", "");
            int offset = Integer.parseInt(hex, 16);
    
            return writeFlash(offset, buf, len);
        }
    
        public void releasePort(){close();}
    
        // JNI
        private native void open();
        private native void close();
        private native int eraseFlash(int offset, int bytes);
        private native byte[] readFlash(int offset, int len);
        private native int writeFlash(int offset, byte[] buf, int len);
    
        static {
            System.loadLibrary("xx");
        }
    }
    
    在应用中使用
    w25q32 w25qxx = new w25q32();
    w25qxx.w25q32_erase("0x0", 0x3ff000);
    byte[] BUFFER1 = {0x0c,0x00,0x29,0x0b,0x01,0x00,(byte)0xfc,(byte)0xff,(byte)0xfa,0x00,
                                (byte)0xff,(byte)0xff,(byte)0xff,(byte)0xff,0x0d,0x0a};
    w25qxx.w25q32_write("0x1000", BUFFER1, BUFFER1.length);
    byte[] BUFFER2 = w25qxx.w25q32_read("0x1000", BUFFER1.length);
    w25qxx.releasePort();

    以上。
    展开全文
  • W25Q32是一个spi接口的存放芯片, 容量32M比特(4M字节). 驱动文件在"drivers/mtd/devices/m25p80.c" static struct spi_driver m25p80_driver = { .driver = { .name = "m25p80", .of_match_table = m25p_...

    W25Q32是一个spi接口的存放芯片, 容量32M比特(4M字节).
    驱动文件在"drivers/mtd/devices/m25p80.c"

    static struct spi_driver m25p80_driver = { 
        .driver = { 
            .name   = "m25p80",
            .of_match_table = m25p_of_table,
        },  
        .id_table   = m25p_ids, //使用id_table来匹配
        .probe  = m25p_probe,
        .remove = m25p_remove,
    };
    
    //支持的芯片型号
    static const struct spi_device_id m25p_ids[] = {
     	  ...
        {"at25df321a"}, {"at25df641"},  {"at26df081a"},
        {"mx25l4005a"}, {"mx25l1606e"}, {"mx25l6405d"}, {"mx25l12805d"},
        {"mx25l25635e"},{"mx66l51235l"},
        {"n25q064"},    {"n25q128a11"}, {"n25q128a13"}, {"n25q512a"},
        {"s25fl256s1"}, {"s25fl512s"},  {"s25sl12801"}, {"s25fl008k"},
        {"s25fl064k"},
        {"sst25vf040b"},{"sst25vf016b"},{"sst25vf032b"},{"sst25wf040"},
        {"m25p40"}, {"m25p80"}, {"m25p16"}, {"m25p32"},
        {"m25p64"}, {"m25p128"},
        {"w25x80"}, {"w25x32"}, {"w25q32"}, {"w25q32dw"},
        {"w25q80bl"},   {"w25q128"},    {"w25q256"},
    	...
    }; 
    

    w25q32接在spi0接口,在设备树文件里的描述:

    &spi0 {
        status = "okay";
    
        spiflash {
            compatible = "w25q32"; //设备名就为"w25q32"与设备驱动里的id_table项匹配
            reg = <0>;
            status = "okay";
            spi-max-frequency = <10000000>;
            buswidth = <8>;
        };  
    };
    
    


    因设备驱动提供的是mtd接口,所以设备驱动与设备匹配后会产生"mtd0 mtdblock0"等设备文件

    mkfs.ext2 /dev/mtdblock0   //先格式化设备分区
    mount /dev/mtdblock0 /mnt    //再挂载上来操作即可
    
    展开全文
  • 简单的记录一下使用HAL库的SPI外挂W25Q32 抽筋了,想记录一下。 cubeMX配置SPI CS脚 spi.h 里添加 #define FLASH_ID 0XEF14 //指令表 #define W25X_WriteEnable 0x06 #define W25X_WriteDisable 0x04...
  • 转载地址:... 一、W25Q32BV芯片简介  W25X是一系列SPI接口Flash芯片的简称,它采用SPI接口和CPU通信,本文使用的W25Q32BV容量为32M,具体特性如下: 1.1、基本特性  该芯片最大支持104MHz
  • t work correctly with W25Q32FVSSIG flash memory. I try to read data after erase and read only 0x88(0b1000). I think it means, that MCU waits data on 4 lines, but memory send it only by one line. [INFO...
  • RT1011_W25Q32_By_L17.FLM

    2020-07-11 12:37:51
    自己的RT1011能支持W25Qxx的Flash下载算法。该算法IDE平台Keil,不要看错了哦!
  • 一、W25Q32BV芯片简介  W25X是一系列SPI接口Flash芯片的简称,它采用SPI接口和CPU通信,本文使用的W25Q32BV容量为32M,具体特性如下: 1.1、基本特性  该芯片最大支持104MHz的时钟,供电电压范围在2.7~3.6V...
  • STM32开发 -- W25Q32JV SPI FlASH详解

    千次阅读 2019-11-20 18:41:48
    我们将利用 STM32F1 自带的 SPI来实现对外部 FLASH(W25Q32JV)的读写。 一、SPI简介 首先是SPI简单介绍,这部分之前有讲过, 参看: S5PV210开发 – SPI 你知道多少? SPI是英文Serial Peripheral interface...
  • 接着上一篇文章,由于W25Q32芯片是一个存储器芯片,先对这个芯片有关存储器的一些概念进行解读。 一、存储器相关知识 1、存储器的三个单位: 存储器三个等级:页(Page),扇区(sector),块(block) 2、单位...
  • 编写SPI FALSH的读写擦除函数 ...int32_t W25Qxx_SPI_EraseSector(uint32_t addrNb) { addrNb*=4096; uint8_t CommandArray[4] = {0}; int32_t res; CommandArray[0] = 0x20; //擦除扇区指令 命令为0x20,在
  • W25Q32芯片是一个可以通过SPI(串行外围设备接口)操作的flash存储器,这篇文章备忘和总结一下英文版数据手册的一些解读。有关时序及具体用STC单片机编写程序的内容等下一篇文章。 一、芯片引脚功能 我买的是8引脚、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 649
精华内容 259
关键字:

w25q32