基于verilog的EEPROM读写

最新推荐文章于 2024-03-09 23:36:15 发布
最新推荐文章于 2024-03-09 23:36:15 发布
阅读量8.1k 收藏 44
点赞数 10
分类专栏： 我的个人笔记 文章标签： IIC eeprom
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/augus_per/article/details/52348659
版权

I2C串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL

这里以一个byte的读写为例

时序图：

写时序
这里写图片描述

读时序
这里写图片描述

通过时序图可知，IIC读的时候需要先完成写的控制字和地址的命令，因为读的部分和写的部分有重复，所以这里的IIC控制模块我使用状态机来完成的，划分状态时，写时序的start—ack_low_addr这段为复用状态

控制命令和状态的定义

//instru
parameter 
            WR_CTRL_DATA=   8'hA0,
            HIGH_DATA   =   8'h00,
            LOW_DATA    =   8'h05,
            DATA_WR     =   8'hAf,
            RD_CTRL_DATA=   8'hA1;
    //state
parameter 
        WR_START    =   15'b000_0000_0000_0001,
        WR_CTRL_BYTE=   15'b000_0000_0000_0010,
        ACK_WR_CTRL =   15'b000_0000_0000_0100,
        HIGH_ADDR   =   15'b000_0000_0000_1000,
        ACK_HIGH    =   15'b000_0000_0001_0000,
        LOW_ADDR    =   15'b000_0000_0010_0000,
        ACK_LOW     =   15'b000_0000_0100_0000,
        WR_DATA     =   15'b000_0000_1000_0000,
        ACK_WR      =   15'b000_0001_0000_0000,
        RD_START    =   15'b000_0010_0000_0000,
        RD_CTRL_BYTE=   15'b000_0100_0000_0000,
        ACK_RD_CTRL =   15'b000_1000_0000_0000,
        RD_DATA     =   15'b001_0000_0000_0000,
        NO_ACK      =   15'b010_0000_0000_0000,
        STOP        =   15'b100_0000_0000_0000;

用两个按键控制写和读

//----------key_flag--------------------
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        key_wr_state <= 1'b0;
    else if(w_valid)
        key_wr_state <= 1'b1;
    else if(key_clr)
        key_wr_state <= 1'b0;
    else 
        key_wr_state <= key_wr_state;

    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        key_rd_state <= 1'b0;
    else if(r_valid)
        key_rd_state <= 1'b1;
    else if(key_clr)
        key_rd_state <= 1'b0;
    else 
        key_rd_state <= key_rd_state;

iic的scl这里用的是200K

//------scl 200K------------------------------------
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        cnt_clk <= 'd0;
    else if(key_wr_state || key_rd_state)begin
        if(cnt_clk == 'd124)
            cnt_clk <= 'd0;
        else
            cnt_clk <= cnt_clk + 1'b1;
    end
    else 
        cnt_clk <= 'd0;

    always @(posedge clk or negedge rst_n)
    if(!rst_n)  
        eeprom_scl <= 1'b1;
    else if((key_wr_state || key_rd_state) && cnt_clk == 'd124)
        eeprom_scl <= ~eeprom_scl;
    else 
        eeprom_scl <= eeprom_scl;

状态开始信号由按键标志产生

//-------------start------------------- 
    always @(posedge clk or negedge rst_n)
    if(rst_n == 1'b0)
        wr_start <= 1'b0;
    else if(w_valid || r_valid)
        wr_start <= 1'b1;
    else if(eeprom_scl == 1 && eeprom_sda == 1'b0 && cnt_clk == 'd124)
        wr_start <= 1'b0;
    else 
        wr_start <= wr_start;

控制字命令的

//此处建议使用case语句
//参考
alw @（posedge clk or negedge rst_n）
    instru <= 'd0;
else begin
    case(state)
        WR_CTRL_BYTE   : 
        HIGH_ADDR      :
        LOW_ADDR       :
        WR_DATA        :
        RD_CTRL_BYTE   :
        default        :
    endcase
end

    //-----------------instru---------------------

    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        instru <= 'd0;
    else if(state == WR_CTRL_BYTE)
        instru <= WR_CTRL_DATA;
    else if(state == HIGH_ADDR)
        instru <= HIGH_DATA;
    else if(state == LOW_ADDR)
        instru <= LOW_DATA;
    else if(state == WR_DATA)
        instru <= DATA_WR;
    else if(state == RD_CTRL_BYTE)
        instru <= RD_CTRL_DATA;
    else 
        instru <= instru;

移位计数器：因为iic需要从机ack应答
所以这里移位计数器设置9位，1到8位为串行命令的移位输入，第9位为从机应答

//--------------shift_byte-----------------------
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        shift_cnt <= 'd0;
    else if(shift_flag && state != RD_START && state != STOP)begin
        if(shift_cnt== 'd8 &&eeprom_scl == 'd0 && cnt_clk == 'd63)
            shift_cnt <= 'd0;
        else if(state != WR_START && eeprom_scl == 'd0 && cnt_clk == 'd63)
            shift_cnt <= shift_cnt + 'b1;
    end
    else
        shift_cnt <=shift_cnt; 

    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        shift_byte <= 'd0;
    else if(shift_cnt == 'd0)
        shift_byte <= instru;
    else if(shift_cnt != 'd0 && cnt_clk == 'd64 && eeprom_scl == 'd0)
        shift_byte <= {shift_byte[6:0],shift_byte[7]};
    else 
        shift_byte <= shift_byte;

当写控制完成后产生stop信号，然后需要读的时候这里设置了读数据的开始信号

//-------------------rd_start_flag--------------

    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        rd_start_flag <= 'd0;
    else if(key_rd_state && state == ACK_LOW && eeprom_scl == 'd0 && cnt_clk == 'd63)
        rd_start_flag <= 'd1;
    else 
        rd_start_flag <= 'd0;

写状态完成和读状态完成后都会产生一个stop标志回到程序复位状态等待下次读写

//------------------stop_wr-----------------------------
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        stop_wr <= 'd0;
    else if((state == ACK_WR||state == NO_ACK) && eeprom_scl =='d0&& cnt_clk == 'd63)
        stop_wr <= 'd1;
    else 
        stop_wr <= 'd0;

因为iic需要从机应答，所以仿真时应答信号可以设置为高阻态

//---------eeprom_sda----------------------------------------
    always @(posedge clk or negedge rst_n)
    if(rst_n == 1'b0)
        oe <= 1'b1;
    else if((shift_cnt =='d8 && state != NO_ACK) || state ==RD_DATA)//
        oe <= 1'b0;
    else
        oe <= 1'b1;

    assign  eeprom_sda = (oe == 1'b1)? sda_r: 1'bz;

状态机

wire key_clr;
    assign key_clr = (state == STOP && eeprom_scl == 'd1 && cnt_clk == 'd123)? 1'b1:1'b0;
    wire state_jump_flag;
    assign state_jump_flag = (eeprom_scl == 0 && cnt_clk == 'd63 && shift_cnt=='d7)? 1'b1:1'b0;
    wire ack_jump;
    assign ack_jump = (shift_cnt=='d8 && eeprom_scl == 0 && cnt_clk == 'd63)? 1'b1:1'b0;


//----------------state_ctrl------------------------------
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        state <= WR_START;
    else begin
        case(state)
            //1-------------------------wr_state----------------------
            WR_START        :   if(shift_flag && eeprom_scl == 0 && cnt_clk == 'd63)
                                    state <= WR_CTRL_BYTE;
                                else
                                    state <= WR_START;
            //2                 
            WR_CTRL_BYTE    :   if(state_jump_flag)
                                    state <= ACK_WR_CTRL;
                                else 
                                    state <= WR_CTRL_BYTE;
            //4                 
            ACK_WR_CTRL     :   if(ack_jump)
                                    state <= HIGH_ADDR;
                                else 
                                    state <= ACK_WR_CTRL;
            //8
            HIGH_ADDR       :   if(state_jump_flag)
                                    state <= ACK_HIGH;
                                else 
                                    state <= HIGH_ADDR;
            //10                        
            ACK_HIGH        :   if(ack_jump)
                                    state <= LOW_ADDR;
                                else 
                                    state <= ACK_HIGH;
            //20                        
            LOW_ADDR        :   if(state_jump_flag)
                                    state <= ACK_LOW;
                                else 
                                    state <= LOW_ADDR;
            //40                        
            ACK_LOW         :   if(ack_jump)begin
                                    if(key_wr_state)
                                        state <= WR_DATA;
                                    else if(key_rd_state) 
                                        state <= RD_START;
                                end
                                else 
                                    state <= ACK_LOW;
            //                  
            WR_DATA         :   if(state_jump_flag)
                                    state <= ACK_WR;
                                else 
                                    state <= WR_DATA;
            //                  
            ACK_WR          :   if(ack_jump)
                                    state <= STOP;
                                else 
                                    state <= ACK_WR;

            //---------------------rd_state--------------------------                   
            RD_START        :   if(shift_flag && eeprom_scl == 0 && cnt_clk == 'd63)
                                    state <= RD_CTRL_BYTE;
                                else
                                    state <= RD_START;

            RD_CTRL_BYTE    :   if(state_jump_flag)
                                    state <= ACK_RD_CTRL;
                                else 
                                    state <= RD_CTRL_BYTE;

            ACK_RD_CTRL     :   if(ack_jump)
                                    state <= RD_DATA;
                                else 
                                    state <= ACK_RD_CTRL;

            RD_DATA         :   if(state_jump_flag)
                                    state <= NO_ACK;
                                else 
                                    state <= RD_DATA;

            NO_ACK          :   if(ack_jump)
                                    state <= STOP;
                                else
                                    state <= NO_ACK;

            //-------------------wr_rd_stop------------------------------
            STOP            :   if(eeprom_scl && cnt_clk == 'd124)
                                    state <= WR_START;
                                else 
                                    state <= STOP;

            default :   state <= WR_START;
        endcase     
    end

读数据串行数据转换

//-----------------RD_DATA--------------------------    
    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        DATA_r <= 8'd0;
    else if(state == RD_DATA)begin
        case(shift_cnt)
            4'd0    :   DATA_r[7] <= eeprom_sda;
            4'd1    :   DATA_r[6] <= eeprom_sda;
            4'd2    :   DATA_r[5] <= eeprom_sda;
            4'd3    :   DATA_r[4] <= eeprom_sda;
            4'd4    :   DATA_r[3] <= eeprom_sda;
            4'd5    :   DATA_r[2] <= eeprom_sda;
            4'd6    :   DATA_r[1] <= eeprom_sda;
            4'd7    :   DATA_r[0] <= eeprom_sda;
            default :   DATA_r <= 8'd0;
        endcase     
    end

    always @(posedge clk or negedge rst_n)
    if(!rst_n)
        data <= 8'd0;
    else if(shift_cnt == 'd7 && eeprom_scl == 1'b0 && cnt_clk == 'd63)
        data <= DATA_r;
    else 
        data <= data;

整个控制模块基本完成了
下面看一下仿真
这里写图片描述
这里写图片描述

这里用singtap II 抓取 了波形
这里写图片描述

请叫我小怪物
关注
  • 10
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
采用OTP技术的CSOC单芯片解决方案
11-07
AS1E5F是雅格罗技(Agate Logic)公司推出的一款内嵌高速8051硬核的FPGA芯片。该产品采用OTP存储代码独有技术，在产品量产的时候无需再外挂配置Flash芯片，直接把代码下载到芯片内部的OTP代码存储区即可，OTP技术不但可以大大降低芯片成本提供单芯片解决方案，而且使用户的代码安全性和产品的稳定性获得进一步提高。在实际应用中，AS1E5F具有灵活、安全、稳定、低成本等优势。图1是AS1E5F内部框图。 　　由于AS1E5F内嵌高性能的8051（最高运行速度可以达到28MIPS）以及内嵌独有加密技术的OTP存储器和可编程逻辑阵列，所以用户在使用AS1E5F时会更加灵活和方便。
基于FPGA的EEPROM读写系统
06-06
I2C接口器件EEPROM读写系统设计，包括串口发送模块，串口接收模块、fifo存储模块，fifo控制模块，I2C写控制模块，I2C读控制模块，I2C模块等。 EEPROM器件在FPGA上进行读写，以及接口设计和调试系统进行具体叙述。本实验平台使用的是小梅哥的AC620开发板，FPGA芯片是cyclone IV EP4CE10F17C8N。
I2C(IIC)---EEPROM超详细图解
最新发布
weixin_61125362的博客
03-09 2066
图解IIC--EEPROM的通信使用过程，使用单片机的IO口，进行模拟IIC时序与AT24C20进行双向通信(读写)。
IIC协议驱动EEPROM的Verilog实现与竞争冒险与下降沿触发、多重驱动
传承双龙的博客
03-04 5188
文章目录一、前言二、软硬件平台软件平台硬件平台三、IIC与EEPROMIIC简介1. 写操作大致步骤2. 读操作大致步骤3. IIC总线有以下几种状态1. 空闲状态2. 起始信号和结束信号3. 数据传输状态4. 应答信号/非应答信号4. 从机地址EEPROM简介EEPROM从机地址EEPROM数据地址EEPROM的五访问方式1. 字节写（BYTE WRITE）2. 页写（PAGE WRITE）3....
I2C学习——读写eeprom
weixin_44834094的博客
12-04 1万+
一.理论学习 I2C 通讯协议(Inter－Integrated Circuit)是由Philips公司开发的一种简单、双向二线制同步串行总线，只需要两根线即可在连接于总线上的器件之间传送信息。 I2C物理层 特点如下： 1.在一个I2C通讯总线中，可挂载多个设备，这些设备既可做主机也可做从机。（一般总线上挂载的设备所在的地址，在出厂的时候已经设置好了，一般来说器件地址是7位，当然也有其他的情况，比如说在eeprom，它的地址设置了高4位，剩下的3位可由用户自己设置） 2.一个I2C总线只使用两条总线线路
【S031】verilog 读写spi flash S25fl128L
1615549892
05-18 3720
https://www.cnblogs.com/fedorayang/p/8564792.html 在芯片资料上极性和相位一般表示为CPOL（Clock POLarity）和CPHA(Clock PHAse), 极性和相位组合成4种工作模式。 CPOL CPHA MODE0 0 0 MODE1 0 1 MODE2 1 0 MODE3 1 1 CPOL: SPI空闲时的时钟信号电平(1:高电平, 0:低电平) CPHA: SPI在时钟第几个边沿采样(1:第二个边沿开始, 0:第一个边沿开始) ......
一次可编程的非易失性存储器（OTP NVM）工作原理、eFuse模块解析
weixin_42491720的博客
06-21 1万+
 OTP，One time programmable，是一种特殊类型的非易失性存储器 ( non-volatile memory ), 只允许『编程』一次，一旦被编程，数据『永久』有效。相较于MTP (multi-time programmable ) 如EEPROM, OTP 的面积更小而且不需要额外的制造步骤，因此广泛应用于low-cost 芯片中，OTP 常用于存储可靠且可重复读取的数据。......
Verilog实现IIC协议读写EEPROM
mikusic的博客
03-23 3868
在FPGA设计中，IIC协议是一个十分常见的协议，因为几乎所有的EEPROM都是用这个协议进行配置。
正点原子 eeprom FPGA(verilog)编程
qq_31764341的博客
05-20 1683
eeprom 出于积累Verilog编程和调试经验的需求，用这个东西练手 使用的是正点原子领航者zynq的板子 实验环境过于优越了 导致进度慢就会很自责 ，程序一天出来了 。。 写个总结算是对得起我这两天的debug， eeprom 用的是板子上自带的AT24C64 iic时序 先分析下这货的iic时序，后面再说这货的iic读写时序 这里提前说一下，虽然很多设备都叫iic但是iic和iic之间也是有区别的，所以在写时序的时候一般最好还是看一眼手册和你之前用的iic是不是一样的 简单说两句这个图，你生成的S
SPI读写EEPROM实验[FPGA][verilog]
m0_58059010的博客
10-18 646
SPI读写EEPROM实验
Verilog数字系统设计教程[第4版]夏宇闻——第16章EEPROM代码
weixin_45968042的博客
12-29 456
【代码】Verilog数字系统设计教程[第4版]夏宇闻——第16章EEPROM代码。
eeprom的verilog代码
11-14
经过验证的eeprom存储器控制，I2C接口协议，AT24C1024，上板调试过
自己编写的使用Verilog通过SPI读写EEPROM，验证OK
07-06
自己编写的使用Verilog通过SPI读写EEPROM，验证OK
[FPGA][Verilog][SPI]简单的读写SPI接口EEPROM-93C46程序
04-09
[FPGA][Verilog][SPI]简单的读写SPI接口EEPROM-93C46程序
I2C总线EEPROM AT24CM01读写Verilog代码
03-02
I2C总线EEPROM AT24CM01读写FPGA控制器，Verilog代码实现。将8bit字节形式的数据写入EEPROM指定的地址中，从指定的地址读取数据以8bit字节形式输出，友好的读写握手接口信号。容易修改以适应其它I2C总线的存储器。 ...
24C512 EEPROM读写.zip
11-15
24C512驱动程序 STM32F407 驱动EEPROM（24C512） 自改，已用于实际项目，亲测可用。
Verilog读写EEPROM的代码+仿真脚本
03-23
EEPROM为AT24C64，详情请参考我写的IIC的教学文章。
基于i2c协议verilog读写EEPROM控制从机的简单示例
08-31
包含了对EEPROM先写再读的全部状态过程，包含EEPROM官方文档，对照i2c协议理解，适合FPGA小白
浮点数的定点化
热门推荐
小怪物的博客
10-02 1万+
FPGA(一般只能处理定点数):浮点数的定点化浮点数例子 : 2.918 12.918 3.1415926转成定点数要定义小数需求多少位,整数需求多少位例:16位的定点数(MAX:16’d32767 MIN:-32768) 3位整数位宽,12位的小数位,最高位的符号位 取低15位,其中第14,13,12位最大能表示7, 小数最大12位能表示的最大精度:1/4096=0.00244
verilog实现spi读写eeprom
09-20
在Verilog中，可以通过以下步骤实现SPI读写EEPROM的功能： 1. 首先，需要定义SPI总线的时钟(Clk)和数据(Din)信号，以及片选信号(CS)和数据输出信号(Dout)。 2. 创建一个状态机来控制SPI的读写操作。这个状态机可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值