STARTUPE3原语的使用

最新推荐文章于 2024-05-31 22:50:46 发布
最新推荐文章于 2024-05-31 22:50:46 发布
阅读量1.5k 收藏 8
点赞数 4
文章标签： fpga开发 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1006348650/article/details/129784288
版权

分享我写的一个程序，利用STARTUPE3原语实现读写配置flash，用的是VU3P+S25FL256S flash，有需要的可以参考一下。

`timescale 1ns / 1ps

module top(
    input sys_clk,
    output led
    
    );
    
    reg rst_n;

    wire Read_tx_en;
    wire MISO;
    wire CS;
    wire SCK;
    wire MOSI;
    wire [31:0] Read_Usr_Addr;
    wire [7:0] Read_Usr_Cmd;
    wire [7:0] DATA_OUT;
    wire Write_tx_en;
    wire Write_en;

    wire [31:0] Write_Usr_Addr;
    wire [7:0] Write_Usr_Cmd;
    wire [7:0] Write_Usr_Data;

    wire Erase_en;
    wire [31:0] Erase_Addr;
    wire [7:0] Erase_Cmd;

    wire Read_Cmd_Send_Ok;
    wire Read_Addr_Send_Ok;
    wire Read_Data_Ok;
    wire Write_Cmd_Send_Ok;
    wire Write_Addr_Send_Ok;
    wire Write_Data_Ok;
    wire Write_Enable_Ok;
    wire Erase_Ok;
    //wire sys_clk;
    
//    clk_wiz_0 clk_wiz_0_u
//   (
//        // Clock out ports
//        .clk_out1(sys_clk),     // output clk_out1
//        // Status and control signals
//        .reset(1'b0), // input reset
//        .locked(),       // output locked
//        // Clock in ports
//        .clk_in1(clk_100M)
//    );      // input clk_in1
    
    vio_0 your_instance_name (
        .clk(sys_clk),                // input wire clk
        .probe_in0(),    // input wire [0 : 0] probe_in0
        .probe_in1(),    // input wire [0 : 0] probe_in1
        .probe_in2(),    // input wire [0 : 0] probe_in2
        .probe_out0(Read_tx_en),  // output wire [0 : 0] probe_out0
        .probe_out1(Read_Usr_Addr),  // output wire [31 : 0] probe_out1
        .probe_out2(Read_Usr_Cmd),  // output wire [7 : 0] probe_out2
        .probe_out3(Write_tx_en),  // output wire [0 : 0] probe_out3
        .probe_out4(Write_Usr_Addr),  // output wire [31 : 0] probe_out4
        .probe_out5(Write_Usr_Cmd),  // output wire [7 : 0] probe_out5
        .probe_out6(Write_Usr_Data),  // output wire [7 : 0] probe_out6
        .probe_out7(Erase_en),  // output wire [0 : 0] probe_out7
        .probe_out8(Erase_Addr),  // output wire [31 : 0] probe_out8
        .probe_out9(Erase_Cmd)  // output wire [7 : 0] probe_out9
    );

    
    Read_Write_SignalBytes Read_Write_SignalBytes_u(

        .sys_clk(sys_clk),
        .rst_n(rst_n),
        .Read_tx_en(Read_tx_en),                         //发送使能
        .MISO(MISO),

        .Read_Usr_Addr(Read_Usr_Addr),
        .Read_Usr_Cmd(Read_Usr_Cmd),
   
        .Write_tx_en(Write_tx_en),         //发送完 写使能  紧接着就发送地址和数据
        .Write_en(Write_en),

        .Write_Usr_Addr(Write_Usr_Addr),
        .Write_Usr_Cmd(Write_Usr_Cmd),
        .Write_Usr_Data(Write_Usr_Data),
        
         .Erase_en(Erase_en),

        .Erase_Addr(Erase_Addr),
        .Erase_Cmd(Erase_Cmd),

        .CS(CS),
        .SCK(SCK),
        .MOSI(MOSI),
        .DATA_OUT(DATA_OUT),

        .Read_Cmd_Send_Ok(Read_Cmd_Send_Ok),
        .Read_Addr_Send_Ok(Read_Addr_Send_Ok),
        .Read_Data_Ok(Read_Data_Ok),

        .Write_Cmd_Send_Ok(Write_Cmd_Send_Ok),
        .Write_Addr_Send_Ok(Write_Addr_Send_Ok),
        .Write_Data_Ok(Write_Data_Ok),
        .Write_Enable_Ok(Write_Enable_Ok),
        
         .Erase_Ok(Erase_Ok)

    );
    
    
    STARTUPE3 #(
      .PROG_USR("FALSE"),  
      
      .SIM_CCLK_FREQ(0.0)  // Set the Configuration Clock Frequency (ns) for simulation
   )
   STARTUPE3_inst (
      .CFGCLK(),       // 1-bit output: Configuration main clock output
      .CFGMCLK(),     // 1-bit output: Configuration internal oscillator clock output
      .DI({1'b0,1'b0,MISO,1'b0}),               // 4-bit output: Allow receiving on the D input pin
      .EOS(),             // 1-bit output: Active-High output signal indicating the End Of Startup
      .PREQ(),           // 1-bit output: PROGRAM request to fabric output
      .DO({1'b0,1'b0,1'b0,MOSI}),               // 4-bit input: Allows control of the D pin output
      .DTS(4'b0000),             // 4-bit input: Allows tristate of the D pin
      .FCSBO(CS),         // 1-bit input: Controls the FCS_B pin for flash access
      .FCSBTS(0),       // 1-bit input: Tristate the FCS_B pin
      .GSR(0),             // 1-bit input: Global Set/Reset input (GSR cannot be used for the port)
      .GTS(0),             // 1-bit input: Global 3-state input (GTS cannot be used for the port name)
      .KEYCLEARB(0), // 1-bit input: Clear AES Decrypter Key input from Battery-Backed RAM (BBRAM)
      .PACK(0),           // 1-bit input: PROGRAM acknowledge input
      .USRCCLKO(SCK),   // 1-bit input: User CCLK input
      .USRCCLKTS(0), // 1-bit input: User CCLK 3-state enable input
      .USRDONEO(),   // 1-bit input: User DONE pin output control
      .USRDONETS(0)  // 1-bit input: User DONE 3-state enable output
   );
   
  
    
    reg [27:0] cnt;
    
    assign led = (cnt == 28'd100_000_000) ? ~led : led;
    
    always @(posedge sys_clk) begin
        if (cnt > 28'd100_000_000) begin
            cnt <= 28'd0;
            rst_n <= 1'b1;
        end
        else
            cnt <= cnt + 1'b1;
    end
    
     
    (*MARK_DEBUG = "TRUE"*)reg Read_tx_en_ila;
    (*MARK_DEBUG = "TRUE"*)reg MISO_ila;
    (*MARK_DEBUG = "TRUE"*)reg CS_ila;
    (*MARK_DEBUG = "TRUE"*)reg SCK_ila;
    (*MARK_DEBUG = "TRUE"*)reg MOSI_ila;
    (*MARK_DEBUG = "TRUE"*)reg [31:0] Read_Usr_Addr_ila;
    (*MARK_DEBUG = "TRUE"*)reg [7:0] Read_Usr_Cmd_ila;
    (*MARK_DEBUG = "TRUE"*)reg [7:0] DATA_OUT_ila;
    (*MARK_DEBUG = "TRUE"*)reg Write_tx_en_ila;
    
    (*MARK_DEBUG = "TRUE"*)reg [31:0] Write_Usr_Addr_ila;
    (*MARK_DEBUG = "TRUE"*)reg [7:0] Write_Usr_Cmd_ila;
    (*MARK_DEBUG = "TRUE"*)reg [7:0] Write_Usr_Data_ila;

    (*MARK_DEBUG = "TRUE"*)reg Erase_en_ila;
    (*MARK_DEBUG = "TRUE"*)reg [31:0] Erase_Addr_ila;
    (*MARK_DEBUG = "TRUE"*)reg [7:0] Erase_Cmd_ila;

    (*MARK_DEBUG = "TRUE"*)reg Read_Cmd_Send_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Read_Addr_Send_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Read_Data_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Write_Cmd_Send_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Write_Addr_Send_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Write_Data_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Write_Enable_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg Erase_Ok_ila;
    (*MARK_DEBUG = "TRUE"*)reg rst_n_ila;

    always @(posedge sys_clk) begin
         Read_tx_en_ila <= Read_tx_en;
         MISO_ila <= MISO;
         CS_ila <= CS;
         SCK_ila <= SCK;
         MOSI_ila <= MOSI;
         Read_Usr_Addr_ila <= Read_Usr_Addr;
         Read_Usr_Cmd_ila <= Read_Usr_Cmd;
         DATA_OUT_ila <= DATA_OUT;
         Write_tx_en_ila <= Write_tx_en;
    

         Write_Usr_Addr_ila <= Write_Usr_Addr;
         Write_Usr_Cmd_ila <= Write_Usr_Cmd;
         Write_Usr_Data_ila <= Write_Usr_Data;

         Erase_en_ila <= Erase_en;
         Erase_Addr_ila <= Erase_Addr;
         Erase_Cmd_ila <= Erase_Cmd;

         Read_Cmd_Send_Ok_ila <= Read_Cmd_Send_Ok;
         Read_Addr_Send_Ok_ila <= Read_Addr_Send_Ok;
         Read_Data_Ok_ila <= Read_Data_Ok;
         Write_Cmd_Send_Ok_ila <= Write_Cmd_Send_Ok;
         Write_Addr_Send_Ok_ila <= Write_Addr_Send_Ok;
         Write_Data_Ok_ila <= Write_Data_Ok;
         Write_Enable_Ok_ila <= Write_Enable_Ok;
         Erase_Ok_ila <= Erase_Ok;
         
         rst_n_ila <= rst_n;

    end
    
    
    
    
    
endmodule

`timescale 1ns / 1ps


module Read_Write_SignalBytes(

    input sys_clk,
    input rst_n,
    input Read_tx_en,                         //发送使能
    input MISO,

    input [31:0] Read_Usr_Addr,
    input [7:0]  Read_Usr_Cmd,
    
    input Write_tx_en,
    input Write_en,

    input [31:0] Write_Usr_Addr,
    input [7:0] Write_Usr_Cmd,
    input [7:0] Write_Usr_Data,

    input Erase_en,

    input [31:0] Erase_Addr,
    input [7:0] Erase_Cmd,
    

    output reg CS,
    output reg SCK,
    output reg MOSI,
    output reg [7:0] DATA_OUT,

    output reg Read_Cmd_Send_Ok,
    output reg Read_Addr_Send_Ok,
    output reg Read_Data_Ok,

    output reg Write_Cmd_Send_Ok,
    output reg Write_Addr_Send_Ok,
    output reg Write_Data_Ok,
    output reg Write_Enable_Ok,
    output reg Erase_enable_Ok,

    output reg Erase_Ok

    );
    
    //  写数据发送使能
    reg [5:0] cnt;

    reg Write_tx_en_dly1;
    reg Write_tx_en_dly2;

    wire Write_tx_en_pos;
    reg Write_tx_en_pos_dly;

    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            Write_tx_en_dly1 <= 1'b0;
            Write_tx_en_dly2 <= 1'b0;
        end
        else begin
            {Write_tx_en_dly2, Write_tx_en_dly1} <= {Write_tx_en_dly1, Write_tx_en};
        end
    end

    assign Write_tx_en_pos = ~Write_tx_en_dly2 & Write_tx_en_dly1;

    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            Write_tx_en_pos_dly <= 1'b0;
        end
        else begin
            Write_tx_en_pos_dly <= Write_tx_en_pos;
        end
    end

    
    //  写使能 发送使能
    reg [7:0] Enable_Data = 8'h06;
    
    reg [1:0] Write_en_dly;
    wire Write_en_pos;
    reg Write_en_pos_dly;
    
    assign Write_en_pos = ~Write_en_dly[1] & Write_en_dly[0];
    
    always @(posedge sys_clk) begin
        Write_en_dly[1:0] <= {Write_en_dly[0],Write_en};
        Write_en_pos_dly <= Write_en_pos;
    end

    //  读数据发送使能
    reg tx_en_dly1;
    reg tx_en_dly2;

    wire tx_en_pos;
    reg tx_en_pos_dly;

    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            tx_en_dly1 <= 1'b0;
            tx_en_dly2 <= 1'b0;
        end
        else begin
            {tx_en_dly2, tx_en_dly1} <= {tx_en_dly1, Read_tx_en};
        end
    end

    assign tx_en_pos = ~tx_en_dly2 & tx_en_dly1;

    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            tx_en_pos_dly <= 1'b0;
        end
        else begin
            tx_en_pos_dly <= tx_en_pos;
        end
    end

    // 擦除使能
    reg [1:0] Erase_en_dly;
    reg Erase_en_pos_dly;
    wire Erase_en_pos;

    assign Erase_en_pos = ~Erase_en_dly[1] & Erase_en_dly[0];

    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            Erase_en_dly <= 2'd0;
        end
        else begin
            Erase_en_dly[1:0] <= {Erase_en_dly[0], Erase_en};
            Erase_en_pos_dly <= Erase_en_pos;
        end
    end
    

    // 读数据的逻辑
    reg [16:0] Current_State = 17'd0;
    parameter READY = 17'b0_0000_0000_0000_0000;
    parameter READ_CMD = 17'b0_0000_0000_0000_0001;
    parameter READ_ADDR = 17'b0_0000_0000_0000_0010;
    parameter READ_DATA =  17'b0_0000_0000_0000_0100;
    parameter READ_FINISH = 17'b0_0000_0000_0000_1000;
    //  写数据得逻辑
    parameter WRITE_READY = 17'b0_1000_0000_0000_0000;
    parameter WRITE_CMD = 17'b0_0000_0000_0001_0000;
    parameter WRITE_ADDR = 17'b0_0000_0000_0010_0000;
    parameter WRITE_DATA =  17'b0_0000_0000_0100_0000;
    parameter WRITE_FINISH = 17'b0_0000_0000_1000_0000;
    //  写使能的逻辑
    parameter WRITE_ENABLE = 17'b0_0000_0001_0000_0000;
    parameter WRITE_OVER = 17'b0_0000_0010_0000_0000;

    //  擦除sector的逻辑
    parameter ERASE_ENABLE = 17'b0_0000_0100_0000_0000;
    parameter ERASE_OVER = 17'b0_0000_1000_0000_0000;
    parameter ERASE_READY = 17'b1_0000_0000_0000_0000;
    parameter ERASE_CMD = 17'b0_0001_0000_0000_0000;
    parameter ERASE_ADDR = 17'b0_0010_0000_0000_0000;
    parameter ERASE_FINISH = 17'b0_0100_0000_0000_0000;


    always @(posedge sys_clk or negedge rst_n) begin
        if (!rst_n) begin
            CS <= 1'b1;
            MOSI <= 1'b0;
            cnt <= 5'd0;
            Current_State <= READY;
            Read_Cmd_Send_Ok <= 1'b0;
            Read_Addr_Send_Ok <= 1'b0;     //发送完成
            Read_Data_Ok <= 1'b0;
            Write_Cmd_Send_Ok <= 1'b0;
            Write_Addr_Send_Ok <= 1'b0;
            Write_Data_Ok <= 1'b0;
            Write_Enable_Ok <= 1'b0;
            Erase_enable_Ok <= 1'b0;
            Erase_Ok <= 1'b0;
            Enable_Data <= 8'h06;
        end
        else begin
            case (Current_State)
                READY:begin
                    if (tx_en_pos_dly) begin   // 读使能
                        CS <= 1'b0;
                        MOSI <= Read_Usr_Cmd[7];
                        Current_State <= READ_CMD;
                    end
                    else if (Write_en_pos_dly) begin
                        CS <= 1'b0;
                        MOSI <= Enable_Data[7];
                        Current_State <= WRITE_ENABLE;
                    end
                    else if (Write_tx_en_pos_dly) begin         //写数据使能
                        CS <= 1'b0;
                        MOSI <= Enable_Data[7];
                        Current_State <= WRITE_ENABLE;          //写发送写使能
                    end
                    else if (Erase_en_pos_dly) begin            //擦除使能
                        CS <= 1'b0;
                        MOSI <= Enable_Data[7];
                        Current_State <= ERASE_ENABLE;
                    end
                    else begin
                         CS <= 1'b1;
                         Current_State <= READY;
                    end
                end
                //擦除数据的逻辑
                ERASE_ENABLE: begin
                    if (cnt <= 5'd6)begin
                        if (SCK) begin
                            MOSI <= Enable_Data[6-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Erase_enable_Ok <= 1'b1;
                        Current_State <= ERASE_OVER;
                    end
                end
                ERASE_OVER: begin
                    CS <= 1'b1;
                    MOSI <= 1'b0;
                    Erase_enable_Ok <= 1'b0;
                    Current_State <= ERASE_READY;
                end
                ERASE_READY:begin
                    CS <= 1'b0;
                    MOSI <= Erase_Cmd[7];
                    Current_State <= ERASE_CMD;
                end
                ERASE_CMD:begin
                    if (cnt <= 5'd6) begin
                        if (SCK) begin
                            MOSI <= Erase_Cmd[6-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= ERASE_ADDR;
                    end
                end
                ERASE_ADDR:begin
                    if (cnt <= 5'd31) begin
                        if (SCK) begin
                            MOSI <= Erase_Addr[31-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= ERASE_FINISH;
                        Erase_Ok <= 1'b1;
                    end
                end
                ERASE_FINISH:begin
                    Erase_Ok <= 1'b0;
                    CS <= 1'b1;
                    Current_State <= READY;
                    MOSI <= 1'b0;
                end
                //  读数据的逻辑
                READ_CMD:begin
                    if (cnt <= 5'd6) begin
                        if (SCK) begin
                            MOSI <= Read_Usr_Cmd[6-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= READ_ADDR;
                        Read_Cmd_Send_Ok <= 1'b1;
                    end
                end
                READ_ADDR:begin
                    Read_Cmd_Send_Ok <= 1'b0;
                    if (cnt <= 5'd31) begin
                        if (SCK) begin
                            MOSI <= Read_Usr_Addr[31-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Read_Addr_Send_Ok <= 1'b1;
                        Current_State <= READ_DATA;
                    end
                end
                READ_DATA:begin
                    Read_Addr_Send_Ok <= 1'b0;
                    if (cnt <= 5'd7) begin
                        if (!SCK) begin
                            DATA_OUT[7-cnt] <= MISO;
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= READ_FINISH;
                        Read_Data_Ok <= 1'b1;
                    end
                end
                READ_FINISH:begin
                    Read_Data_Ok <= 1'b0;
                    CS <= 1'b1;
                    Current_State <= READY;
                    //SCK <= 1'b0;
                    MOSI <= 1'b0;
                end
                //  写  写使能
                WRITE_ENABLE:begin
                    if (cnt <= 5'd6) begin
                        if (SCK) begin
                            MOSI <= Enable_Data[6-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        Write_Enable_Ok <= 1'b1;
                        cnt <= 5'd0;
                        Current_State <= WRITE_OVER;
                    end
                end
                WRITE_OVER:begin
                    CS <= 1'b1;
                    MOSI <= 1'b0;
                    Write_Enable_Ok <= 1'b0;
                    Current_State <= WRITE_READY;
                end
                //  写数据的逻辑
                WRITE_READY:begin
                    CS <= 1'b0;
                    MOSI <= Write_Usr_Cmd[7];
                    Current_State <= WRITE_CMD;
                end
                WRITE_CMD:begin
                    if (cnt <= 5'd6) begin
                        if (SCK) begin
                            MOSI <= Write_Usr_Cmd[6-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= WRITE_ADDR;
                        Write_Cmd_Send_Ok <= 1'b1;
                    end
                end
                WRITE_ADDR:begin
                    Write_Cmd_Send_Ok <= 1'b0;
                    if (cnt <= 5'd31) begin
                        if (SCK) begin
                            MOSI <= Write_Usr_Addr[31-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Write_Addr_Send_Ok <= 1'b1;
                        Current_State <= WRITE_DATA;
                    end
                end
                WRITE_DATA:begin
                    Write_Addr_Send_Ok <= 1'b0;
                    if (cnt <= 5'd7) begin
                        if (SCK) begin
                            MOSI <= Write_Usr_Data[7-cnt];
                            cnt <= cnt + 1'b1;
                        end
                        else begin
                            cnt <= cnt;
                        end
                    end
                    else begin
                        cnt <= 5'd0;
                        Current_State <= WRITE_FINISH;
                        Write_Data_Ok <= 1'b1;
                    end
                end
                WRITE_FINISH:begin
                    Write_Data_Ok <= 1'b0;
                    CS <= 1'b1;
                    Current_State <= READY;
                    //SCK <= 1'b0;
                    MOSI <= 1'b0;
                end
                default:begin
                    CS <= 1'b1;
                    Current_State <= READY;
                    SCK <= 1'b0;
                    MOSI <= 1'b0;
                end
                

            endcase
        end
    end

    always @(posedge sys_clk) begin
        if (!CS) begin
            SCK <= ~SCK;
        end
        else begin
            SCK <= 1'b0;
        end
    end


endmodule
 

二乐二乐
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
使用STARTUPE3原语通过SPI Flash实现UltraScale FPGA的局部重配置（一）
qq_34670507的博客
04-20 3114
使用STARTUPE3原语通过SPI Flash实现UltraScale FPGA的局部重配置介绍合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 介绍 本应用中的参考设计使用MicroBlaze®软处理器内核连接到AXI Quad SPI内
固件远程更新之STARTUPE2原语（fpga控制flash）
热门推荐
jiuzhangzi的博客
03-07 1万+
有的项目需要远程更新固件，更新完成后断电、重启即可。那远程更新是如何实现的呢？用的最多的应该是以太网或者自定义的局域网为主，当然还可以使用pcie、串口之类的，像xilinx还有golden image，以防止远程更新失败启动不起来，它主要是flash存有两个启动文件，正常情况下启动默认的，当默认的被损坏，就从备用的启动。本文章主要讲解的是STARTUPE2原语，这和远程更新有什么关系呢？请接着向...
产品推荐 | 基于VIRTEX UltraScale+系列的 FACE-VU3P-B高性能FPGA开发平台
dpwkj的博客
04-03 788
FACE-VU3P-B高性能FPGA开发平台是FACE系列的新产品。FACE-VU3P-B搭载有16nm工艺的VIRTEX UltraScale+系列主器件XCVU3P。该主器件具有丰富的FPGA可编程逻辑资源，其资源量高于常用的V7-690器件，并且其性能远远高于V7-690器件。
FPGA通过CPU远程升级方案
ET_David的博客
02-01 4750
FPGA通过CPU远程升级方案方案介绍升级流程图功能框图例程实现AXI Quad SPI IP核的生成和配置Dual/Quad SPI ModeLegacy ModeRegister Space (Legacy and Enhanced Non-XIPMode)Example Programming SequenceWrite Enable Command SequenceErase Command SequenceWrite Data Command SequenceRead Data Command S
FPGA 控制 FLASH 之 Startup 原语使用相关链接
Reborn Lee
04-24 7485
固件远程更新之STARTUPE2原语（fpga控制flash） 上个格式不方便看，看这个转载的： https://blog.csdn.net/Reborn_Lee/article/details/89187417 针对所有 ISE 版本和 Vivado 2017.2 及更早版本的 Zynq-7000 SoC RSVDGND 引脚和 PL STARTUPE2 原语需求的设计咨询 这个才是最重...
学习笔记之Ultrascale利用STARTUPE3读写BPI
weixin_42564775的博客
11-18 3621
学习笔记之Ultrascale利用STARTUPE3读写BPI 1.简介 Ultrascale系列FPGA的DQ0~DQ3规划到了FPGA的专用BANK0上面，而在使用BPI加载模式时， FPGA配置完成之后，BPI配置接口通常保持未使用状，态BPI FLASH剩余空间依旧可以利用。但是，DQ0~DQ3规划到了FPGA的专用BANK0上，下图展示了如何利用剩余空间的流程。 步骤1：使用NOR F...
STARTUPE2原语
Reborn Lee
04-10 1万+
转载：https://blog.csdn.net/jiuzhangzi/article/details/79471365 有的项目需要远程更新固件，更新完成后断电、重启即可。那远程更新是如何实现的呢？用的最多的应该是以太网或者自定义的局域网为主，当然还可以使用pcie、串口之类的，像xilinx还有golden image，以防止远程更新失败启动不起来，它主要是flash存有两个启动文件，正常情...
xilinx原语的使用方法
12-19
原语在设计中可以直接例化使用，是最直接的代码输入方式，其和 HDL 语言的关系，类似于汇编语言和 C 语言的关系。 Xilinx 公司提供的原语，涵盖了FPGA开发的常用领域，但只有相应配置的硬件才能执行相应的原语，并...
Vivado中原语使用汇总
06-25
Vivado中原语使用汇总
Xilinx原语的使用方法.pdf
05-31
pdf带书签，查找方便，讲解清楚明了 ，有关bufg，bufiO，bufr，dsp48，DCM，时钟和IO的buf原语使用。
xilinx 原语的使用方法
01-24
文名字为 Primitive，是 Xilinx 针对其器件特征开发的一系列常用模 块的名字，用户可以将其看成 Xilinx 公司为用户提供的库函数，类似于 C++ 中的“cout”等关键字，是芯片中的基本元件，代表 FPGA 中实际拥有的硬件...
Xilinx原语的使用说明
01-24
Xilinx 针对其器件特征开发的一系列常用模 块的名字，用户可以将其看成 Xilinx 公司为用户提供的库函数，类似于 C++ 中的“cout”等关键字，是芯片中的基本元件，代表 FPGA 中实际拥有的硬件逻 ...
IC开发——VCS基本用法
飞鹤的程序员人生
05-28 876
VCS是编译型verilog仿真器，处理verilog的源码过程如下：VCS先将verilog/systemverilog文件转化为C文件，在linux下编译链接生成可执行文件，在linux下运行simv即可得到仿真结果。VCS使用步骤，先编译verilog源码，再运行可执行文件：编译命令的格式：vcs sourcefile [compile_time_option] （编译选项用来控制编译过程）执行仿真命令格式：./simv [run_time_option]
ZYNQ AXI4 FDMA内存读写
baidu_34971492的博客
05-28 114
如果用过ZYNQ的都知道，要直接操作PS的DDR 通常是DMA 或者VDMA,然而用过XILINX 的DMA IP 和 VDMA IP，总有一种遗憾，那就是不够灵活，还需要对寄存器配置，真是麻烦。对于我们搞 FPGA 的人来说，最喜欢直接了当，直接用FPGA代码搞定。现在XILINX 的总线接口是AXI4总线，那么熟 练自定义AXI4 IP挂到总线上就非常方便了。基于这个目的，定义了一个基于AXI4 FULL MASTER 的IP，暂且取名为FDMA。 ZYNQ 配置 测试代码： 3下板测试
FPGA实现多路并行dds
weixin_42553916的博客
05-22 691
多路并行dds，传统DDS的局限性在于输出频率有限。根据奈奎斯特采样定理，单路DDS的输出频率应小于系统时钟频率的一半。但是在很多地方，要使采样率保持一致，所以，为了提高采样率，可以采样多路并行dds技术，然后并转串输出，提高采样率。假如fs是100MHz，调用4个并行的dds，然后按照顺序将4路并行的dds拼接成一路（并转串），这样就相当于采样率是4*fs,即400MHz采样率下的数据。可以从上式中看出，4路dds的pinc（频率控制字）是一样，差别是在其相位差（poff）DDS0的poff是0；
飞腾+FPGA多U多串全国产工控主机
最新发布
YEYUANGEN的专栏
05-31 480
飞腾多U多串工控主机基于国产化飞腾高性能8核D2000处理器平台的国产自主可控解决方案，搭载国产化固件,支持UOS、银河麒麟等国产操作系统，满足金融系统安全运算需求，实现从硬件、操作系统到应用的完全国产、自主、可控，是国产金融信息安全中控机明星解决方案。
xilinx startupe2原语使用
08-16
Xilinx STARTUPE2原语是一种用于FPGA配置启动时序的IP核。它可以在FPGA上实现重配置功能，即在FPGA上电后，使用存储在外部存储器中的配置比特流对FPGA进行初始化。在配置启动过程中，STARTUPE2原语可以实现多个重要的功能，包括配置比特流的加载、配置完成的检测、外部存储器的访问等。具体使用方法可以参考Xilinx官方文档<https://www.xilinx.com/support/documentation/application_notes/xapp1280-us-post-cnfg-flash-startupe3.pdf>中的程序说明。该文档提供了详细的操作步骤以及参考设计的示例。在参考设计中，一般会使用MicroBlaze软处理器内核连接到AXI Quad SPI内核，并通过STARTUPE2原语通过专用SPI接口实现对配置后的读写访问，以访问板载SPI闪存。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Xilinx FPGA原语的使用方法pdf\Xilinx原语的使用方法2.pdf](https://download.csdn.net/download/hglikun/2539977)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [使用STARTUPE3原语通过SPI Flash实现UltraScale FPGA的局部重配置（一）](https://blog.csdn.net/qq_34670507/article/details/115913601)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值