xilinx中ddr3仿真出现tRFC maximum violation during No Op问题

最新推荐文章于 2024-03-10 11:44:45 发布
最新推荐文章于 2024-03-10 11:44:45 发布
阅读量286 收藏
点赞数
文章标签： fpga开发 学习方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72015659/article/details/133527243
版权

1、问题描述

在调用DDR3仿真模型时出现该问题，WREADY拉高的长度与实际需要突发的长度不匹配，还可以观察到此时打印窗口的行列，bank的值都是X。

2、问题排查

        第一步：怀疑AXI总线操作违规，阅读手册后发现使用是正确的

        第二步：使用BRAM替代DDR3仿真模型，进行AXI总线时序仿真，（这一步是请教大佬得到的经验），仿真无误后确定AXI时序操作正常

        第三步：问题此时就剩下DDR3器件模型本身，将DDR3的信号拉出来观察发现地址位宽不匹配，修改与AXI读写DMA一致后解决问题

3、分享一个将AXI的读写DDR3操作封装成FIFO接口的模块，此版本仅为第一版本，后面使用时发现有问题会不断的迭代

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2023/10/02 15:12:08
// Design Name: 
// Module Name: MIG_AXI_Drive
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module MIG_AXI_Drive #(
		parameter           C_M_TARGET_SLAVE_BASE_ADDR	= 32'h40000000      ,
		parameter integer   C_M_AXI_BURST_LEN	        = 16                ,
		parameter integer   C_M_AXI_ID_WIDTH	        = 1                 ,
		parameter integer   C_M_AXI_ADDR_WIDTH	        = 32                ,
		parameter integer   C_M_AXI_DATA_WIDTH	        = 32                ,
		parameter integer   C_M_AXI_AWUSER_WIDTH	    = 0                 ,
		parameter integer   C_M_AXI_ARUSER_WIDTH	    = 0                 ,
		parameter integer   C_M_AXI_WUSER_WIDTH	        = 0                 ,
		parameter integer   C_M_AXI_RUSER_WIDTH	        = 0                 ,
		parameter integer   C_M_AXI_BUSER_WIDTH	        = 0                 
)(  
		input  wire                                 M_AXI_ACLK              ,
		input  wire                                 M_AXI_ARESETN           ,
        input  wire                                 i_init_calib_complete   ,
        //--------用户写接口--------//
        input  wire [8 : 0]                         i_wr_len                ,
        input  wire [C_M_AXI_ADDR_WIDTH-1   : 0]    i_wr_addr               ,
        input  wire                                 i_wr_valid              ,
        output wire                                 o_wr_ready              ,
        
        input  wire [C_M_AXI_DATA_WIDTH-1   : 0]    i_wr_data               ,
        output wire                                 o_wr_req                ,
        //--------用户读接口--------//
        input  wire [8 : 0]                         i_rd_len                ,
        input  wire [C_M_AXI_ADDR_WIDTH-1   : 0]    i_rd_addr               ,
        input  wire                                 i_rd_valid              ,
        output wire                                 o_rd_ready              ,
        
        output wire [C_M_AXI_DATA_WIDTH-1   : 0]    o_rd_data               ,
        output wire                                 o_rd_valid              ,
        //--------AXI写地址--------//
		output wire [C_M_AXI_ID_WIDTH-1     : 0]    M_AXI_AWID              ,
		output wire [C_M_AXI_ADDR_WIDTH-1   : 0]    M_AXI_AWADDR            ,
		output wire [7 : 0]                         M_AXI_AWLEN             ,
		output wire [2 : 0]                         M_AXI_AWSIZE            ,
		output wire [1 : 0]                         M_AXI_AWBURST           ,
		output wire                                 M_AXI_AWLOCK            ,   
		output wire [3 : 0]                         M_AXI_AWCACHE           ,
		output wire [2 : 0]                         M_AXI_AWPROT            ,
		output wire [3 : 0]                         M_AXI_AWQOS             ,
		output wire [C_M_AXI_AWUSER_WIDTH-1 : 0]    M_AXI_AWUSER            ,
		output wire                                 M_AXI_AWVALID           ,
		input  wire                                 M_AXI_AWREADY           ,
        //--------AXI写数据--------//  
		output wire [C_M_AXI_DATA_WIDTH-1   : 0]    M_AXI_WDATA             ,
		output wire [C_M_AXI_DATA_WIDTH/8-1 : 0]    M_AXI_WSTRB             ,
		output wire                                 M_AXI_WLAST             ,
		output wire [C_M_AXI_WUSER_WIDTH-1  : 0]    M_AXI_WUSER             ,
		output wire                                 M_AXI_WVALID            ,
		input  wire                                 M_AXI_WREADY            ,
        //--------AXI写响应--------//  
		input  wire [C_M_AXI_ID_WIDTH-1     : 0]    M_AXI_BID               ,
		input  wire [1 : 0]                         M_AXI_BRESP             ,
		input  wire [C_M_AXI_BUSER_WIDTH-1  : 0]    M_AXI_BUSER             ,
		input  wire                                 M_AXI_BVALID            ,
		output wire                                 M_AXI_BREADY            ,
        //--------AXI读地址--------//  
		output wire [C_M_AXI_ID_WIDTH-1     : 0]    M_AXI_ARID              ,
		output wire [C_M_AXI_ADDR_WIDTH-1   : 0]    M_AXI_ARADDR            ,
		output wire [7 : 0]                         M_AXI_ARLEN             ,
		output wire [2 : 0]                         M_AXI_ARSIZE            ,
		output wire [1 : 0]                         M_AXI_ARBURST           ,
		output wire                                 M_AXI_ARLOCK            ,
		output wire [3 : 0]                         M_AXI_ARCACHE           ,
		output wire [2 : 0]                         M_AXI_ARPROT            ,
		output wire [3 : 0]                         M_AXI_ARQOS             ,
		output wire [C_M_AXI_ARUSER_WIDTH-1 : 0]    M_AXI_ARUSER            ,
		output wire                                 M_AXI_ARVALID           ,
		input  wire                                 M_AXI_ARREADY           ,
        //--------AXI读数据和读响应--------//  
		input  wire [C_M_AXI_ID_WIDTH-1     : 0]    M_AXI_RID               ,
		input  wire [C_M_AXI_DATA_WIDTH-1   : 0]    M_AXI_RDATA             ,
		input  wire [1 : 0]                         M_AXI_RRESP             ,
		input  wire                                 M_AXI_RLAST             ,
		input  wire [C_M_AXI_RUSER_WIDTH-1  : 0]    M_AXI_RUSER             ,
		input  wire                                 M_AXI_RVALID            ,
		output wire                                 M_AXI_RREADY    
);

/***************function**************/
function integer clogb2(input integer bit_depth);
begin 
    for(clogb2=0;bit_depth>0;clogb2=clogb2+1)
        bit_depth = bit_depth >> 1;
end 
endfunction
/***************parameter*************/

/***************port******************/             

/***************mechine***************/

/***************reg*******************/
reg                                 ro_wr_ready              ;
reg [8 : 0]                         ri_wr_len                ;
reg [C_M_AXI_ADDR_WIDTH-1   : 0]    ri_wr_addr               ;
reg                                 ro_aw_valid              ;
reg                                 ro_w_valid               ;
reg                                 ro_w_last                ;
reg [15: 0]                         r_wr_index               ; 
reg                                 ro_w_bready              ;
reg                                 ro_rd_ready              ;
reg                                 ro_arvalid               ;
reg [8 : 0]                         ri_rd_len                ;
reg [C_M_AXI_ADDR_WIDTH-1   : 0]    ri_rd_addr               ;
reg                                 ro_rready                ;
reg [C_M_AXI_DATA_WIDTH-1   : 0]    ro_rd_data               ;
reg                                 ro_rd_valid              ;
reg                                 r_w_ready_lock           ;
reg [C_M_AXI_ADDR_WIDTH-1   : 0]    ro_awaddr                ;
reg [7 : 0]                         ro_awlen                 ;  
reg                                 r_r_ready_lock           ;   
reg [C_M_AXI_ADDR_WIDTH-1   : 0]    ro_rwaddr                ;
reg [7 : 0]                         ro_rwlen                 ;                           

/***************wire******************/
wire                                w_wr_op_act              ;
wire                                w_aw_act                 ;
wire                                w_w_act                  ;
wire                                w_wb_act                 ;
wire                                w_ra_act                 ;
wire                                w_r_act                  ;
wire                                w_rd_op_act              ;
wire                                w_init_pose              ;
/***************component*************/

/***************assign****************/
assign o_wr_ready = ro_wr_ready ;
assign w_wr_op_act= i_wr_valid & o_wr_ready;
//写地址通道
assign M_AXI_AWID   = 'b0           ;
assign M_AXI_AWADDR = ro_awaddr     ;
assign M_AXI_AWLEN  = ro_awlen      ;
assign M_AXI_AWSIZE = clogb2(C_M_AXI_DATA_WIDTH/8 -1);
assign M_AXI_AWBURST= 2'b01;//地址递增
assign M_AXI_AWLOCK = 'b0;
assign M_AXI_AWCACHE= 4'b0010;//无缓存
assign M_AXI_AWPROT = 'b0;
assign M_AXI_AWQOS  = 'b0;
assign M_AXI_AWUSER = 'b0;
assign M_AXI_AWVALID= ro_aw_valid   ;
assign w_aw_act     = M_AXI_AWVALID & M_AXI_AWREADY;
//写数据通道
assign o_wr_req     = (w_aw_act) | (w_w_act);
assign M_AXI_WVALID = ro_w_valid;
assign w_w_act      = M_AXI_WVALID & M_AXI_WREADY;
assign M_AXI_WLAST  = ro_w_last;
assign M_AXI_WSTRB  = {C_M_AXI_DATA_WIDTH/8{1'b1}};
assign M_AXI_WUSER  = 'b0;
assign M_AXI_WDATA  = i_wr_data;
//写响应通道
assign M_AXI_BREADY = ro_w_bready;
assign w_wb_act     = M_AXI_BVALID && M_AXI_BREADY && (M_AXI_BRESP == 2'b00);
//读地址通道
assign w_rd_op_act  = i_rd_valid & o_rd_ready;
assign w_ra_act     = M_AXI_ARVALID & M_AXI_ARREADY;
assign M_AXI_ARVALID= ro_arvalid;
assign M_AXI_ARID   = 'd0;
assign M_AXI_ARADDR = ro_rwaddr;
assign M_AXI_ARLEN  = ro_rwlen;
assign M_AXI_ARSIZE = clogb2(C_M_AXI_DATA_WIDTH/8 -1);
assign M_AXI_ARBURST= 2'b01;//地址递增
assign M_AXI_ARLOCK = 'd0;
assign M_AXI_ARCACHE= 4'b0010;//无缓存
assign M_AXI_ARPROT = 'b0;
assign M_AXI_ARQOS  = 4'b0;
assign M_AXI_ARUSER = 'b0;
assign o_rd_ready   = ro_rd_ready;
//读响应通道
assign w_r_act      = M_AXI_RVALID && M_AXI_RREADY && (M_AXI_RRESP == 2'b00);
assign M_AXI_RREADY = ro_rready;
assign o_rd_data    = ro_rd_data ;
assign o_rd_valid   = ro_rd_valid;

/***************always****************/

//写地址
always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_wr_ready <= 1'b0;
    else if(w_aw_act)
        ro_wr_ready <= 1'b0;
    else if((M_AXI_AWREADY & i_init_calib_complete & !r_w_ready_lock) || w_wb_act)
        ro_wr_ready <= 1'b1;
    else 
        ro_wr_ready <= ro_wr_ready;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN) begin 
        ro_awaddr <= 'd0;
        ro_awlen  <= 'd0;
    end else if(w_wr_op_act)begin 
        ro_awaddr <= i_wr_addr; 
        ro_awlen  <= i_wr_len-1;
    end else begin 
        ro_awaddr <= ro_awaddr;
        ro_awlen  <= ro_awlen;  
    end 
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        r_w_ready_lock <= 1'b0;
    else if(w_wb_act)
        r_w_ready_lock <= 1'b0;
    else if(M_AXI_AWREADY & i_init_calib_complete)
        r_w_ready_lock <= 1'b1;
    else 
        r_w_ready_lock <= r_w_ready_lock;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN) begin 
        ri_wr_len  <= 'd0;
        ri_wr_addr <= 'd0;
    end else if(w_wr_op_act) begin 
        ri_wr_len  <= i_wr_len ;
        ri_wr_addr <= i_wr_addr;
    end else begin 
        ri_wr_len  <= ri_wr_len ;
        ri_wr_addr <= ri_wr_addr;
    end 
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_aw_valid <= 1'b0;
    else if(w_aw_act)
        ro_aw_valid <= 1'b0;
    else if(!ro_aw_valid & w_wr_op_act)
        ro_aw_valid <= 1'b1;
    else 
        ro_aw_valid <= ro_aw_valid;
end 

//写数据
always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_w_valid <= 1'b0;
    else if(w_aw_act)
        ro_w_valid <= 1'b1;
    else if(w_w_act & ro_w_last)
        ro_w_valid <= 1'b0;
    else 
        ro_w_valid <= ro_w_valid;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        r_wr_index <= 'd0;
    else if(w_w_act & ro_w_last)
        r_wr_index <= 'd0;
    else if(w_w_act)
        r_wr_index <= r_wr_index + 1'b1;
    else 
        r_wr_index <= r_wr_index;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_w_last <= 1'b0;
    else if(w_w_act && (r_wr_index == ri_wr_len - 1))
        ro_w_last <= 1'b0;
    else if(w_w_act && (r_wr_index == ri_wr_len - 2))
        ro_w_last <= 1'b1;
    else 
        ro_w_last <= ro_w_last;
end 

//写响应
always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_w_bready <= 1'b0;
    else if(w_wb_act)
        ro_w_bready <= 1'b0;
    else if(ro_w_last)
        ro_w_bready <= 1'b1;
    else 
        ro_w_bready <= ro_w_bready;
end 

//读地址
always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_rd_ready <= 1'b0;
    else if(w_ra_act)
        ro_rd_ready <= 1'b0;
    else if((M_AXI_ARREADY & i_init_calib_complete & !r_r_ready_lock) || (w_r_act & M_AXI_RLAST))
        ro_rd_ready <= 1'b1;
    else 
        ro_rd_ready <= ro_rd_ready;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN) begin 
        ro_rwaddr <= 'd0; 
        ro_rwlen  <= 'd0;
    end else if(w_rd_op_act) begin 
        ro_rwaddr <= ri_rd_addr;
        ro_rwlen  <= ri_rd_len-1;
    end else begin 
        ro_rwaddr <= ro_rwaddr; 
        ro_rwlen  <= ro_rwlen ; 
    end 
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        r_r_ready_lock <= 1'b0;
    else if(w_r_act & M_AXI_RLAST)
        r_r_ready_lock <= 1'b0;
    else if(M_AXI_ARREADY & i_init_calib_complete)
        r_r_ready_lock <= 1'b1;
    else 
        r_r_ready_lock <= r_r_ready_lock;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN) begin 
        ri_rd_len  <= 'd0;
        ri_rd_addr <= 'd0;
    end else if(w_rd_op_act) begin 
        ri_rd_len  <= i_rd_len ;
        ri_rd_addr <= i_rd_addr;
    end else begin 
        ri_rd_len  <= ri_rd_len ;
        ri_rd_addr <= ri_rd_addr;
    end 
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_arvalid <= 1'b0;
    else if(w_ra_act)
        ro_arvalid <= 1'b0;
    else if(w_rd_op_act && M_AXI_ARREADY)
        ro_arvalid <= 1'b1;
    else 
        ro_arvalid <= ro_arvalid;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
        ro_rready <= 1'b0;
    else if(w_r_act & M_AXI_RLAST)
        ro_rready <= 1'b0;
    else if(w_ra_act)
        ro_rready <= 1'b1;
    else 
        ro_rready <= ro_rready;
end 

always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN) begin 
        ro_rd_data  <= 'd0;
        ro_rd_valid <= 'd0;
    end else begin 
        ro_rd_data  <= M_AXI_RDATA;
        ro_rd_valid <= w_r_act;
    end 
end 

/* always@(posedge M_AXI_ACLK,negedge M_AXI_ARESETN)
begin 
    if(!M_AXI_ARESETN)
    
    else if()
    
    else if()
    
    else 

end 
 */

endmodule

本文章仅用于学习记录

菜鸟小向
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
xilinx平台DDR3设计教程.
04-25
“xilinx平台DDR3设计教程”可能包含了上述步骤的详细指南，包括如何配置MIG IP，如何进行仿真验证，以及如何解决常见问题。这类教程对于初学者来说是宝贵的实践指导材料。 通过深入理解和实践DDR3设计，开发者...
DDR3的效率杀手——时间参数
08-03
DDR3效率杀手——时间参数 DDR3是当前主流的SDRAM存储芯片，广泛应用于PC、消费电子和通信设备领域。但是，DDR系列存储芯片的效率是一个世界性难题。本文将探讨DDR3存储芯片的主要时间参数，这些参数对DDR3的访问...
modelsim仿真MCB DDR3 IP核时的报错
七水的博客
04-17 3871
问题描述： ddr3_model_parameters_c3.vh这个文件总是编译不过去，有错误。 错误提示： Error: (vlog-2902) ddr2_model_parameters_c3.vh(214): A `define was found on the same line as a SystemVerilog `ifdef, `ifndef, `elsif, or
关于xilinx中ddr3仿真出现tRFC maximum violation during No Op问题记录
Yuxin_Yu的博客
05-31 1105
文章目录1.问题描述2.解决方案 1.问题描述  在日常的FPGA开发中，ddr常用于对大量数据的存储，在对ddr的仿真过程中，常采用的是官方提供的ddr3_model.sv模块，简单方便。前段时间采用其进行仿真时，出现了app_rdy在进行短暂的读取数据后，一直置低，并且信息窗口报错如下  因为这个问题卡了我好多天，一直得不到解决，后面直接放下，转而去解决其他问题了，近来项目整合，不得不解决问题。于是乎到处问，最后得到一位南理工的同行指点，才算是解决了问题，特此记录在此，给后人排坑。 2.解决方案  给
Xilinx DDR3的MIG IP信号分析及仿真和上板测试
最新发布
weixin_50810761的博客
03-10 1764
文章分析了MIG IP的信号，并通过官方例程进行仿真测试，验证了DDR3的读写操作。介绍了MIG IP的用户接口信号，包括地址、指令、数据和控制信号，以及系统时钟和复位信号。最后，文章在开发板上进行了上板测试，使用ILA抓取读写数据时序，并观察LED指示灯确认了MIG IP的正常工作。
ddr3仿真初始化失败，DDR4仿真没有效果
bingbang0703的博客
08-29 2233
在对DDR3，DDR4等存储器进行仿真的时候，会发现仿真不出效果！！！
UBOOT学习之DDR3
qq_37400022的博客
02-16 1323
DDR3内存简介 1. ROM和RAM简介 - RAM RAM随机存储器，可以随时进行读写操作，速度块，但是掉电以后数据会丢失。比如内存条、SDRAM、SRAM和DDR都是RAM,RAM一般用来保存程序数据、中间结果。 - ROM ROM只读存储器，随着科技发展，ROM演变为FLASH,flash可以写操作，但是相对于读操作，效率低。例如手机配置“8G+128G”，8G指的就RAM,128G指的就是FLASH。EMMC、NAND Flash和UFS都属于ROM。总的来说，RAM读写速度快，但是掉电数据会丢失
南亚DDR3 SDRAM NTC-DDR3-1Gb-G-V14
05-03
南亚DDR3 SDRAM NTC-DDR3-1Gb-G-V14是南亚科技公司（Nanya Technology Corp.）生产的DDR3同步动态随机存取存储器（SDRAM）产品，容量为1Gb（即128Mb）。这款内存条采用JEDEC DDR3标准，包含了一系列的技术特性，旨在...
DDR3规格说明书
12-13
DDR3内存是一种随机存取内存（RAM），它是动态RAM（DRAM）的一种形式，用于在计算机和其他数字设备中存储和读取数据。DDR3是第四代双倍数据速率同步动态随机存取内存，它在DDR2的基础上进行了技术提升和性能优化。 ...
DDR3_NT5cc256M16er datasheet
09-21
DDR3_NT5cc256M16er是一款由Nanya Technology Corporation生产的4Gb DDR3内存芯片，符合DDR3标准并具有多种高级功能和优化的能效设计。该芯片适用于商业和工业应用，具备与DDR3兼容的8n预取架构，支持差分时钟（CK/...
SDRAM单字节读写仿真测试
瞎想的博客
08-30 1445
仿真测试的所有文件
DDR内存时序指南
奋斗中拥有
04-15 1万+
  DDR 内存 既然叫做双倍速率SDRAM（Dual date rate SDRSM），就是说是SDRAM的升级换代产品。从技术上分析，DDR SDRAM最重要的改变是在界面数据传输上，其在时钟信号上升缘与下降缘时各传输一次数据，这使得DDR的数据传输速率为传统SDRAM的两倍。那么大家就应该知道了，我们所说的DDR400，DDR333，DDR266，他们的工作频率其实仅为那些数值的一半
DDR3 controller 之储存器介绍
weixin_44101336的博客
07-04 2546
DDR3 SDRAM 接口信号：特别重要，物理层的时序转化就得跟着它来； DDR3操作流程：DDR3 SDRAM 操作流程 如图所示，是 DDR3 颗粒内部单个 Bank 的状态机命令跳转过程。由于 DRAM电容充放电读写数据的关系，每一个命令之间的跳转必须满足特定的时间参数，对DDR3 颗粒的读写就是要玩转这些时间参数，使 DDR3 颗粒内部的状态机运行起来。下图的实线箭头代表了状态之间通过命令使能进行跳转，虚线箭头代表状态机自动跳转。可以看到， DDR3 SDRAM 首先要经过上电复位和初始化过程，这
DDR3基础详解
热门推荐
Respate
08-07 3万+
DDR3基础详解 最近在IMX6平台下做DDR3的测试接口开发，以前在学习嵌入式时，用的是官方源码，没有做过多的研究。此时需要仔细研究DDR3的引脚与时序，此篇是我在学习DDR3做的归纳与总结，其中有大部分内容是借鉴他人的 博客，大部分博客的链接我已经贴出来了，如果存在版权或知识错误请直接联系我。 PS:本着知识共享的原则，此篇博客可以随意转载，不过请标明出处(虽然大部分内容不是我写的，但是整理也挺累的 _ ！) 一、专有名词索引表 名称缩写 名称含义 名称描述 RAS 行地址选通脉冲 Ro
Lattice FPGA 使用指南1 - clarity designer出现ERROR – Error trying to create component 错误的解决办法
tbzj_2000的博客
12-26 1339
ERROR – Error trying to create component 信息如下: 若工具联网，则工具会自动检查更新，有更新时，在Software Updae Center，会给出更新连接。 解决方法, 点击Software Updae Center给出的最新版本链接更新工具。更新后如下： 重新配置IP，发现问题已解决。 ...
xilinx ddr3 使用ncverilog 仿真
aiwa0311的专栏
02-29 1463
使用ncverilog 搭建ddr3 仿真平台
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值