55.基于IIC协议的EEPROM驱动控制（2）

已于 2024-08-27 18:38:20 修改
阅读量606 收藏
点赞数 10
分类专栏： 升腾A7-FPGA 文章标签： fpga开发
于 2024-08-27 18:37:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80417284/article/details/140804328
版权

        升腾A7pro的EEPROM芯片为24C64芯片，器件地址为1010_011。

        （1）Visio整体设计视图（IIC_SCL为250KHz，IIC_CLK为1MHz，addr_num为1，地址字节数为2字节，addr_num为0，地址字节数为1字节）：

（2）IIC_ctrl模块状态转移图：

（3）按键消抖模块代码及注释解析：

module key_filter(clk,reset_n,key_in,key_p_flag,key_r_flag,key_state);

    input clk;
    input reset_n;
    input key_in;
    
    output reg key_p_flag;
    output reg key_r_flag;
    output reg key_state;
    
    reg key_in1;
    reg key_in2;
    reg key_in3;
    reg [3:0]STATE;
    
//抖动时间往往小于20ms，20ms = 20_000_000ns = 20ns * 1_000_000;   (1_000_000)D = (1111_0100_0010_0100_0000)B   需要一个20位的寄存器,用于计数
    reg [19:0]cnt_20ms;
    reg en_cnt_20ms;

    wire podge;
    wire nedge;
    wire arrive_time_20ms;
    
//状态设计
    parameter IDLE      = 4'b0001;          //释放稳定状态
    parameter P_SHAKE   = 4'b0010;          //按下抖动状态
    parameter DOWN      = 4'b0100;          //按下稳定状态
    parameter R_SHAKE   = 4'b1000;          //释放抖动状态
    
    parameter CNT_MAX   = 20'd999_999;
    
//异步输入key_in 信号的同步化————“打两拍”
    always@(posedge clk)begin
        key_in1 <= key_in;
        key_in2 <= key_in1;
    end

//上升沿、下降沿设计
    always@(posedge clk)
        key_in3 <= key_in2;
        
    assign podge = key_in2  &&  (!key_in3);     //上升沿
    assign nedge = (!key_in2)  &&  key_in3;     //下降沿
        
//20ms计数器模块设计    
    always@(posedge clk or negedge reset_n)
        if(!reset_n)
            cnt_20ms <= 20'd0;
        else if(en_cnt_20ms &&(cnt_20ms == CNT_MAX))
            cnt_20ms <= 20'd0;
        else if(en_cnt_20ms)
            cnt_20ms <= cnt_20ms + 20'd1;
        else 
            cnt_20ms <= 20'd0;
            
//计满20ms信号设计           
    assign arrive_time_20ms = (cnt_20ms == CNT_MAX);
    
//状态机主程序设计
    always@(posedge clk or negedge reset_n)
        if(!reset_n)begin
            key_r_flag  <= 1'd0;
            key_p_flag  <= 1'd0;
            key_state   <= 1'd1;
            STATE       <= IDLE;
            en_cnt_20ms <= 1'd0;
        end
        else begin
            case(STATE)
                IDLE:begin
                    key_r_flag <= 1'd0;
                    key_state  <= 1'd1;
                    if(nedge)begin
                        STATE <= P_SHAKE;
                        en_cnt_20ms <= 1'd1;
                    end
                    else 
                        STATE <= STATE;
                end
                
                P_SHAKE:begin
                    if(arrive_time_20ms)begin
                        STATE <= DOWN;
                        en_cnt_20ms <= 1'd0;
                        key_p_flag <= 1'd1;
                        key_state <= 1'd0;
                    end
                    else if(podge)begin
                        STATE <= IDLE;
                        en_cnt_20ms <= 1'd0;
                    end
                    else 
                        STATE <= STATE;  
                end
                
                DOWN:begin
                    key_p_flag <= 1'd0;
                    key_state <= 1'd0;
                    if(podge)begin
                        STATE <= R_SHAKE;
                        en_cnt_20ms <= 1'd1;
                    end
                    else 
                        STATE <= STATE;          
                end
                
                R_SHAKE:begin
                    if(arrive_time_20ms)begin
                        STATE <= IDLE;
                        en_cnt_20ms <= 1'd0;
                        key_r_flag <= 1'd1;
                        key_state  <= 1'd1;
                    end
                    else if(nedge)begin
                        STATE <= DOWN;
                        en_cnt_20ms <= 1'd0;
                    end
                    else 
                        STATE <= STATE; 
                end
                
                default:begin
                    key_r_flag <= 1'd0;
                    key_p_flag <= 1'd0;
                    key_state  <= 1'd1;
                    STATE      <= IDLE;
                end
            endcase
        end

endmodule

（4）IIC_ctrl模块Verilog代码：

module IIC_ctrl(

    input   wire            clk         ,
    input   wire            reset_n     ,
    input   wire            IIC_start   ,
    input   wire            wr_en       ,
    input   wire            rd_en       ,
    input   wire    [15:0]  byte_addr   ,
    input   wire    [7:0]   wr_data     ,
    input   wire            addr_num    ,
    
    output  reg             IIC_SCL     ,
    inout   wire            IIC_SDA     ,
    output  reg             IIC_clk     ,
    output  reg             IIC_end     ,
    output  reg     [7:0]   rd_data     
    
);

    reg     [4:0]       cnt_1M          ;      //计数最大值是25  一个五位宽的寄存器足以胜任计数任务
    reg     [15:0]      state           ;
    reg     [1:0]       IIC_clk_cnt     ;
    reg                 EN_IIC_clk_cnt  ;
    reg     [2:0]       bit_cnt         ;
    reg                 ack             ;
    reg                 sda_out         ;
    reg     [7:0]       rd_data_reg     ;
        
    wire                sda_in          ;
    wire                EN_IIC_SDA      ;
    
    parameter IDLE        =  16'b0000_0000_0000_0001    ;       //空闲状态
    parameter START       =  16'b0000_0000_0000_0010    ;       //发送开始信号
    parameter SEND_D_A    =  16'b0000_0000_0000_0100    ;       //发送控制命令（器件地址+写操作）   {7'b1010_011,1'b0}
    parameter ACK_1       =  16'b0000_0000_0000_1000    ;       //等待响应 
    parameter SEND_B_H    =  16'b0000_0000_0001_0000    ;       //发送存储地址高8位  
    parameter ACK_2       =  16'b0000_0000_0010_0000    ;       //等待响应
    parameter SEND_B_L    =  16'b0000_0000_0100_0000    ;       //发送存储地址低8位
    parameter ACK_3       =  16'b0000_0000_1000_0000    ;       //等待响应
    parameter WR_DATA     =  16'b0000_0001_0000_0000    ;       //写入单比特数据   
    parameter ACK_4       =  16'b0000_0010_0000_0000    ;       //等待响应
    parameter START_2     =  16'b0000_0100_0000_0000    ;       //发送开始信号
    parameter SEND_RD_A   =  16'b0000_1000_0000_0000    ;       //发送控制命令（器件地址+读操作）   {7'b0101_011,1'b1} 
    parameter ACK_5       =  16'b0001_0000_0000_0000    ;       //等待响应
    parameter RD_DATA     =  16'b0010_0000_0000_0000    ;       //读出单比特数据
    parameter NO_ACK      =  16'b0100_0000_0000_0000    ;       //等待无响应信号
    parameter END         =  16'b1000_0000_0000_0000    ;       //结束单比特传输
    
    parameter DEVICE_ADD  =  7'b1010_011 ;                      //EEPROM器件地址设定
    

/*-----------IIC_clk生成模块--------------------*/
//IIC_clk 频率要求1MHz，而系统时钟clk频率为50MHz,半个周期需要计数25次（5位寄存器）

always@(posedge clk or negedge reset_n)
    if(!reset_n)
        cnt_1M <= 5'd0;
    else if(cnt_1M == 5'd24)
        cnt_1M <= 5'd0;
    else 
        cnt_1M <= cnt_1M + 5'd1;
     
always@(posedge clk or negedge reset_n)
    if(!reset_n)
        IIC_clk <= 1'd0;
    else if(cnt_1M == 5'd24)
        IIC_clk <= ~IIC_clk;
    else 
        IIC_clk <= IIC_clk;
  
/*----------------状态机设计-----------------------*/  

always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        state <= IDLE;
    else begin
        case(state)
            IDLE      :
                        if(IIC_start)
                            state <= START;
                        else 
                            state <= state;
            START     : 
                        if(IIC_clk_cnt == 2'd3)
                            state <= SEND_D_A;
                        else 
                            state <= state;           
            SEND_D_A  : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= ACK_1;
                        else 
                            state <= state;
            ACK_1     : 
                        if((IIC_clk_cnt == 2'd3) && (ack == 1'd0) &&  (addr_num == 1'd1))
                            state <= SEND_B_H;
                        else if((IIC_clk_cnt == 2'd3) && (ack == 1'd0) && (addr_num == 1'd0))
                            state <= SEND_B_L;
                        else 
                            state <= state;  
            SEND_B_H  : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= ACK_2;
                        else 
                            state <= state;
            ACK_2     : 
                        if((IIC_clk_cnt == 2'd3) && (ack == 1'd0))
                            state <= SEND_B_L;
                        else 
                            state <= state;  
            SEND_B_L  : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= ACK_3;
                        else 
                            state <= state;
            ACK_3     : 
                        if((IIC_clk_cnt == 2'd3) && (ack == 1'd0) && (wr_en == 1'd1))
                            state <= WR_DATA;
                        else if((IIC_clk_cnt == 2'd3) && (ack == 1'd0) && (rd_en == 1'd1))
                            state <= START_2;
                        else 
                            state <= state;
            WR_DATA   : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= ACK_4;
                        else 
                            state <= state;
            ACK_4     : 
                        if((IIC_clk_cnt == 2'd3) && (ack == 1'd0))
                            state <= END;
                        else 
                            state <= state; 
            START_2   : 
                        if(IIC_clk_cnt == 2'd3)
                            state <= SEND_RD_A;
                        else 
                            state <= state; 
            SEND_RD_A : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= ACK_5;
                        else 
                            state <= state;
            ACK_5     : 
                        if((IIC_clk_cnt == 2'd3) && (ack == 1'd0))
                            state <= RD_DATA;
                        else 
                            state <= state; 
            RD_DATA   : 
                        if((bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
                            state <= NO_ACK;
                        else 
                            state <= state;
            NO_ACK    : 
                        if(IIC_clk_cnt == 2'd3)
                            state <= END;
                        else 
                            state <= state; 
            END       : 
                        if((bit_cnt == 3'd3) && (IIC_clk_cnt == 2'd3))
                            state <= IDLE;
                        else 
                            state <= state;
            default   : state <= IDLE;
        endcase       
    end
        
/*----------------IIC_clk_cnt 、 EN_IIC_clk_cnt设计-----------------------*/
always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        IIC_clk_cnt <= 2'd0;
    else if(!EN_IIC_clk_cnt) 
        IIC_clk_cnt <= 2'd0;
    else 
        IIC_clk_cnt <= IIC_clk_cnt + 2'd1;

always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        EN_IIC_clk_cnt <= 1'd0;
    else if((state == END) && (bit_cnt == 3'd3) && (IIC_clk_cnt == 2'd3))
        EN_IIC_clk_cnt <= 1'd0;
    else if(IIC_start)
        EN_IIC_clk_cnt <= 1'd1;
    else 
        EN_IIC_clk_cnt <= EN_IIC_clk_cnt;

/*--------------------bit_cnt设计-----------------------*/
always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        bit_cnt <= 3'd0;
    else if((state == IDLE)||(state == START)||(state == ACK_1)
                ||(state == ACK_2)||(state == ACK_3)||(state == ACK_4) 
                ||(state == START_2)||(state == ACK_5)||(state == NO_ACK))
        bit_cnt <= 3'd0;
    else if((state == END) && (bit_cnt == 3'd3) && (IIC_clk_cnt == 2'd3))
        bit_cnt <= 3'd0;
    else if(IIC_clk_cnt == 2'd3)
        bit_cnt <= bit_cnt + 3'd1;
    else 
        bit_cnt <= bit_cnt;

/*--------------------ack 、 sda_in信号设计---------------------------*/
always@(*)
    begin
        case(state)
            ACK_1,ACK_2,ACK_3,ACK_4,ACK_5   : if(IIC_clk_cnt == 2'd0)
                                                    ack <= sda_in   ;
                                              else 
                                                    ack <= ack      ;
            default                         : ack = 1'd1;
        endcase
    end

assign sda_in = IIC_SDA ;

/*--------------------IIC_SCL设计-----------------------*/
always@(*)
    begin
        case(state)
            IDLE:
                    IIC_SCL <= 1'd1;
            START:
                    if(IIC_clk_cnt == 2'd3)
                        IIC_SCL <= 1'd0;
                    else 
                        IIC_SCL <= 1'd1;
            SEND_D_A,ACK_1,SEND_B_H,ACK_2,SEND_B_L,ACK_3,WR_DATA,
                ACK_4,START_2,SEND_RD_A,ACK_5,RD_DATA,NO_ACK:
                    if((IIC_clk_cnt == 2'd1) || (IIC_clk_cnt == 2'd2))
                        IIC_SCL <= 1'd1;
                    else 
                        IIC_SCL <= 1'd0;
            END:
                    if((bit_cnt == 3'd0) && (IIC_clk_cnt == 2'd0))
                        IIC_SCL <= 1'd0;
                    else 
                        IIC_SCL <= 1'd1;
            default:
                    IIC_SCL <= 1'd1;
        endcase
    end
    
/*--------------------sda_out 、 rd_data_reg设计-----------------------*/
always@(*)
    begin
        case(state)
            IDLE        :begin
                            sda_out <= 1'd1; 
                            rd_data_reg <= 8'd0;
                         end
            START       :
                if(IIC_clk_cnt >= 2'd1)
                    sda_out <= 1'd0; 
                else 
                    sda_out <= 1'd1;
            SEND_D_A    :
                if(bit_cnt <= 3'd6)
                    sda_out <= DEVICE_ADD[6 - bit_cnt];
                else 
                    sda_out <= 1'd0;
            ACK_1,ACK_2,ACK_3,ACK_4,ACK_5   :
                sda_out <= 1'd1;
            SEND_B_H    :  
                sda_out <= byte_addr[15-bit_cnt]; 
            SEND_B_L    :  
                sda_out <= byte_addr[7-bit_cnt];     
            WR_DATA     :
                sda_out <= wr_data[7-bit_cnt];        
            START_2     :
                if(IIC_clk_cnt >= 2'd2)
                    sda_out <= 1'd0; 
                else 
                    sda_out <= 1'd1;   
            SEND_RD_A   :
                if(bit_cnt <= 3'd6)
                    sda_out <= DEVICE_ADD[6 - bit_cnt];
                else 
                    sda_out <= 1'd1;                 
            RD_DATA     :begin
                            sda_out <= 1'd1;
                            if(IIC_clk_cnt == 2'd2)
                                rd_data_reg[7 - bit_cnt] <=  sda_in;
                            else    
                                rd_data_reg <= rd_data_reg;
                         end
            NO_ACK      :
                sda_out <= 1'd1;
            END         :
                if((bit_cnt == 3'd0) && (IIC_clk_cnt <= 2'd2))
                    sda_out <= 1'd0;
                else 
                    sda_out <= 1'd1;
            default     :begin
                    sda_out <= 1'd1;
                    rd_data_reg <= rd_data_reg;
            end
        endcase
    end
 
/*--------------------rd_data设计-----------------------*/ 
always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        rd_data <= 8'd0;
    else if((state == RD_DATA) && (bit_cnt == 3'd7) && (IIC_clk_cnt == 2'd3))
        rd_data <= rd_data_reg;
    else    
        rd_data <= rd_data;
        
/*--------------------EN_IIC_SDA设计-----------------------*/ 
//EN_IIC_SDA信号为1,表示IIC_SDA输出;反之，EN_IIC_SDA信号为0，表示IIC_SDA作为输入.

assign EN_IIC_SDA = ((state == IDLE) || (state == START) || (state == SEND_D_A) 
                        || (state == SEND_B_H) || (state == SEND_B_L) || (state == WR_DATA)
                        || (state == START_2) || (state == SEND_RD_A) || (state == NO_ACK)
                        || (state == END));
                        
/*--------------------IIC_SDA设计-----------------------*/ 
assign IIC_SDA = EN_IIC_SDA ? sda_out : 1'dz;

/*--------------------IIC_end设计-----------------------*/ 
always@(posedge IIC_clk or negedge reset_n)
    if(!reset_n)
        IIC_end <= 1'd0;
    else if((state == END) && (bit_cnt == 3'd3) && (IIC_clk_cnt == 2'd3))
        IIC_end <= 1'd1;
    else 
        IIC_end <= 1'd0;

endmodule

∑狸猫不是猫
关注
专栏目录
FPGA实现IIC接口（2）--IIC接口芯片的实际使用
孤独的单刀
10-15 4万+
通过本文您会学到：如何用EEPROM来实现IIC接口。
linux IIC设备驱动开发
wangjie36的博客
11-28 2249
1、通过module_i2c_driver注册对应的I2C驱动，此时内核会遍历挂载在I2C总线上的设备，通过总线的match方法对驱动和设备进行匹配，匹配原则可以是1、基于设备树of_driver_match_device方法，对应的结构为定义的驱动结构体是否含有of_match_table成员 2、基于id_table的匹配，对应为驱动是否定义id_table成员 3、基于名字的匹配，匹配原则为驱动的name是否和设备的name相同 4、基于ACPI风格的匹配，使用较少。参数msgs是需要发送的数据。
基于I2C协议的EEPROM驱动控制
m0_51133942的博客
05-23 889
IIC协议的这些特点使其在嵌入式系统和集成电路间的通信中非常流行，特别是在对硬件资源要求较低、需要连接多个低速设备的应用场景中。A2A1A3地址表示可以连接8个EEPROM设备，当读写控制位为0表示主机要对从机进行数据写入操作，1表示主机要对从机进行数据读出操作。当主机把器件地址发送到总线上，所有的从机都会收到，然后和自身的器件地址做对比，如果和总线上的地址相同，那么从机设备就会给主机发送一个应答信号。内存地址只是一个编号，代表一个内存空间；内存地址所执行的内存单元大小就是1字节，跟内存地址位数无关。
【正点原子STM32】IIC总线协议（拓扑图、IIC协议的核心特征、IIC协议的时序、AT24C02基于EEPROM非易失性存储器件、AT24C02读写时序、AT24C02驱动步骤、IIC通信失败）
咖喱年糕的博客
03-08 2497
在实际应用中，IIC总线因其简单易用、占用IO口少、支持热插拔和故障隔离等特点，常被用于各种嵌入式系统中不同器件间的通信，如温度传感器、EEPROM、ADC、DAC等。总之，IIC总线协议作为一种简洁高效的通信协议，广泛应用于传感器、存储器、微控制器等各种集成芯片间的通信，尤其适用于那些只需要少量线路连接和较低数据速率的应用场景。总结来说，IIC协议通过严格的时序规定保证了通信的可靠性和准确性，尤其是在多设备共用一条总线的情况下，这种有序的时序控制尤为重要。一、IIC总线协议介绍。一、IIC总线协议介绍。
基于FPGA的EEPROM读写（IIIC 接口协议）
啦啦啦啦啦
01-03 2699
笔者使用的是黑金AX309的开发板，其板载了一块有一个 IIC 接口的 EEPROM 芯片 24LC04（data sheet），容量大小为 4Kbit。这里先简单总结下一般的存储器件，然后介绍IIC协议及其读写时序，最后板机验证。这里最后实现给EEPROM中写入数据，然后再讲写入的数据显示在数码管验证其正确性。本文主要介绍IIC协议，至于芯片的种类不影响协议本身以及相关问题的理解。（参考资料会在文末给出出处或在文中以超链接的形式给出） 一，相关存储器件介绍 ROM Read Only Memory,意.
stm32的IIC协议以及IIC通信驱动OLED屏幕
m0_53573725的博客
07-30 2329
这里是直接根据写入的汉字，然后在hz_index[]数组中遍历寻找，所以你要想输出汉字，得现在hz[]和hz_index[]数组中补充。如果在hz_index[]数组中找到了对应的汉字，那就对应地在hz[]数组中找到字节，输出，完成OLED的汉字显示。I2C器件一般采用开漏结构与总线相连，所以I2C_SCL和I2C_SDA均需接上拉电阻，也正因此，当总线空闲时，这两条线路都处于高电平状态，当连到总线上的任一器件输出低电平，都将使总线拉低。汉字是16*16的形式。我用的是四引脚的，用的是IIC通信驱动。
IIC协议——向EEPROM进行读写操作
weixin_44497281的博客
12-27 1169
板子是普中科技开发板HC6800-ES V2.0 我按照文档的时序很快写了代码，但是结果一直出不来，最后发现是延时设置的不够，这个延时虽然官方说**EEPROM(24C02)**的延时都是纳秒和微秒级别的。但是实际上更大一点。 详细的步骤就代码里注释说明吧 #include <reg51.h> #include <intrins.h> sbit scl=P2^1; sbit sda=P2^0; void start(); void init(); void write(unsigne
二十二、Linux驱动之IIC驱动（基于linux2.6.22.6内核）
墨、白的博客
12-17 1481
1. 基本概念 本文默认读者掌握裸机下的I2C操作，该部分只做简单介绍， 主要内容是对linux-2.6.22.6系统下I2C驱动的分析。     由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据，是一个多主机的半双工通信方式，每个挂接在总线上的器件都有个唯一的地址。位速在标准模式下可达100kbit/s，在快速模式下可达400kbit/s，在高速模式下可待3.4Mbit/s。   ...
Chapter007-FPGA学习之IIC总线EEPROM读取
ASWaterbenben的博客
07-22 941
IIC总线是嵌入式领域较为重要的器件间通信总线，同样，FPGA也能通过模块的形式实现IIC的功能，其原理和STM32的模拟IIC总线一致，就是控制每个时间点的SCL、SDA总线电平。IIC总线需要对应的从机机通信器件进行通信，故目前使用AT24C64【IIC总线的EEPROM】作为从机，通过实现对EEPROM的读、写，来学习IIC协议在FPGA的实现。...
IIC控制器（2）：PS端与EEPROM读写例程
NoNoUnknow的博客
10-04 713
本文主要做一些基本知识的补充和工程参考。写IIC需要注意的事情：1.查询芯片手册获得slave地址，以及寄存器地址（或者叫寄存器命令）。2.约定好每次读/写的数据长度。对于这类芯片而言，读取一般都使用了顺序读，即读完一个地址自动读下一个地址，所以约定好长度通过no ack来打断很重要。（SPI设备是通过停止输入时钟和拉高CS_N来打断的）
STM32硬件IIC主机例程（以读写EEPROM为例）
04-19
STM32是一款基于ARM Cortex-M内核的微控制器，广泛应用于嵌入式系统设计。在STM32中，硬件IIC（Inter-Integrated Circuit，也称为I²C）接口是实现设备间通信的重要方式，特别适合低速、短距离的数据传输，如连接...
STM32 IIC协议
m0_59949484的博客
05-21 621
I2C 通讯协议（Inter-Integrated Circuit) 是由 Philps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路（IC）间的通讯。·紧跟设备地址的一个数据位 RW 用来表示数据传输方向，数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据。·SCL 为高电平的时候 SDA 表示的数据有效，即此时的 SDA 为高电平时表示数据“1”，为低电平时表示数据“0”。
IIC通信协议（STM32学习笔记 一）
qq_30012471的博客
11-25 1640
对STM32中IIC总线通信协议的学习笔记记录，通过协议简介、物理层及协议层从零基础开始了解IIC总线协议、传输过程及运用IIC总线传输数据。
AMD(Xilinx) FPGA配置Flash大小选择
qq_44385725的博客
11-17 482
讲解Xilinx 7系列FPGA配置Flash大小选择决定因素。
Xilinx FPGA的基本组成结构
u011732210的博客
11-17 364
Xilinx FPGA提供了内嵌的块RAM（BRAM），用于高效的数据存储或者缓冲，可以配置为双端口或单端口RAM，并且具有可编程的FIFO逻辑和内建可选的纠错电路。：Xilinx的某些FPGA系列，如7系列，集成了DSP块，这些DSP块提供了强大的数字信号处理能力，包括乘法器和累加器等。这些组成部分共同构成了Xilinx FPGA的基本架构，使得FPGA能够灵活地实现各种复杂的数字逻辑和信号处理任务。：FPGA内部的布线资源用于连接不同的逻辑资源，包括CLB、BRAM、DSP等，以实现复杂的逻辑功能。
FPGA FIFO系列 - FIFO使用中需要注意的若干问题
Qqyangleiyu的博客
11-17 719
场景：类似图像、文字等码流数据是不需要重复被访问的，因此使用FIFO进行缓存（如果需要被存储，一般不会放在FPGA内部）。此时，FIFO的数据消失性对设计没有影响。但是对于fifo来说，如果时钟频率提高，需要满足建立和保持时间，那么就需要对fifo接口进行缓存，以截断前、后组合逻辑布线延迟和FIFO接口时序之间的相互影响。写时序因为数据和写使能是同步输入给FIFO的，所以没有影响，但是，读时序，读出数据就会延迟3个时钟周期，如下图所示。
spi 回环
LonelyDragons的博客
11-14 696
spi回环
单片机和FPGA有什么区别？
u011732210的博客
11-14 1412
总的来说，选择单片机还是FPGA取决于具体的应用需求、成本预算、开发资源和性能要求。单片机更适合成本敏感和性能要求不高的应用，而FPGA则适用于需要高度定制化和高性能的应用。
一文快速掌握 AMD FPGA IO约束 常用电平标准
最新发布
mengzaishenqiu的博客
11-18 564
FPGA开发中IO约束是不可缺少的部分，正确的电平约束是确保电路稳定运行与兼容性的关键所在。今天分享下IO约束中常用的电平标准，帮助大家快速理解和掌握。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值