FPGA UART串口设计与上板

最新推荐文章于 2024-09-16 20:25:04 发布
最新推荐文章于 2024-09-16 20:25:04 发布
阅读量683 收藏 16
点赞数 8
文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45682657/article/details/137187385
版权

目录

基本框架

代码设计

上板验证

基本框架

使用黑金 ARTIX-7 系列FPGA 开发平台（型号：AX7102，数据手册详见官网）实现UART接口RTL代码的设计，然后简单上板测试。可以配置协议数据位宽，校验类型，停止位宽度和波特率。

对于RX接收模块，使用串口调试工具发送数据，FPGA接收数据后，根据低4位数据点亮FPGA上的LED灯。

对于TX发送模块，为了简单测试模块的功能，在复位后简单打拍几下，将测试数据发送到串口调试工具上。

代码设计

代码主要包括三个模块和一个IP核。

IP核为一个分频模块，将FPGA的200M差分信号晶振分频为5M的时钟信号（主要为了后续项目，可以直接使用差分信号或者任意分频频率）。

一个UART发送模块uart_tx.v

module uart_tx#(
    parameter                       DATA_WIDTH  =   4'd8        ,
    parameter                       CHECKSUM    =   2'd2        , // 0:无校验位 1：奇校验 2：偶校验
    parameter                       STOP_WIDTH  =   2'd2        , // 1:1个停止位 2：2个停止位
    parameter                       BAUD        =   11520000    ,
    parameter                       FREQUENCY   =   50000000    )
(   input                           i_clk                       ,
    input                           i_rst                       ,
    input   [DATA_WIDTH - 1 : 0]    i_data                      ,
    input                           i_en                        ,
    output                          o_tx                        ,
    output                          o_valid                     );

/*--------------------------------parameter------------------------------*/
localparam  CLK     =   FREQUENCY/BAUD - 1                      ;

localparam  IDLE    =   8'b0000_0001                            ,
            START   =   8'b0000_0010                            ,
            TX      =   8'b0000_0100                            ,
            CHECK   =   8'b0000_1000                            ,
            STOP    =   8'b0001_0000                            ;

/*----------------------------------wire---------------------------------*/
wire [1 : 0] w_check_mode;

/*----------------------------------reg----------------------------------*/
reg [7 : 0] r_state;
reg [7 : 0] r_state_next;
reg [15: 0] r_clk_cnt;
reg [3 : 0] r_tx_cnt;
reg [1 : 0] r_stop_cnt;
reg         r_tx;
reg [DATA_WIDTH - 1 : 0] r_data;
reg         r_div_clk; // 仿真时看波形的，无实际意义
/*---------------------------------assign--------------------------------*/
assign o_valid = (r_state == IDLE);
assign o_tx = r_tx;

assign w_check_mode = CHECKSUM;
/*---------------------------------always--------------------------------*/
always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_data <= {DATA_WIDTH{1'b0}};
    end
    else if (i_en && (r_state == IDLE)) begin
        r_data <= i_data;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_state <= IDLE;
    end
    else begin
        r_state <= r_state_next;
    end
end

always @(*) begin
    case (r_state)
        IDLE    :begin
            if (i_en) begin
                r_state_next = START;
            end
            else begin
                r_state_next = r_state;
            end
        end
        START   :begin
            if (r_clk_cnt == CLK) begin
                r_state_next = TX;
            end
            else begin
                r_state_next = r_state;
            end
        end
        TX      :begin
            if ((r_clk_cnt == CLK) && (r_tx_cnt == (DATA_WIDTH - 1))) begin
                if (CHECKSUM == 2'd0) begin
                    r_state_next = STOP;
                end
                else begin
                    r_state_next = CHECK;
                end
            end
            else begin
                r_state_next = r_state;
            end
        end
        CHECK   :begin
            if (r_clk_cnt == CLK) begin
                r_state_next = STOP;
            end
            else begin
                r_state_next = r_state;
            end
        end
        STOP    :begin
            if ((r_clk_cnt == CLK) && (r_stop_cnt == (STOP_WIDTH - 1))) begin
                r_state_next = IDLE;
            end
            else begin
                r_state_next = r_state;
            end
        end
        default :begin
            r_state_next = IDLE;
        end
    endcase
end

always @(*) begin
    case (r_state)
        IDLE    :begin
            r_tx = 1'b1;
        end
        START   :begin
            r_tx = 1'b0;
        end
        TX      :begin
            r_tx = r_data[r_tx_cnt];
        end
        CHECK   :begin
            if (w_check_mode == 2'd1) begin // 奇校验
                r_tx = ~(^r_data);
            end
            else begin
                r_tx = ^r_data;
            end
        end
        STOP    :begin
            r_tx = 1;
        end
        default :begin
            r_tx = 1;
        end
    endcase
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_clk_cnt <= 16'b0;
    end
    else if (r_clk_cnt == CLK) begin
        r_clk_cnt <= 16'b0;
    end
    else if (r_state != IDLE) begin
        r_clk_cnt <= r_clk_cnt + 1;
    end
    else begin
        r_clk_cnt <= 16'b0;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_div_clk <= 1'b0;
    end
    else if (r_clk_cnt == CLK) begin
        r_div_clk <= ~r_div_clk;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_tx_cnt <= 4'b0;
    end
    else if ((r_state == TX) && (r_clk_cnt == CLK)) begin
        if (r_tx_cnt == (DATA_WIDTH - 1)) begin
            r_tx_cnt <= 4'b0;
        end
        else begin
            r_tx_cnt <= r_tx_cnt + 1;
        end
    end
    else if (r_state != TX) begin
        r_tx_cnt <= 4'b0;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_stop_cnt <= 2'b0;
    end
    else if ((r_state == STOP) && (r_clk_cnt == CLK)) begin
        if (r_stop_cnt == STOP_WIDTH - 1) begin
            r_stop_cnt <= 2'b0;
        end
        else begin
        r_stop_cnt <= r_stop_cnt + 1;
        end
    end
    else if (r_state != STOP) begin
        r_stop_cnt <= 2'b0;
    end
end

/*----------------------------------inst---------------------------------*/

endmodule

一个UART接收模块uart_rx.v

module uart_rx#(    
    parameter                       DATA_WIDTH  =   4'd8        ,
    parameter                       CHECKSUM    =   2'd0        , // 0:无校验位 1：奇校验 2：偶校验
    parameter                       STOP_WIDTH  =   2'd2        , // 1:1个停止位 2：2个停止位
    parameter                       BAUD        =   115_200     ,
    parameter                       FREQUENCY   =   5_000_000   )
(   input                           i_clk                       ,
    input                           i_rst                       ,
    input                           i_data                      ,
    output  [DATA_WIDTH - 1 : 0]    o_rx                        ,
    output                          o_done                      ,
    output                          o_error                     );

/*--------------------------------parameter------------------------------*/
localparam  CLK         =   FREQUENCY/BAUD - 1                  ;
localparam  CLK_SAMPLE  =   FREQUENCY/(2*BAUD) - 1              ;

localparam  IDLE        =   8'b0000_0001                        ,
            START       =   8'b0000_0010                        ,
            RX          =   8'b0000_0100                        ,
            CHECK       =   8'b0000_1000                        ,
            STOP        =   8'b0001_0000                        ;
/*----------------------------------wire---------------------------------*/
wire w_data_negedge;
wire [1 : 0] w_checksum_mode;
wire w_sample_en;
/*----------------------------------reg----------------------------------*/
reg [DATA_WIDTH - 1 : 0] r_rx;
reg [7 : 0] r_state;
reg [7 : 0] r_state_next;

reg r_data_d1; // 判断下降沿

reg r_check;
reg r_error;

reg [15: 0] r_clk_cnt;
reg r_div_clk;
reg [3 : 0] r_rx_cnt;

/*---------------------------------assign--------------------------------*/
assign o_rx = r_rx;
assign o_done = (r_state == STOP);
assign o_error = r_error;

assign w_data_negedge = (r_state == IDLE) ? ((~i_data) & r_data_d1) : 1'b0;
assign w_checksum_mode = CHECKSUM;
assign w_sample_en = ((r_state == RX) || (r_state == CHECK)) ? (r_clk_cnt == CLK_SAMPLE) : 1'b0;
/*---------------------------------always--------------------------------*/
always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_state <= IDLE;
    end
    else begin
        r_state <= r_state_next;
    end
end

always @(*) begin
    case (r_state)
        IDLE    :begin
            if (w_data_negedge) begin
                r_state_next = START;
            end
            else begin
                r_state_next = r_state;
            end
        end
        START   :begin
            if (r_clk_cnt == CLK) begin
                r_state_next = RX;
            end
            else begin
                r_state_next = r_state;
            end
        end
        RX      :begin
            if ((r_clk_cnt == CLK) && (r_rx_cnt == (DATA_WIDTH - 1))) begin
                if (w_checksum_mode == 2'd0) begin
                    r_state_next = STOP;
                end
                else begin
                    r_state_next = CHECK;
                end
            end
            else begin
                r_state_next = r_state;
            end
        end
        CHECK   :begin
            if (r_clk_cnt == CLK) begin
                r_state_next = STOP;
            end
            else begin
                r_state_next = r_state;
            end
        end
        STOP    :begin
            if (r_clk_cnt == CLK) begin
                r_state_next = IDLE;
            end
            else begin
                r_state_next = r_state;
            end
        end
        default :begin
            r_state_next = IDLE;
        end
    endcase
end

always @(posedge i_clk) begin
    case (r_state)
        IDLE    :begin
            r_rx <= {DATA_WIDTH{1'b0}};
        end
        START   :begin
            r_rx <= r_rx;
        end
        RX      :begin
            if (w_sample_en) begin
                r_rx[r_rx_cnt] <= i_data;
            end
        end
        CHECK   :begin
            r_rx <= r_rx;
        end
        STOP    :begin
             r_rx <= r_rx;
        end
        default :begin
            r_rx <= {DATA_WIDTH{1'b0}};        
        end
    endcase
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_clk_cnt <= 16'b0;
    end
    else if (r_clk_cnt == CLK) begin
        r_clk_cnt <= 16'b0;
    end
    else if (r_state != IDLE) begin
        r_clk_cnt <= r_clk_cnt + 1;
    end
    else begin
        r_clk_cnt <= 16'b0;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_check <= 1'b0;
    end
    else if ((r_state == CHECK) && w_sample_en && (w_checksum_mode != 2'd0)) begin
        r_check <= i_data;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_div_clk <= 1'b0;
    end
    else if (r_clk_cnt == CLK) begin
        r_div_clk <= ~r_div_clk;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_rx_cnt <= 4'b0;
    end
    else if ((r_state == RX) && (r_clk_cnt == CLK)) begin
        if (r_rx_cnt == (DATA_WIDTH - 1)) begin
            r_rx_cnt <= 4'b0;
        end
        else begin
            r_rx_cnt <= r_rx_cnt + 1;
        end
    end
    else if (r_state != RX) begin
        r_rx_cnt <= 4'b0;
    end
end

always @(posedge i_clk or posedge i_rst) begin
    if (i_rst) begin
        r_data_d1 <= 1'b0;
    end
    else begin
        r_data_d1 <= i_data;
    end
end

always @(*) begin
    if (r_state == STOP) begin
        if (w_checksum_mode == 2'd0) begin
            r_error = 1'b0;
        end
        else if (w_checksum_mode == 2'd1) begin
            if (r_check != (^r_rx)) begin
                r_error = 1'b0;
            end
            else begin
                r_error = 1'b1;
            end
        end
        else if (w_checksum_mode == 2'd2) begin
            if (r_check == (^r_rx)) begin
                r_error = 1'b0;
            end
            else begin
                r_error = 1'b1;
            end
        end
    end
    else begin
        r_error = 1'b0;
    end
end
/*----------------------------------inst---------------------------------*/

endmodule

最后是顶层模块top.v

在顶层模块里进行例化和参数配置。同时进行异步复位同步释放和发送模块的简单测试。

module top(
    input                       i_sys_clk_p     , // 200M
    input                       i_sys_clk_n     , // 200M
    input                       i_sys_rstn      ,
    input                       i_data_uart     , // uart_rx
    output                      o_uart_tx       ,
    output                      o_LED0          ,
    output                      o_LED1          ,
    output                      o_LED2          ,
    output                      o_LED3          );


/*--------------------------------parameter------------------------------*/
parameter                       DATA_WIDTH  =   4'd8        ;
parameter                       CHECKSUM    =   2'd0        ;
parameter                       STOP_WIDTH  =   2'd2        ;
parameter                       BAUD        =   115200      ;
parameter                       FREQUENCY   =   5_000_000   ;
/*----------------------------------wire---------------------------------*/
wire w_clk_5M; // 5M
wire w_rst_syn;
wire w_uart_rx_done;
wire w_uart_done_posedge; // rx_done信号上升沿
wire [DATA_WIDTH - 1:0] w_uart_data;
wire w_uart_error;
wire w_uart_tx_valid;
/*----------------------------------reg----------------------------------*/
reg [7:0] r_cnt;
reg r_rstn_d1;
reg r_rstn_syn; // 异步复位同步释放
reg [DATA_WIDTH - 1:0] r_uart_data;
reg r_uart_done_d1;
reg [DATA_WIDTH - 1:0] r_uart_tx;
reg r_uart_tx_en;
/*---------------------------------assign--------------------------------*/
assign w_rst_syn = ~r_rstn_syn; // 高电平复位
assign o_LED0 = r_uart_data[0];
assign o_LED1 = r_uart_data[1];
assign o_LED2 = r_uart_data[2];
assign o_LED3 = r_uart_data[3];
assign w_uart_done_posedge = w_uart_rx_done & (~r_uart_done_d1);
/*---------------------------------always--------------------------------*/
always @(posedge w_clk_5M or negedge r_rstn_syn) begin
    if (!r_rstn_syn) begin
        r_cnt <= 8'b0;
        r_uart_tx <= {DATA_WIDTH{1'b1}};
        r_uart_tx_en <= 1'b0;
    end
    else if ((r_cnt == 8'd100) && w_uart_tx_valid) begin
        r_uart_tx_en <= 1'b1;
    end
    else if (r_cnt <= 8'd200) begin
        r_cnt <= r_cnt + 1;
        r_uart_tx_en <= 1'b0;
    end
end

always @(posedge w_clk_5M or negedge r_rstn_syn) begin
    if (!r_rstn_syn) begin
        r_uart_done_d1 <= 1'b0;
    end
    else begin
        r_uart_done_d1 <= w_uart_rx_done;
    end
end

always @(posedge w_clk_5M or negedge r_rstn_syn) begin
    if (!r_rstn_syn) begin
        r_uart_data <= {DATA_WIDTH{1'b1}};
    end
    else if (w_uart_error) begin
        r_uart_data <= {DATA_WIDTH{1'b1}};
    end
    else if (w_uart_done_posedge) begin
        r_uart_data <= w_uart_data;
    end
end

always @(posedge w_clk_5M or negedge i_sys_rstn) begin
    if (!i_sys_rstn) begin
        r_rstn_d1 <= 1'b0;
        r_rstn_syn <= 1'b0;
    end
    else begin
        r_rstn_d1 <= i_sys_rstn;
        r_rstn_syn <= r_rstn_d1;
    end
end
/*----------------------------------inst---------------------------------*/
uart_tx #(
    .DATA_WIDTH (DATA_WIDTH         ),
    .CHECKSUM   (CHECKSUM           ),
    .STOP_WIDTH (STOP_WIDTH         ),
    .BAUD       (BAUD               ),
    .FREQUENCY  (FREQUENCY          ))
    uart_tx_inst(   
    .i_clk      (w_clk_5M           ),
    .i_rst      (w_rst_syn          ),
    .i_data     (r_uart_tx          ),
    .i_en       (r_uart_tx_en       ),
    .o_tx       (o_uart_tx          ),
    .o_valid    (w_uart_tx_valid    ));


uart_rx #(
    .DATA_WIDTH (DATA_WIDTH         ),
    .CHECKSUM   (CHECKSUM           ),
    .STOP_WIDTH (STOP_WIDTH         ),
    .BAUD       (BAUD               ),
    .FREQUENCY  (FREQUENCY          ))
    uart_rx_inst(   
    .i_clk      (w_clk_5M           ),
    .i_rst      (w_rst_syn          ),
    .i_data     (i_data_uart        ),
    .o_rx       (w_uart_data        ),
    .o_done     (w_uart_rx_done     ),
    .o_error    (w_uart_error       ));

clk_wiz_0 clock_div(    
    .clk_in1_n  (i_sys_clk_n        ),               
    .clk_in1_p  (i_sys_clk_p        ),               
    .resetn     (i_sys_rstn         ),           
    .clk_out1   (w_clk_5M           ));

endmodule

上板验证

首先进行管脚的约束，具体内容参考官方手册。

这里遇到一个问题，对于差分信号我们只需要约束p管脚就行，好像会自动约束n管脚。

set_property PACKAGE_PIN T6 [get_ports i_sys_rstn]
set_property IOSTANDARD LVCMOS15 [get_ports i_sys_rstn]

set_property PACKAGE_PIN R4 [get_ports i_sys_clk_p]
set_property IOSTANDARD DIFF_SSTL15 [get_ports i_sys_clk_p]

set_property PACKAGE_PIN Y12 [get_ports i_data_uart]
set_property IOSTANDARD LVCMOS33 [get_ports i_data_uart]

set_property PACKAGE_PIN C17 [get_ports o_LED0]
set_property IOSTANDARD LVCMOS33 [get_ports o_LED0]
set_property PACKAGE_PIN D17 [get_ports o_LED1]
set_property IOSTANDARD LVCMOS33 [get_ports o_LED1]
set_property PACKAGE_PIN V20 [get_ports o_LED2]
set_property IOSTANDARD LVCMOS33 [get_ports o_LED2]
set_property PACKAGE_PIN U20 [get_ports o_LED3]
set_property IOSTANDARD LVCMOS33 [get_ports o_LED3]

set_property PACKAGE_PIN Y11 [get_ports o_uart_tx]
set_property IOSTANDARD LVCMOS33 [get_ports o_uart_tx]

最后将比特流进行烧录，使用micro USB连接uart端口，在Microsoft Store下载了一个串口调试助手，然后需要去下载一个驱动，就可以进行数据的收发。

在收发的过程中，将数据类型选为16进制显示，比如发送一个8位aa，LED0和LED2会点亮。按一下复位键，PC就会接收到FPGA发送的ff数据。

OFFER快快来
关注
UART的RTL逻辑设计部分 - uart_rx
Starry__的博客
05-09 1780
目录1. IDLE：等待串数据到来2. REC：串并转换3. ARB：裁决校验位3.1. valid&ready 的Slave读握手3.2. 异步FIFO 的Master写握手3. 基于valid&ready握手 的UART_RX代码4. 基于异步FIFO 的UART_RX代码 当UART完成了模块分解和输出之后，就可以开始设计逻辑了，设计好了再写代码！！！！ 接受模块的流程应该是这样的：先是空闲，然后rx出现低电平表示单bit数据来了，开始串转并，转好之后判断校验位，未通过直接丢掉，通过
FPGA实现串口（UART）
热门推荐
孤独的单刀
03-10 26万+
通过本文您会学到：1、什么是UART？2、如何用FPGA实现它？
从Verilog实现UART到RS232串口收发，RTL和仿真代码全注释，使用ISE或者QUARTUS开发工具，功能包括接收电脑串口调试助手发送的数据并发送回去，同时在调试助手界面显示，RS232协议
lbsfzPpDQgc的博客
06-14 358
其中，时钟信号用于同步数据的传输，复位信号用于初始化模块的状态，串口数据输入信号用于接收外部设备发送过来的数据，串口数据输出信号用于发送数据给外部设备，数据接收完成信号用于指示数据接收完成。起始位用于标识数据的开始，停止位用于标识数据的结束。在顶层模块中，我们可以将UART模块的输入和输出接口与其他模块进行连接，并通过读取和写入寄存器来实现对UART模块的控制和配置。同时，我们还可以使用模块化设计的思想，将UART模块拆分成多个子模块，分别实现不同的功能，如数据接收模块、数据发送模块等。
VIVADO中UART IP核使用
05-21
VIVADO中UART IP核 使用的是AXI-lite通信协议，外部接口分别为RX、TX以及Interrupt。该工程中使用了UART IP核，并且写了AXI-Lite mater部分代码实现UART IP核通信，在tb文件中写了UART rtl代码，可实现IP核与代码直接的发送接收。代码可直接进行仿真。
利用FPGA实现UART的设计
sky156的专栏
06-09 6218
引 言随着电脑技术的发展和广泛应用，尤其是在工业控制领域的应用越来越广泛，电脑通信显的尤为重要。串行通信虽然使设备之间的连线大为减少，但随之带来串／并转换和位计数等问题，这使串行通信技术比并行通信技术更为复杂。串／并转换可用软件实现，也可用硬件实现。用软件实现串行传送大多采用循环移位指令将一个字节由高位到低位(或低位到高位)一位一位依次传送，这种方法虽然简单但速度慢，而且大量占用CPU的时间，
FPGA 学习之路 （七） UART串口设计
无知人生,记录点滴
01-28 2万+
UART串口通信协议的Verilog实现
FPGA_UART.zip_FGPA uart_FPGA串口_UART 串口通信_fpga_uart
09-23
本资源“FPGA_UART.zip”显然包含了实现FPGA上的UART功能的相关代码，这对于我们理解FPGA与外部设备间通过UART进行串口通信至关重要。 UART通信的基本原理是，通过一根数据线进行数据传输，数据以字节为单位，一次...
Verilog HDL设计UART串口读写测试FPGA逻辑Quartus工程文件.zip
03-14
Verilog HDL设计UART串口读写测试FPGA逻辑Quartus工程文件，通过串口接收PC发送的字符然后将收到的字符发送给PC，FPGA型号Cyclone4E系列中的EP4CE10F17C8，Quartus版本18.0。 module uart_top( input sys_clk, //...
基于FPGA的以太网、UART串口、USB通信接口设计：实现高速数据传输与易用性
ZnyjEMWFB的博客
04-27 1157
为了实现基于FPGA的以太网、UDP IP、千兆网络、UART串口、USB通信接口设计，首先需要选择适合的开发板，并购买相应的硬件资源。然后，根据选定的硬件资源和接口设计要求，进行电路设计和PCB布局。本设计基于FPGA开发板，通过实现以太网、UDP IP、千兆网络、UART串口、USB等通信接口协议，旨在方便用户进行数据传输。本设计是在FPGA开发板上实现以太网、UART串口、USB等通信接口协议，使用者可以在不了解具体通信协议下完成FPGA到PC的数据传输，当然也可以实现从PC到FPGA的数据传输。
uart.rar_fpga uart_uart fpga_uart verilog
09-20
UART（通用异步收发传输器）是一种广泛用于设备间通信的串行接口标准，尤其在嵌入式系统和FPGA（现场可编程门阵列）设计中非常常见。本资源"uart.rar_fpga uart_uart fpga_uart verilog"提供了一个FPGA实现UART的...
UART（串口）收发模块设计
qq_38306698的博客
02-26 2083
关注微信公众号：小鱼学IC，获取串口(uart)的Verilog设计源码详解与demo。 《UART（串口）收发模块设计- 01》 https://mp.weixin.qq.com/s?__biz=MzUyMzc2NTY3Mg==&mid=2247484170&idx=1&sn=7cd143c32b716e4d6d25e775f2363e8c&chksm=fa...
RTL设计之状态机讲解
青春易逝，愿不负昭华，期待梦与远方
02-26 3304
目录 1、状态机FSM 1.1 一段/二段/三段状态机对比 1.2 FSM 1.2.1 摩尔机（Moore Machine） 1.2.2 米利机（Mealy Machine） 1.2.3 一段式状态机（时钟闭节点机器） 1.2.4 二段式状态机（时钟开节点机器） 1.2.5 三段式状态机（时钟闭节点机器） 2、状态机实践 2.1一段式状态机 2.2两段式状态机 2.3三段式...
UART的RTL逻辑设计部分 - uart_tx
Starry__的博客
05-03 1607
目录1. IDLE：等待并数据到来1.1. valid&ready 的Slave写握手1.2. 异步FIFO 的Master读握手2. TRANS：并串转换2.1. 打包tx_data_frm2.2. 并串转换2.3. 发送完毕标志3. 基于valid&ready握手 的UART_TX代码4. 基于异步FIFO 的UART_TX代码 当UART完成了模块分解和输出之后，就可以开始设计逻辑了，设计好了再写代码！！！！ 还是先从外围模块开始，UART_TX模块的功能比较简单，将多bit数据按照
【FPGA开发】比特文件的压缩
最新发布
qq1016019583的博客
09-16 945
FPGA比特文件的压缩是常见的处理，文章对其进行了详细介绍。
易灵思FPGA开发（一）——软件安装
weixin_73538444的博客
09-09 630
双击第一个.msi文件进行安装。下载Gtkwave软件。安装USB下载器驱动。
深入解析软硬复位
weixin_42929997的博客
09-13 1285
在集成电路IC设计中，复位是一个至关重要的过程，它用于保证芯片的各个模块在启动、故障或其他特定条件下能重新回到初始状态。复位通常可以分为三类：硬复位、软复位以及上电复位。这三类复位虽然都有相似的目标，但其产生机制和作用范围各不相同。
FPGA开发：模块 × 实例化
qq_74114817的博客
09-07 1443
就相当于确定了这个芯片有哪些端口（引脚），而下面的。
vivado 时间汇总报告
cckkppll的博客
09-09 492
vivado 时间汇总报告
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值