【FPGA/verilog -入门学习17】vivado 实现串口自发自收程序

最新推荐文章于 2024-06-14 10:16:18 发布
最新推荐文章于 2024-06-14 10:16:18 发布
阅读量675 收藏 11
点赞数 5
分类专栏： verilog &FPGA 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cengqiu4314/article/details/135505299
版权

1，需求

PC使用串口助手给FPGA板发送9600 波特率的数据，FPGA板接收到数据后，回复同样的数据给PC

2，需求分析

按模块可以划分为：

rx接收模块，将输入的8位并行rx 数据转换成[7:0]rx_data 信号，当数据接收完成后，同时生成一个rx_done 信号。

bsp_generate_clk_en:接收波特率时钟产生模块，当rx接收到数据时，给一个start信号给波特率时钟产生模块，由bsp时钟产生模块按9600波特率产生时钟使能信号bsp_generate_clk_en 用于同步rx 接收模块接收数据的时序。

tx发送模块：当接收到来子rx 接收模块发过来的rx_done 信号后，将[7:0]rx_data 的数据按波特率时钟产生模块的顺序依次发送出去。

bsp_generate_clk_en:发送波特率时钟产生模块，功能同接收模块

3，绘制框图和时序图

4，编写发送tx 模块，并编写行为测试模块代码测试其功能


`timescale 1ns/1ps

module testbench_top();
    

//参数定义

`define CLK_PERIORD        20        //时钟周期设置为20ns（50MHz）    


//接口申明
reg i_clk;
reg i_rest_n;
 
wire o_uart_tx;
wire o_uart_tx_done;


   

 vlg_design vlg_design_inst(
    .i_clk(i_clk),
    .i_rest_n(i_rest_n),
    .o_uart_tx(o_uart_tx),
    .o_uart_tx_done(o_uart_tx_done)
  
 );
 
initial begin
 
i_clk <= 0;
i_rest_n <= 0;
#20;
i_rest_n <= 1;


#2_000_000_000;
$stop;
 
end

always #(`CLK_PERIORD/2) i_clk = ~i_clk;
 
endmodule

//my_uart_tx
//put o_rx_data to i_uart_tx
  
`timescale 1ns/1ps
module vlg_1ms(
    input i_clk,  //25Mhz
    input i_rest_n,
    output [7:0]o_data, 
    output reg tx_en
    );

localparam CNT_1MS_MAX = 25*2000 - 1;

wire clk_25m;
wire clk_12r5m;
wire clk_100m;
wire locked;
 
clk_wiz_0 instance_name
(
    // Clock out ports
    .clk_out1(clk_25m),     // output clk_out1
    .clk_out2(clk_12r5m),     // output clk_out2
    .clk_out3(clk_100m),     // output clk_out3
    // Status and control signals
    .reset(!i_rest_n), // input reset
    .locked(locked),       // output locked
    // Clock in ports
    .clk_in1(i_clk) // input clk_in1
);      

// 每隔1ms 产生一个 tx_en 上升沿脉冲  
reg [15:0] r_cnt_1ms;    
always @(posedge i_clk) begin
    if(!i_rest_n) r_cnt_1ms <= 0;
    else if(r_cnt_1ms < CNT_1MS_MAX)  r_cnt_1ms <= r_cnt_1ms + 1;
    else r_cnt_1ms <= 0;
end    
    
always @(posedge i_clk) begin
    if(!i_rest_n) tx_en <= 0;
    else if(r_cnt_1ms == CNT_1MS_MAX)  tx_en <= 1;
    else tx_en <= 0;
end    
reg [7:0]r_data;
// 每隔1ms ，data = 0000_0001 自增 
always @(posedge i_clk) begin
    if(!i_rest_n)  r_data <= 0;
    else if(r_data == 100) r_data <= 0;
    else if(r_cnt_1ms == CNT_1MS_MAX) r_data <= r_data+1;
    else ;
    end

assign o_data = r_data;




endmodule


//my_uart_tx
//put o_rx_data to i_uart_tx
  
`timescale 1ns/1ps
module vlg_design(
    input i_clk,  //25Mhz
    input i_rest_n,
    output  o_uart_tx,    
    output  o_uart_tx_done 
    );


wire clk_25m;
wire clk_12r5m;
wire clk_100m;
wire locked;
 
wire tx_bps_start;
wire o_bps_clk_en;

wire [7:0]w_data;
wire w_tx_en;

  clk_wiz_0 instance_name
   (
    // Clock out ports
    .clk_out1(clk_25m),     // output clk_out1
    .clk_out2(clk_12r5m),     // output clk_out2
    .clk_out3(clk_100m),     // output clk_out3
    // Status and control signals
    .reset(!i_rest_n), // input reset
    .locked(locked),       // output locked
   // Clock in ports
    .clk_in1(i_clk));      // input clk_in1


    
//对被测试的设计进行例化
    
vlg_speed_generate        vlg_speed_generate_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_bps_start(tx_bps_start),
    .o_bps_clk_en(o_bps_clk_en) 
    );    
    
    
///

 vlg_my_uart_tx vlg_my_uart_tx_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_uart_tx_bps_en(o_bps_clk_en),
    .i_rx_data(w_data),
    .tx_en(w_tx_en),
    .tx_bps_start(tx_bps_start),
    .o_uart_tx(o_uart_tx),
    .o_uart_tx_done(o_uart_tx_done)
  
 );
 ///

 vlg_1ms vlg_1ms_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .o_data(w_data),
    .tx_en(w_tx_en)
 );
 endmodule


//my_uart_tx
//put o_rx_data to i_uart_tx
  
`timescale 1ns/1ps
module vlg_my_uart_tx(
    input i_clk,  //25Mhz
    input i_rest_n,
    input i_uart_tx_bps_en, 
    input [7:0]i_rx_data, 
    input tx_en,
    output reg tx_bps_start,
    output reg o_uart_tx,    
    output reg o_uart_tx_done
    );
    
reg [3:0]txdata_cnt;    
    

//检测tx_en 的高电平脉冲
//检测到高脉冲 tx_bps_start 置1
//当数据发送完成，即start，D0~D7，Stop .txdata_cnt = 10 时结束tx_bps_start 置0


reg [1:0]r_tx_en_plus;
wire w_tx_en_pos;


always @(posedge i_clk) begin
    if(!i_rest_n) r_tx_en_plus <= 2'b00;
    else r_tx_en_plus <= {r_tx_en_plus[0],tx_en};
end

assign w_tx_en_pos = r_tx_en_plus[0]& ~r_tx_en_plus[1];


//产生 tx_bps_start
always @(posedge i_clk) begin
if(!i_rest_n) tx_bps_start <= 0;
else if(txdata_cnt == 11) tx_bps_start <= 0;
else if(w_tx_en_pos) tx_bps_start <= 1;
end


//txdata_cnt 计数 0~10 
always @(posedge i_clk) begin
if(!i_rest_n) txdata_cnt <= 0;
else if(txdata_cnt == 11)  txdata_cnt <= 0;
else if(i_uart_tx_bps_en) txdata_cnt <= txdata_cnt + 1;
end

//发出o_uart_tx
wire [9:0]w_data_10 = {1'b1,i_rx_data,1'b0}; // 1,d7,d6,d5,d4,d3,d2,d1,d0,0
always @(posedge i_clk) begin
    if(!i_rest_n) o_uart_tx <= 1;
    else if(i_uart_tx_bps_en)  begin 
            case (txdata_cnt)
                0: o_uart_tx <= w_data_10[0];
                1: o_uart_tx <= w_data_10[1];
                2: o_uart_tx <= w_data_10[2];
                3: o_uart_tx <= w_data_10[3];
                4: o_uart_tx <= w_data_10[4];
                5: o_uart_tx <= w_data_10[5];
                6: o_uart_tx <= w_data_10[6];
                7: o_uart_tx <= w_data_10[7];
                8: o_uart_tx <= w_data_10[8];
                9: o_uart_tx <= w_data_10[9];
                10: o_uart_tx <= 1;
                default : o_uart_tx <= 1;
            endcase 
        end
end

//o_uart_tx_done
always @(posedge i_clk) begin
if(!i_rest_n) o_uart_tx_done <= 0;
else if(txdata_cnt == 11)  o_uart_tx_done <= 1;
else  o_uart_tx_done <= 0;
end



endmodule


 
`timescale 1ns/1ps
module vlg_speed_generate(
    input i_clk,  //input 25Mhz
    input i_rest_n,
    input i_bps_start,
    output reg o_bps_clk_en
    );

localparam bpsrate = 115200;
localparam BPS_COUNT_MAX = 1*25*1000_000/bpsrate - 1;
localparam BPS_COUNT_MAX_DIV_2 = 1*25*1000_000/bpsrate/2-1;


reg [11:0]bsp_cnt;
 
always @(posedge i_clk) begin
if(!i_rest_n) bsp_cnt <= 0;
else if(!i_bps_start) bsp_cnt <= 0;
else if(bsp_cnt < BPS_COUNT_MAX)  bsp_cnt <= bsp_cnt+1;
    else bsp_cnt <= 0;
end
 
 
always @(posedge i_clk) begin
    if(!i_rest_n) o_bps_clk_en <= 0;
    else if (bsp_cnt == BPS_COUNT_MAX_DIV_2)  o_bps_clk_en <= 1;
    else o_bps_clk_en <= 0;
end

endmodule

仿真波形

5，编写RX接收模块，并编写行为测试模块代码测试其功能


`timescale 1ns/1ps

module testbench_top();
    

//参数定义

`define CLK_PERIORD        20        //时钟周期设置为20ns（50MHz）    


//接口申明
reg [7:0]data;
reg i_clk;
reg i_rest_n;
reg i_rx;

 
wire o_uart_tx;
wire o_uart_tx_done;

wire i_uart_rx_bps_en;
wire [7:0]o_rx_data;
wire o_rx_start;
wire o_uart_rx_done;

wire locked;

  clk_wiz_0 instance_name
   (
    // Clock out ports
    .clk_out1(clk_25m),     // output clk_out1
    .clk_out2(clk_12r5m),     // output clk_out2
    .clk_out3(clk_100m),     // output clk_out3
    // Status and control signals
    .reset(!i_rest_n), // input reset
    .locked(locked),       // output locked
   // Clock in ports
    .clk_in1(i_clk));      // input clk_in1
    
 
 
vlg_my_uart_rx vlg_my_uart_rx_inst(

    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_rx(i_rx),
    .i_uart_rx_bps_en(i_uart_rx_bps_en),
    .o_rx_data(o_rx_data),
    .o_rx_start(o_rx_start),
    .o_uart_rx_done(o_uart_rx_done)

); 
 


 
 vlg_speed_generate        vlg_speed_generate_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_bps_start(o_rx_start),
    .o_bps_clk_en(i_uart_rx_bps_en) 
    );    
    
integer i;


 
initial begin
 
i_rx <= 1;
i_clk <= 0;
i_rest_n <= 0;
#20;
i_rest_n <= 1;
data <= 8'b0101_0101;  

end

always #(`CLK_PERIORD/2) i_clk = ~i_clk;


initial begin

 
@(posedge i_clk);
@(posedge i_rest_n);
#2000_000;
i_rx <= 0;
#10_4166;  //等待1个时钟 1_000_000_000 / 9600

for(i = 0;i<8;i=i+1) begin 
    i_rx <= data[i];
    #10_4166;
end
i_rx <= 1;
#10_4166;
#2000_000;


data <= 8'b0000_0101;  
i_rx <= 0;
#10_4166;  //等待1个时钟 1_000_000_000 / 9600

for(i = 0;i<8;i=i+1) begin 
    i_rx <= data[i];
    #10_4166;
end
i_rx <= 1;
#10_4166;
#2000_000;


data <= 8'b1111_0000;  
i_rx <= 0;
#10_4166;  //等待1个时钟 1_000_000_000 / 9600

for(i = 0;i<8;i=i+1) begin 
    i_rx <= data[i];
    #10_4166;
end
i_rx <= 1;
#10_4166;
#2000_000;


data <= 8'b0000_1111;  
i_rx <= 0;
#10_4166;  //等待1个时钟 1_000_000_000 / 9600

for(i = 0;i<8;i=i+1) begin 
    i_rx <= data[i];
    #10_4166;
end
i_rx <= 1;
#10_4166;
#2000_000;

$stop;

end


endmodule

//my_uart_tx
//put rx_data to i_uart_tx

`timescale 1ns/1ps
module vlg_design(
    input i_clk,  //25Mhz
    input i_rest_n,
    input i_rx,
    output o_tx
);

wire o_uart_tx;
wire o_uart_tx_done;
wire i_uart_rx_bps_en;
（*mark_debug = "true"*)wire [7:0]o_rx_data;
wire o_rx_start;
（*mark_debug = "true"*)wire o_uart_rx_done;
wire locked;


wire clk_25m;
wire clk_12r5m;
wire clk_100m;
wire locked;
 
wire tx_bps_start;
wire i_uart_tx_bps_en;


//灏唕x_data 杞垚 tx 
 ///

 vlg_my_uart_tx vlg_my_uart_tx_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_uart_tx_bps_en(i_uart_tx_bps_en),
    .i_rx_data(o_rx_data),
    .tx_en(o_uart_rx_done),
    .tx_bps_start(tx_bps_start),
    .o_uart_tx(o_tx),
    .o_uart_tx_done(o_uart_tx_done)
  
 );

    
vlg_speed_generate        vlg_speed_generate_tx_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_bps_start(tx_bps_start),
    .o_bps_clk_en(i_uart_tx_bps_en) 
    );    
    

//浜х敓rx 杞琩ata鏁版嵁
vlg_my_uart_rx vlg_my_uart_rx_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_rx(i_rx),
    .i_uart_rx_bps_en(i_uart_rx_bps_en),
    .o_rx_data(o_rx_data),
    .o_rx_start(o_rx_start),
    .o_uart_rx_done(o_uart_rx_done)
); 
  
 vlg_speed_generate        vlg_speed_generate_rx_inst(
    .i_clk(clk_25m),
    .i_rest_n(i_rest_n),
    .i_bps_start(o_rx_start),
    .o_bps_clk_en(i_uart_rx_bps_en) 
    );    


// 浜х敓鏃堕挓淇″彿
  clk_wiz_0 instance_name
   (
    // Clock out ports
    .clk_out1(clk_25m),     // output clk_out1
    .clk_out2(clk_12r5m),     // output clk_out2
    .clk_out3(clk_100m),     // output clk_out3
    // Status and control signals
    .reset(!i_rest_n), // input reset
    .locked(locked),       // output locked
   // Clock in ports
    .clk_in1(i_clk));      // input clk_in1


endmodule


//my_uart_tx
//put o_rx_data to i_uart_tx
  
`timescale 1ns/1ps
module vlg_my_uart_rx(
    input i_clk,  //25Mhz
    input i_rest_n,
    input（*mark_debug = "true"*) i_rx,  //杈撳叆 
    input i_uart_rx_bps_en, 
    
    output  [7:0]o_rx_data, 
    output reg o_rx_start,
    output reg o_uart_rx_done
    );
    
reg [3:0]rxdata_cnt;    
wire w_rx_pos;
reg  r_rx_start_pos;
reg [1:0]rx_plus;

always @(posedge i_clk) begin
    if(!i_rest_n)  rx_plus <= 2'b00;
    else rx_plus <= {rx_plus[0],i_rx};
end    

assign w_rx_pos = ~rx_plus[0] & rx_plus[1];// 鎵?鏈塺x 涓嬮檷娌?

///
//浜х敓 r_rx_start_pos 鑴夊啿锛屽綋rx 绗竴娆? = 0鏃讹紝杈撳嚭楂樼數骞筹紝鍏朵粬鏃跺埢鎷変綆
always @(posedge i_clk) begin
    if(!i_rest_n) r_rx_start_pos <= 0;
    else if(rxdata_cnt == 0) r_rx_start_pos <= w_rx_pos;
    else r_rx_start_pos <= 0;

end    



//妫?娴嬪埌 rx 1涓剦鍐茬殑涓嬮檷娌匡紝琛ㄧず淇″彿寮?濮嬶紝鎶?鏈粨鏉燂紝瀹屾垚
//o_rx_start
always @(posedge i_clk) begin
    if(!i_rest_n) o_rx_start <= 0;
    else if(rxdata_cnt == 11)o_rx_start <= 0;
    else if(r_rx_start_pos) o_rx_start <= 1;
    else  ;
end

//浜х敓rxdata_cnt璁℃暟
always @(posedge i_clk) begin
    if(!i_rest_n) rxdata_cnt <= 0;
    else if (rxdata_cnt == 11) rxdata_cnt <= 0;
    else if(i_uart_rx_bps_en)rxdata_cnt <= rxdata_cnt + 1;
    else ;
end

reg [7:0]r_rx_data;    
//鏀堕泦鏁版嵁
always @(posedge i_clk) begin
    if(!i_rest_n) r_rx_data <= 8'b0000_0000;  
   
     else if(i_uart_rx_bps_en)   
        case (rxdata_cnt)
            4'd0:    ;//start
            4'd1:    r_rx_data[0] <= i_rx;
            4'd2:    r_rx_data[1] <= i_rx;
            4'd3:    r_rx_data[2] <= i_rx;
            4'd4:    r_rx_data[3] <= i_rx;
            4'd5:    r_rx_data[4] <= i_rx;
            4'd6:    r_rx_data[5] <= i_rx;
            4'd7:    r_rx_data[6] <= i_rx;
            4'd8:    r_rx_data[7] <= i_rx;
            4'd9:;//stop
            4'd10:;//none
            default:;//none
        endcase 
 end    

assign o_rx_data= (rxdata_cnt == 11)?r_rx_data:o_rx_data;

//浜х敓o_uart_rx_done
always @(posedge i_clk) begin
    if(!i_rest_n)  o_uart_rx_done <= 0;
    else if(rxdata_cnt == 11) o_uart_rx_done <= 1;
    else o_uart_rx_done <= 0;  
end
endmodule

6，配置IO端口，生成bit文件烧录到板子测试

7，问题1：2024年1月10日

发送单个数据没有问题，但是连发出现异常数据。

对比代码发现例程代码的发送数据，结束位并没有保持1个bsp的完整高电平，而是只保持了一个脉冲的电平

修改代码后，测试ok

//my_uart_tx
//put o_rx_data to i_uart_tx
  
`timescale 1ns/1ps
module vlg_my_uart_tx(
    input i_clk,  //25Mhz
    input i_rest_n,
    input i_uart_tx_bps_en, 
    input [7:0]i_rx_data, 
    input tx_en,
    output reg tx_bps_start,
    output reg o_uart_tx,    
    output reg o_uart_tx_done
    );
    
reg [3:0]txdata_cnt;    
    

//检测tx_en 的高电平脉冲
//检测到高脉冲 tx_bps_start 置1
//当数据发送完成，即start，D0~D7，Stop .txdata_cnt = 10 时结束tx_bps_start 置0


reg [1:0]r_tx_en_plus;
wire w_tx_en_pos;


always @(posedge i_clk) begin
    if(!i_rest_n) r_tx_en_plus <= 2'b00;
    else r_tx_en_plus <= {r_tx_en_plus[0],tx_en};
end

assign w_tx_en_pos = r_tx_en_plus[0]& ~r_tx_en_plus[1];


//产生 tx_bps_start
always @(posedge i_clk) begin
if(!i_rest_n) tx_bps_start <= 0;
else if(txdata_cnt == 10) tx_bps_start <= 0;
else if(w_tx_en_pos) tx_bps_start <= 1;
end


//txdata_cnt 计数 0~10 
always @(posedge i_clk) begin
if(!i_rest_n) txdata_cnt <= 0;
else if(txdata_cnt == 10)  txdata_cnt <= 0;
else if(i_uart_tx_bps_en) txdata_cnt <= txdata_cnt + 1;
end

//发出o_uart_tx
wire [9:0]w_data_10 = {1'b1,i_rx_data,1'b0}; // 1,d7,d6,d5,d4,d3,d2,d1,d0,0
always @(posedge i_clk) begin
    if(!i_rest_n) o_uart_tx <= 1;
    else if(i_uart_tx_bps_en)  begin 
            case (txdata_cnt)
                0: o_uart_tx <= w_data_10[0];
                1: o_uart_tx <= w_data_10[1];
                2: o_uart_tx <= w_data_10[2];
                3: o_uart_tx <= w_data_10[3];
                4: o_uart_tx <= w_data_10[4];
                5: o_uart_tx <= w_data_10[5];
                6: o_uart_tx <= w_data_10[6];
                7: o_uart_tx <= w_data_10[7];
                8: o_uart_tx <= w_data_10[8];
                9: o_uart_tx <= w_data_10[9];
                default : o_uart_tx <= 1;
            endcase 
        end
end

//o_uart_tx_done
always @(posedge i_clk) begin
    if(!i_rest_n) o_uart_tx_done <= 0;
    else if(txdata_cnt == 10)  o_uart_tx_done <= 1;
    else  o_uart_tx_done <= 0;
end
endmodule

8，问题2：{} 数据合并要加上前缀

wire [9:0]w_data_10 = {1,i_rx_data,0}; //错误

wire [9:0]w_data_10 = {1'b1,i_rx_data,1'b0}; //正确

王者时代
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FPGA零基础学习：UART协议驱动设计
07-15 573
本系列将带来FPGA的系统性学习，从最基本的数字电路基础开始，最详细操作步骤，最直白的言语描述，手把手的“傻瓜式”讲解，让电子、信息、通信类专业学生、初入职场小白及打算进阶提升的职业开发者都可以有系统性学习的机会。 系统性的掌握技术开发以及相关要求，对个人就业以及职业发展都有着潜在的帮助，希望对大家有所帮助。后续会陆续更新 Xilinx 的 Vivado、ISE 及相关操作软件的开发的相关内容，学习FPGA设计方法及设计思想的同时，实操结合各类操作软件，会让你在技术学习道路上无比的顺畅，告别技术学习小BU
artix-7系列FPGA串口自发自收程序（基于verilog）
02-06
本代码使用vivado2018.3开发，在artix-7系列的FPGA平台上实现了波特率为9600的串口自发自收，已下载到开发板上验证，真实可用。保留了接口，方便接入其他模块调试。
Vivado简单串口实验，打印hello world
weixin_44115643的博客
04-30 4742
Vivado 2021简单串口实验，打印hello world
Vivado 串口通信(UART)------串口发送
hhh123987_的博客
02-19 996
Vivado 串口通信(UART)------串口发送
FPGA入门学习笔记（八）Vivado实现UART通信发送
weixin_45463952的博客
03-07 807
FPGA入门学习笔记（八）Vivado实现UART通信发送
4、vivado之uart串口数据发送与接收
scottar的博客
08-01 1万+
文章目录实验目标实验原理串口协议状态机设定关于波特率，采用115200的波特率设计实验代码rx_uartuart_txuart_top实验仿真仿真结果仿真代码总结 实验目标 常态下，fpga 侧实现1s一次的的数据发送。在空闲的时候， fpga侧实现串口的数据的接收，然后再通过串口将数据返回给上位机 实验原理 串口协议 状态机设定 关于波特率，采用115200的波特率设计 实验代码 说明：以下的代码是我照着黑金的修改后，形成的自己的代码，要看原来的代码可以参考黑金的资料。 rx_uart `times
Vivado 串口通信(UART)原理A ------串口发送实验
hhh123987_的博客
02-08 1203
Vivado zynq串口通信之串口发送实验
AD7606_IP_CORE.zip_VHDL/FPGA/Verilog_Vivado__VHDL/FPGA/Verilog_Vivado_
08-09
此压缩包包含了adc7606的 ip核，便于sopc调用
Video_power_workshop-master.zip_VHDL/FPGA/Verilog_Vivado_
08-09
基于数字ZYBO板和OpenCV视频库的一套简单的控制系统
实测亲测xilinx fpga uart 串口rs232例子实例工程，不出错发送接收数据测试，节省资源3根线串口，可以学习ip core用法verilog写
12-09
实测亲测xilinx fpga uart 串口rs232例子实例工程，ISE打包工程，不出错发送接收数据测试，无状态机，节省资源3根线串口，可以学习rs232串口和倍频ip core用法，字节编写，用verilog编写 基于一个xilinx的学习板子，具体io配置请看工程，测试内容内容是 pc 用 uart rs232发一个字节到fpga，fpga收到之后马上把字节加1发回给pc，uart的波特率是50m时钟，用到了ise的pll倍频，可以学习pll用法，uart 的 verilog 代码没有用到状态机，只用到txd，rxd，gnd这3根最基本的串口通讯线，极大的简化了fpga资源。整个工程打包，方便大家下载到之后可以马上用，相信对初学xilinx fpga 或者 ip cone用法的初学者来说，学习很用帮助。
FPGA纯verilog代码实现串口协议帧解析，提供vivado工程源码及仿真
01-18
内容摘要：请看csdn博文 csdn博文链接如下： ... 注意！注意！注意！ 1、请先认真看csdn博文，觉得有用再买哦；...4、纯verilog实现串口协议帧数据解码； 4、了解vivado仿真文件的设计思路和方法，提供仿真源码；
veriloga实例_verilog/verilog-a_PLLverilog_锁相放大器_锁相放大_
10-04
硬件描述语言，veriloga实例，包含运算放大器，锁相环等模块。
Vivado开发FPGA使用流程、教程 verilog（建立工程、编译文件到最终烧录的全流程）
热门推荐
weixin_45676874的博客
08-10 1万+
本文从建立工程到最终烧录，vivado的使用傻瓜式教程，都能会用，具体的原因有的可能没写需要自己查
FPGA学习笔记（三）——串口通信之发送数据（调试过程）
weixin_45719141的博客
05-08 4434
本学习笔记主要参考小梅哥B站教学视频，网址如下: https://www.bilibili.com/video/BV1va411c7Dz?p=1 使用的编译器为Vivado，HDL语言为verilog
VIVADO 常用IP使用-PLL
ed25137667的博客
12-11 311
2.PLL输入时钟配置。3.PLL|输出配置。
FPGA开发（五） 串口发送和接收实验
AlwaysSun的博客
03-15 2802
本次试验我们来学习
xilinx FPGA 串口设计笔记
u012129372的专栏
03-25 2540
xilinx FPGA  串口设计笔记 在设计中，需要用 FPGA 读取 GPS 内部的信息，GPS 的通信方式为串口，所以在 FPGA 中移植了串口程序。 本次移植的程序源代码是特权的串口程序，本以为移植应该很快就能完成， 但其中还是 出了一写小问题，耽误了不少的时间，下面将问题进行一个总结！ 以下是串口的时序： 在设计中，耽误时间最长的问题就是数据老是出错，为了找出问题的所在，用示
什么是仲裁器（Arbiter）？
最新发布
weixin_49007164的博客
06-14 633
在电子系统设计中，仲裁器（Arbiter）是关键组件，用于管理多设备或信号对共享资源（如总线、内存、I/O通道等）的竞争访问。通过确保公平和高效的资源分配，仲裁器提升了系统的性能和可靠性。本文将详细探讨仲裁器的作用、常见算法及其应用，并通过代码示例展示其实现。
采用创新的FPGA 器件来实现更经济且更高能效的大模型推理解决方案
mahuahu的博客
06-12 589
本文根据完整的基准测试，将Achronix Semiconductor公司推出的Speedster7t FPGA与GPU解决方案进行比较，在运行同一个Llama2 70B参数模型时，该项基于FPGA的解决方案实现了超越性的LLM推理处理。
VCS_OPT += -y /edatools/Xilinx/Xilinx/Xilinx_Vivado_2015_1/data/verilog/src/unisims什么意思？-y有什么含义
06-06
VCS_OPT += -y /edatools/Xilinx/Xilinx/Xilinx_Vivado_2015_1/data/verilog/src/unisims 是一个VCS编译器的选项。-y 表示添加目录到搜索路径中，这里的目录为 /edatools/Xilinx/Xilinx/Xilinx_Vivado_2015_1/data/...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值