【FPGA】EEPROM+iic协议

已于 2022-09-28 15:21:49 修改
阅读量337 收藏 1
点赞数
文章标签： fpga开发
于 2022-09-26 22:52:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42792802/article/details/127060929
版权

EEPROM

电可擦除可编程只读存储器， 是一种常用的非易失性存储器（掉电后，数据不丢失）。

结构图：

SCL：iic的时钟引脚

SDA：双向数据引脚

WP：写保护引脚，低电平——可写，高电平——可读

A0、A1、A2地址引脚

iic

以下引用自原子哥：

IIC (I2C，Inter－Integrated Circuit)即集成电路总线，是一种两线式串行总线，由PHILIPS公司开发用于连接微控制器及其外围设备。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。

I2C总线由数据线SDA和时钟线SCL构成通信线路，既可用于发送数据，也可接收数据

标准模式：100Kbit/s  

快速模式：400kbit/s 

高速模式：3.4Mbit/s

IIC是半双工通信方式

① 空闲状态
② 开始信号
③ 停止信号
④ 数据的有效性
⑤ 应答信号
⑥ 数据传输

1.空闲状态

SCL：                1

SDA：                1

2.空闲状态

SCL：                1

SDA：        1 — — > 0

3.数据有效状态

SCL：                0— — — — —  >1 — — — — —  > 0

SDA：            稳定       准备    【数据】     稳定

                          采用                                                 采用

数据在SCL的上升沿到来之前就需准备好。并在在下降沿到来之前必须稳定

4.应答信号：

发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。 

对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P。

5.停止状态

SCL：                1

SDA：        0 — — > 1

以下的EEPROM大小为：内部分成256页，一页32个字节

所以储存大小为：256*32*8 / 1024 = 64 Kbit

写时序为：

大概四个部分：

1、器件地址 + 应答位

2、EEPROM的内部高 5 地址 + 应答位

3、EEPROM内部低 8 位地址 + 应答位

4、8 位数据 + 应答位

为什么内部地址是13位的？

答：256*32字节 = 8192 。8191是13位的

注：AT24C64支持页写模式

读时序

完整时序表如下：

SCLSDASCLSDASCLSDASCLSDASCLSDASCLSDA
11起始态011寄存高8位地址00add【15】寄存低8位地址00add【7】读数据00写数据00data【7】
11110111111data【7】11
写/读器件地址21021212121
30030303030
40add【6】40add【14】40add【6】4040data【6】
51515151data【6】51
6161616161
7070707070
80add【5】80add【13】80add【5】8080data【5】
91919191data【5】91
101101101101101
110110110110110
120add【4】120add【12】120add【4】120120data【4】
131131131131data【4】131
141141141141141
150150150150150
160add【3】160add【11】160add【3】160160data【3】
171171171171data【3】171
181181181181181
190190190190190
200add【2】200add【10】200add【2】200200data【2】
211211211211data【2】211
221221221221221
230230230230230
240add【1】240add【9】240add【1】240240data【1】
251251251251data【1】251
261261261261261
270270270270270
280add【1】280add【8】280add【0】280280data【0】
291291291291data【0】291
301301301301301
310310310310310
3200/1320从机答320从机答320应答320应答
331331331331331
341341341341341
350350350350350
360从机答
371
381
390完成

我们能得出一个结论：

在SCL为0， 0时写入东西

在SCL为0， 1时读数据

代码：

module i2c_dri
    #(// slave address（器件地址），放此处方便参数传递
      parameter   SLAVE_ADDR =  7'b1010000   ,
      parameter   CLK_FREQ   = 26'd50_000_000,   // i2c_dri模块的驱动时钟频率(CLK_FREQ)
      parameter   I2C_FREQ   = 18'd250_000       // I2C的SCL时钟频率
     )(
          //global clock
          input                clk        ,      // i2c_dri模块的驱动时钟(CLK_FREQ)
          input                rst_n      ,      // 复位信号

          //i2c interface
          input                i2c_exec   ,      // I2C触发执行信号
          input                bit_ctrl   ,      // 字地址位控制(16b/8b)
          input                i2c_rh_wl  ,      // I2C读写控制信号
          input        [15:0]  i2c_addr   ,      // I2C器件内地址
          input        [ 7:0]  i2c_data_w ,      // I2C要写的数据
          output  reg  [ 7:0]  i2c_data_r ,      // I2C读出的数据
          output  reg          i2c_done   ,      // I2C一次操作完成
          output  reg          scl        ,      // I2C的SCL时钟信号
          inout                sda        ,      // I2C的SDA信号

          //user interface
          output  reg          dri_clk           // 驱动I2C操作的驱动时钟,1us
     );

//localparam define
localparam  st_idle     = 8'b0000_0001;          // 空闲状态
localparam  st_sladdr   = 8'b0000_0010;          // 发送器件地址(slave address)
localparam  st_addr16   = 8'b0000_0100;          // 发送16位字地址
localparam  st_addr8    = 8'b0000_1000;          // 发送8位字地址
localparam  st_data_wr  = 8'b0001_0000;          // 写数据(8 bit)
localparam  st_addr_rd  = 8'b0010_0000;          // 发送器件地址读
localparam  st_data_rd  = 8'b0100_0000;          // 读数据(8 bit)
localparam  st_stop     = 8'b1000_0000;          // 结束I2C操作

//reg define
reg            sda_dir     ;                     // I2C数据(SDA)方向控制
reg            sda_out     ;                     // SDA输出信号
reg            st_done     ;                     // 状态结束
reg            wr_flag     ;                     // 写标志
reg    [ 6:0]  cnt         ;                     // 计数
reg    [ 7:0]  cur_state   ;                     // 状态机当前状态
reg    [ 7:0]  next_state  ;                     // 状态机下一状态
reg    [15:0]  addr_t      ;                     // 地址
reg    [ 7:0]  data_r      ;                     // 读取的数据
reg    [ 7:0]  data_wr_t   ;                     // I2C需写的数据的临时寄存
reg    [ 9:0]  clk_cnt     ;                     // 分频时钟计数

//wire define
wire          sda_in       ;                     // SDA输入信号
wire   [8:0]  clk_divide   ;                     // 模块驱动时钟的分频系数

//*****************************************************
//**                    main code
//*****************************************************

//SDA控制
assign  sda     = sda_dir ?  sda_out : 1'bz;     // SDA数据输出或高阻
assign  sda_in  = sda ;                          // SDA数据输入
assign  clk_divide = (CLK_FREQ/I2C_FREQ) >> 2'd3;// 模块驱动时钟的分频系数，25

//生成I2C的SCL的四倍频率的驱动时钟用于驱动i2c的操作
always @(posedge clk or negedge rst_n) begin
    if(rst_n == 1'b0) begin
        dri_clk <=  1'b1;
        clk_cnt <= 10'd0;
    end
    else if(clk_cnt == clk_divide - 1'd1) begin
        clk_cnt <= 10'd0;
        dri_clk <= ~dri_clk;
    end
    else
        clk_cnt <= clk_cnt + 1'b1;
end

//(三段式状态机)同步时序描述状态转移
always @(posedge dri_clk or negedge rst_n) begin
    if(rst_n == 1'b0)
        cur_state <= st_idle;
    else
        cur_state <= next_state;
end

//组合逻辑判断状态转移条件
always @( * ) begin
//    next_state = st_idle;
    case(cur_state)
        st_idle: begin                            // 空闲状态
           if(i2c_exec) begin
               next_state = st_sladdr;
           end
           else
               next_state = st_idle;
        end
        st_sladdr: begin
            if(st_done) begin
                if(bit_ctrl)                      // 判断是16位还是8位字地址
                   next_state = st_addr16;
                else
                   next_state = st_addr8 ;
            end
            else
                next_state = st_sladdr;
        end
        st_addr16: begin                          // 写16位字地址
            if(st_done) begin
                next_state = st_addr8;
            end
            else begin
                next_state = st_addr16;
            end
        end
        st_addr8: begin                           // 8位字地址
            if(st_done) begin
                if(wr_flag==1'b0)                 // 读写判断
                    next_state = st_data_wr;
                else
                    next_state = st_addr_rd;
            end
            else begin
                next_state = st_addr8;
            end
        end
        st_data_wr: begin                        // 写数据(8 bit)
            if(st_done)
                next_state = st_stop;
            else
                next_state = st_data_wr;
        end
        st_addr_rd: begin                         // 写地址以进行读数据
            if(st_done) begin
                next_state = st_data_rd;
            end
            else begin
                next_state = st_addr_rd;
            end
        end
        st_data_rd: begin                        // 读取数据(8 bit)
            if(st_done)
                next_state = st_stop;
            else
                next_state = st_data_rd;
        end
        st_stop: begin                           // 结束I2C操作
            if(st_done)
                next_state = st_idle;
            else
                next_state = st_stop ;
        end
        default: next_state= st_idle;
    endcase
end

//时序电路描述状态输出
always @(posedge dri_clk or negedge rst_n) begin
    //复位初始化
    if(rst_n == 1'b0) begin
        scl        <= 1'b1;
        sda_out    <= 1'b1;
        sda_dir    <= 1'b1;
        i2c_done   <= 1'b0;
        cnt        <= 1'b0;
        st_done    <= 1'b0;
        data_r     <= 1'b0;
        i2c_data_r <= 1'b0;
        wr_flag    <= 1'b0;
        addr_t     <= 1'b0;
        data_wr_t  <= 1'b0;
    end
    else begin
        st_done <= 1'b0 ;
        cnt     <= cnt +1'b1 ;
        case(cur_state)
             st_idle: begin                             // 空闲状态
                scl     <= 1'b1;
                sda_out <= 1'b1;
                sda_dir <= 1'b1;
                i2c_done<= 1'b0;
                cnt     <= 7'b0;
                if(i2c_exec) begin
                    wr_flag   <= i2c_rh_wl ;
                    addr_t    <= i2c_addr  ;
                    data_wr_t <= i2c_data_w;
                end
            end
            st_sladdr: begin                            // 写地址(器件地址和字地址)
                case(cnt)
                    7'd1 : sda_out <= 1'b0;             // 开始I2C
                    7'd3 : scl <= 1'b0;
                    7'd4 : sda_out <= SLAVE_ADDR[6];    // 传送器件地址
                    7'd5 : scl <= 1'b1;
                    7'd7 : scl <= 1'b0;
                    7'd8 : sda_out <= SLAVE_ADDR[5];
                    7'd9 : scl <= 1'b1;
                    7'd11: scl <= 1'b0;
                    7'd12: sda_out <= SLAVE_ADDR[4];
                    7'd13: scl <= 1'b1;
                    7'd15: scl <= 1'b0;
                    7'd16: sda_out <= SLAVE_ADDR[3];
                    7'd17: scl <= 1'b1;
                    7'd19: scl <= 1'b0;
                    7'd20: sda_out <= SLAVE_ADDR[2];
                    7'd21: scl <= 1'b1;
                    7'd23: scl <= 1'b0;
                    7'd24: sda_out <= SLAVE_ADDR[1];
                    7'd25: scl <= 1'b1;
                    7'd27: scl <= 1'b0;
                    7'd28: sda_out <= SLAVE_ADDR[0];
                    7'd29: scl <= 1'b1;
                    7'd31: scl <= 1'b0;
                    7'd32: sda_out <= 1'b0;              // 0:写
                    7'd33: scl <= 1'b1;
                    7'd35: scl <= 1'b0;
                    7'd36: begin
                        sda_dir <= 1'b0;                 // 从机应答
                        sda_out <= 1'b1;
                    end
                    7'd37: scl     <= 1'b1;
                    7'd38: st_done <= 1'b1;
                    7'd39: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            st_addr16: begin
                case(cnt)
                    7'd0 : begin
                        sda_dir <= 1'b1 ;
                        sda_out <= addr_t[15];           // 传送字地址
                    end
                    7'd1 : scl <= 1'b1;
                    7'd3 : scl <= 1'b0;
                    7'd4 : sda_out <= addr_t[14];
                    7'd5 : scl <= 1'b1;
                    7'd7 : scl <= 1'b0;
                    7'd8 : sda_out <= addr_t[13];
                    7'd9 : scl <= 1'b1;
                    7'd11: scl <= 1'b0;
                    7'd12: sda_out <= addr_t[12];
                    7'd13: scl <= 1'b1;
                    7'd15: scl <= 1'b0;
                    7'd16: sda_out <= addr_t[11];
                    7'd17: scl <= 1'b1;
                    7'd19: scl <= 1'b0;
                    7'd20: sda_out <= addr_t[10];
                    7'd21: scl <= 1'b1;
                    7'd23: scl <= 1'b0;
                    7'd24: sda_out <= addr_t[9];
                    7'd25: scl <= 1'b1;
                    7'd27: scl <= 1'b0;
                    7'd28: sda_out <= addr_t[8];
                    7'd29: scl <= 1'b1;
                    7'd31: scl <= 1'b0;
                    7'd32: begin
                        sda_dir <= 1'b0;                 // 从机应答
                        sda_out <= 1'b1;
                    end
                    7'd33: scl     <= 1'b1;
                    7'd34: st_done <= 1'b1;
                    7'd35: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            st_addr8: begin
                case(cnt)
                    7'd0: begin
                       sda_dir <= 1'b1 ;
                       sda_out <= addr_t[7];            // 字地址
                    end
                    7'd1 : scl <= 1'b1;
                    7'd3 : scl <= 1'b0;
                    7'd4 : sda_out <= addr_t[6];
                    7'd5 : scl <= 1'b1;
                    7'd7 : scl <= 1'b0;
                    7'd8 : sda_out <= addr_t[5];
                    7'd9 : scl <= 1'b1;
                    7'd11: scl <= 1'b0;
                    7'd12: sda_out <= addr_t[4];
                    7'd13: scl <= 1'b1;
                    7'd15: scl <= 1'b0;
                    7'd16: sda_out <= addr_t[3];
                    7'd17: scl <= 1'b1;
                    7'd19: scl <= 1'b0;
                    7'd20: sda_out <= addr_t[2];
                    7'd21: scl <= 1'b1;
                    7'd23: scl <= 1'b0;
                    7'd24: sda_out <= addr_t[1];
                    7'd25: scl <= 1'b1;
                    7'd27: scl <= 1'b0;
                    7'd28: sda_out <= addr_t[0];
                    7'd29: scl <= 1'b1;
                    7'd31: scl <= 1'b0;
                    7'd32: begin
                        sda_dir <= 1'b0;                // 从机应答
                        sda_out <= 1'b1;
                    end
                    7'd33: scl     <= 1'b1;
                    7'd34: st_done <= 1'b1;
                    7'd35: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                    end
                    default :  ;
                endcase
            end
            st_data_wr: begin                          // 写数据(8 bit)
                case(cnt)
                    7'd0: begin
                        sda_out <= data_wr_t[7];        // I2C写8位数据
                        sda_dir <= 1'b1;
                    end
                    7'd1 : scl <= 1'b1;
                    7'd3 : scl <= 1'b0;
                    7'd4 : sda_out <= data_wr_t[6];
                    7'd5 : scl <= 1'b1;
                    7'd7 : scl <= 1'b0;
                    7'd8 : sda_out <= data_wr_t[5];
                    7'd9 : scl <= 1'b1;
                    7'd11: scl <= 1'b0;
                    7'd12: sda_out <= data_wr_t[4];
                    7'd13: scl <= 1'b1;
                    7'd15: scl <= 1'b0;
                    7'd16: sda_out <= data_wr_t[3];
                    7'd17: scl <= 1'b1;
                    7'd19: scl <= 1'b0;
                    7'd20: sda_out <= data_wr_t[2];
                    7'd21: scl <= 1'b1;
                    7'd23: scl <= 1'b0;
                    7'd24: sda_out <= data_wr_t[1];
                    7'd25: scl <= 1'b1;
                    7'd27: scl <= 1'b0;
                    7'd28: sda_out <= data_wr_t[0];
                    7'd29: scl <= 1'b1;
                    7'd31: scl <= 1'b0;
                    7'd32: begin
                        sda_dir <= 1'b0;                // 从机应答
                        sda_out <= 1'b1;
                    end
                    7'd33: scl <= 1'b1;
                    7'd34: st_done <= 1'b1;
                    7'd35: begin
                        scl  <= 1'b0;
                        cnt  <= 1'b0;
                    end
                    default  :  ;
                endcase
            end
            st_addr_rd: begin                           // 写地址以进行读数据
                case(cnt)
                    7'd0 : begin
                        sda_dir <= 1'b1;
                        sda_out <= 1'b1;
                    end
                    7'd1 : scl <= 1'b1;
                    7'd2 : sda_out <= 1'b0;             // 重新开始
                    7'd3 : scl <= 1'b0;
                    7'd4 : sda_out <= SLAVE_ADDR[6];    // 传送器件地址
                    7'd5 : scl <= 1'b1;
                    7'd7 : scl <= 1'b0;
                    7'd8 : sda_out <= SLAVE_ADDR[5];
                    7'd9 : scl <= 1'b1;
                    7'd11: scl <= 1'b0;
                    7'd12: sda_out <= SLAVE_ADDR[4];
                    7'd13: scl <= 1'b1;
                    7'd15: scl <= 1'b0;
                    7'd16: sda_out <= SLAVE_ADDR[3];
                    7'd17: scl <= 1'b1;
                    7'd19: scl <= 1'b0;
                    7'd20: sda_out <= SLAVE_ADDR[2];
                    7'd21: scl <= 1'b1;
                    7'd23: scl <= 1'b0;
                    7'd24: sda_out <= SLAVE_ADDR[1];
                    7'd25: scl <= 1'b1;
                    7'd27: scl <= 1'b0;
                    7'd28: sda_out <= SLAVE_ADDR[0];
                    7'd29: scl <= 1'b1;
                    7'd31: scl <= 1'b0;
                    7'd32: sda_out <= 1'b1;             // 1:读
                    7'd33: scl <= 1'b1;
                    7'd35: scl <= 1'b0;
                    7'd36: begin
                        sda_dir <= 1'b0;                // 从机应答
                        sda_out <= 1'b1;
                    end
                    7'd37: scl     <= 1'b1;
                    7'd38: st_done <= 1'b1;
                    7'd39: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                    end
                    default : ;
                endcase
            end
            st_data_rd: begin                          // 读取数据(8 bit)
                case(cnt)
                    7'd0: sda_dir <= 1'b0;
                    7'd1: begin
                        data_r[7] <= sda_in;
                        scl       <= 1'b1;
                    end
                    7'd3: scl  <= 1'b0;
                    7'd5: begin
                        data_r[6] <= sda_in ;
                        scl       <= 1'b1   ;
                    end
                    7'd7: scl  <= 1'b0;
                    7'd9: begin
                        data_r[5] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd11: scl  <= 1'b0;
                    7'd13: begin
                        data_r[4] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd15: scl  <= 1'b0;
                    7'd17: begin
                        data_r[3] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd19: scl  <= 1'b0;
                    7'd21: begin
                        data_r[2] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd23: scl  <= 1'b0;
                    7'd25: begin
                        data_r[1] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd27: scl  <= 1'b0;
                    7'd29: begin
                        data_r[0] <= sda_in;
                        scl       <= 1'b1  ;
                    end
                    7'd31: scl  <= 1'b0;
                    7'd32: begin
                        sda_dir <= 1'b1;              // 非应答
                        sda_out <= 1'b1;
                    end
                    7'd33: scl     <= 1'b1;
                    7'd34: st_done <= 1'b1;
                    7'd35: begin
                        scl <= 1'b0;
                        cnt <= 1'b0;
                        i2c_data_r <= data_r;
                    end
                    default  :  ;
                endcase
            end
            st_stop: begin                            // 结束I2C操作
                case(cnt)
                    7'd0: begin
                        sda_dir <= 1'b1;              // 结束I2C
                        sda_out <= 1'b0;
                    end
                    7'd1 : scl     <= 1'b1;
                    7'd3 : sda_out <= 1'b1;
                    7'd15: st_done <= 1'b1;
                    7'd16: begin
                        cnt      <= 1'b0;
                        i2c_done <= 1'b1;             // 向上层模块传递I2C结束信号
                    end
                    default  : ;
                endcase
            end
        endcase
    end
end

endmodule

 下面是使用signal ii的一些教程：

quartus Ⅱ 12.1 使用教程（5） eeprom 读写测试_虚无缥缈vs威武的博客-CSDN博客

子根
关注
FPGA-串口通信
qq_43409587的博客
03-10 3445
串口
FPGA IIC通信EEPROM仿真模型
08-18
FPGA中 IIC通信调试通信时需要一个仿真模型来模拟总线时序，这个是EEPROM存储芯片AT24C64的仿真模型，地址宽度13位，可存储8192个字节数据。
FPGA开发（十三）----------IIC通信访问eeprom内容
AlwaysSun的博客
04-10 819
本次实验我们主要通过实现IIC通信协议，之后完成eeprom芯片内部内容的读取，通过按键每次将芯片内部的前一个字节数据增加一，之后保存回芯片的内部。 ...
IIC与EEPROM
qq_41328470的博客
06-30 2098
目录 1.IIC的介绍 2.IIC传输一个字节的时序图 1.IIC的起始信号 2.IIC的停止信号 3.IIC的写字节 4.IIC的读字节 3.EEPROM（24c02） 2.IIC对EEPROM单字节的写操作 3.对EEPROM单字节的读操作 4.EEPROM的总结 1.IIC的介绍 1.IIC总线有两条串行线，其一是时钟线SCK（同步），其二是数据线SDA(一条数据线半双）。应用中，单片机常常作为主机，外围器件(特别是外部存储)并且可以挂载多个从机。每一个从机器件都拥有唯一的
FPGA学习笔记05——I2C通信
ngany的博客
10-21 847
1.介绍 I2C总线是Philips半导体公司（现在的NXP半导体公司）开发的一种简单、双向二线制同步串行总线。它只需要两根线即可在连接于总线上的器件之间传送信息。SDA（串行数据线）和SCL（串行时钟线）都是双向I/O线，接口电路为开漏输出．需通过上拉电阻接电源VCC．当总线空闲时．两根线都是高电平。 在I2C器件开始通信（传输数据）之前，串行时钟线SCL和串行数据线SDA线由于上拉的原因处于高电平状态，此时I2C总线处于空闲状态。如果主机（此处指FPGA）想开始传输数据，只需在SCL为高电平时将SD
FPGA学习之-串口+IIC实现对EEPROM读写操作
最新发布
05-29
在本文中，我们将深入探讨如何使用FPGA进行串口（UART）和IIC通信协议来实现对EEPROM的读写操作。这是一项重要的技能，对于FPGA开发者来说，能够掌握这两种通信方式并应用于存储器的控制是十分有价值的。Vivado是一...
iic.rar_IIC EEPROM FPGA_IIC FPGA_IIC总线数据传输_fpga iic_iic总线%2
09-23
这个压缩包文件"iic.rar"包含了关于如何利用IIC协议在FPGA（Field-Programmable Gate Array）与EEPROM（Electrically Erasable Programmable Read-Only Memory）之间实现数据传输的相关资料。 IIC协议由飞利浦（现...
IIC.zip_IIC nio_fpga iic eeprom nios_nios iic
09-21
本主题围绕"IIC.zip_IIC nio_fpga iic eeprom nios_nios iic"展开，将详细介绍如何利用NIOS II软核在FPGA（Field-Programmable Gate Array）中实现IIC协议，并通过此协议与EEPROM进行通信。 首先，我们需要理解IIC...
iic.rar_FPGA IIC VERILOG_IIC FPGA_fpga iic_iic verilog_verilog
09-23
在这个项目中，Verilog被用来创建一个能够模拟IIC协议的FPGA设计。IIC协议包含两个主时钟线（SCL）和一个数据线（SDA），通过这些线，主设备可以控制和通信从设备。Verilog代码会精确地描述如何控制这些线路以执行...
FPGA通过IIC协议驱动24LC32（EEPROM）
03-23
本主题聚焦于如何使用FPGA通过IIC（Inter-Integrated Circuit）协议来驱动24LC32 EEPROM（电可擦除可编程只读存储器）。24LC32是一款常见的IIC接口EEPROM芯片，它提供了32Kb（4K x 8位）的数据存储空间，常用于存储...
基于FPGA的I2C通信（一）
FPGA自习室的博客
04-26 2002
目录 一、I2C通信协议 1.I2C总线介绍 2.I2C总线特性 3.I2C总线协议 3.1 SDA和SCL信号 3.1 数据有效性 3.2 起始和终止位 3.3 传输1字节格式 3.4 应答(ACK)与非应答(NACK) 3.5 从设备器件地址和读写位 二、EEPROM介绍（AT24C64） 1.EEPROM总线时序 2.EEPROM读写时序 2.1 设备地址 2....
IIC协议
m0_52867657的博客
04-29 2325
IIC (I2C，Inter－Integrated Circuit)即集成电路总线，是一种两线式串行总线，由PHILIPS公司开发用于连接微控制器及其外围设备。多用于主机和从机在数据量不大且传输距离短的场合下的主从通信。I2C总线由数据线SDA和时钟线SCL构成通信线路，既可用于发送数据，也可接收数据，是一种半双工通信协议。总线上的主设备与从设备之间以字节(8位)为单位进行双向的数据传输。​SDA 是串行数据线，由于 I2C器件一般采用开漏结构与总线相连，所以SCL 和 SDA 均需接上拉电阻。
FPGA学习笔记（五），串口
2203_75345038的博客
06-02 322
integer函数用于定义变量，寄存器数据类型，位宽为主机的字的位数，最小为32位，默认有符号类型。task函数，类似c语言中的非主函数，需要调用才运行内部代码，用法如下。//name为函数名称，data为输入信号/*内部代码需要调用才能运行*///函数结束标志endtake//在initial中调用，程序最开始的时候调用一次initialbeginend。
FPGA学习3：串口通信
weixin_44977812的博客
06-30 5061
串口、FPGA
FPGA基础入门【11】开发板USB-UART串口通信配置
热门推荐
qimoDIY的博客
08-20 1万+
上一篇教程介绍了NEXYS4 开发板中DDR2的使用方式，这一篇介绍不可或缺的网络接口RJ45在FPGA开发板中的使用 FPGA基础入门【11】开发板USB-UART串口通信配置开发板串口芯片 开发板串口芯片 NEXYS 4开发板自带一根USB mini-B线，在板子上的接口上写着PROG_UART，就是程序烧写和UART串口通信通用接口复用的。 用来实现串口通信的芯片名称是FTDI（Future...
FPGA学习之串口篇
pikaqiu的博客
04-05 2072
FPGA 串口通信
FPGA引脚功能说明与分析
weixin_44077714的博客
05-13 8582
FPGA引脚功能说明与分析 FPGA有很多个引脚，大多数为用户的IO口，有少量的IO作为特殊功能使用，下面以EP4CE10E22C8N芯片为例。 VCCINT： 供电引脚。内核电压1.2V/5%，负责给内部逻辑阵列电源引脚供电 VCCIO： IO口供电电压，共有8个块，每个块的供电电压可以不一样，支持所有IO口输入输出标准 GND： 供电负极。器件所有的GND引脚应该连接到板子地 GNDA： PLL锁相环的地，需要与GND相连。 VREFB： 参考电压引脚供电。给每个块输入参考电压，如果某个块使用输入参考电
CY68013 FPGA通信联调总结
nkltc的博客
10-23 1万+
CY68013 FPGA通信联调总结1. 简介CY68013是一款USB 2.0芯片，常用作fpga与pc的接口芯片，其硬件可以自动处理USB协议，也可以在里面下载对应的固件程序，由固件程序来完成USB协议的通信。我们只关心USB数据的传输，协议的不作深究，能用就行。 2. 开发2.1 CY680132.1.1 CY68013资料摘抄主要参考文档： 参考文档 描述 EZ-USB_TR
FPGA小知识汇总（持续更新中。。。）
zj907638274的博客
12-24 399
FPGA小知识汇总（持续更新中。。。） 备注：基于VHDL语法 1、如果实体的外部引脚是inout类型，则该实体不支持生成DCP文件 2、关于inout类型引脚怎么使用，可以参照下图，其中sda和scl是顶层inout引脚 3、关于两个实体模块在一个顶层模块相连的具体操作：关键操作是在顶层中需要定义A与B相连的中间信号，分别map到A输出和B的输入 ...
基于IIC协议的FPGA读写EEPROM操作与模型仿真分析
资源摘要信息:"在本资源中，我们将详细探讨如何使用IIC（Inter-Integrated Circuit，也称为I2C）协议在FPGA（Field-Programmable Gate Array，现场可编程门阵列）上实现对EEPROM（Electrically Erasable ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值