FPGA串口通信之Uart发送（基础及应用）

已于 2024-04-08 14:32:39 修改
阅读量378 收藏 4
点赞数 9
文章标签： fpga开发
于 2024-04-08 13:13:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mvpkuku/article/details/137473443
版权

一、Uart 发送模块编写和测试

​
`timescale 1ns / 1ps

module uart_tx(
    clk         ,
    rst         ,
    baud_set    ,
    send_go     ,
    data        ,
    uart_tx     ,
    tx_done     
);

input               clk         ;
input               rst         ;
input[2:0]          baud_set    ;
input               send_go     ;
input[7:0]          data        ;
output              uart_tx     ;
output              tx_done     ;

reg                 r_uart_tx     ;
reg                 r_tx_done     ;


reg[17:0]           baud_cnt     ; 
reg[17:0]           baud_counter ;
reg[3:0]            counter1     ;
reg                 bps_clk      ;
reg                 send_en      ;
reg[7:0 ]           r_data       ;

assign              uart_tx    =  r_uart_tx     ;
assign              tx_done    =  r_tx_done     ;

always@(*)begin //波特率选择
    case (baud_set)
        3'd0: baud_cnt <= 1_000_000_000 / 4800 /20    ;
        3'd1: baud_cnt <= 1_000_000_000 / 9600 /20    ;
        3'd2: baud_cnt <= 1_000_000_000 / 14400 /20   ;
        3'd3: baud_cnt <= 1_000_000_000 / 19200 /20   ;
        3'd4: baud_cnt <= 1_000_000_000 / 38400 /20   ;
        3'd5: baud_cnt <= 1_000_000_000 / 56000 /20   ;
        3'd6: baud_cnt <= 1_000_000_000 / 57600 /20   ;
        3'd7: baud_cnt <= 1_000_000_000 / 115200 /20  ;
        default: baud_cnt <= 1_000_000_000 / 4800 /20 ;
    endcase
end
always@(posedge clk,negedge rst)begin
    if(!rst)
        send_en <= 0;
    else if(send_go)
        send_en <= 1;
    else if(tx_done)
        send_en <= 0;
    else
        send_en <= send_en;
end
always@(posedge clk ,negedge rst)begin //波特率计数器，最小计时单位
    if(!rst)
        baud_counter <= 0;
    else if(send_en)begin
        if(baud_counter == baud_cnt - 1)
            baud_counter <= 0;
        else
            baud_counter <= baud_counter + 1;
    end
    else
         baud_counter <= 0;
end
always@(posedge clk ,negedge rst)begin //波特率时钟生成
    if(!rst)
        bps_clk <= 0;
    else if(baud_counter ==  1)
        bps_clk <= 1;
    else
        bps_clk <= 0;
end
always@(posedge clk ,negedge rst)begin
    if(!rst)
        counter1 <= 0;
    else if(send_en) begin
        if(counter1 == 11 && baud_counter == 1)
            counter1 <= 0;
        else if(baud_counter == 1)
            counter1 <= counter1 + 1;
        else
            counter1 <= counter1;
    end
    else
        counter1 <= 0;
end

always@(posedge clk ,negedge rst)begin
    if(!rst)
        r_data <= 0;
    else if(send_go)
        r_data <= data;
    else
        r_data <= r_data;
end

always@(posedge clk ,negedge rst)begin
    if(!rst)
            r_uart_tx <= 1;
    else begin
        case (counter1)
            4'd1: r_uart_tx <= 0;
            4'd2: r_uart_tx <= r_data[0];
            4'd3: r_uart_tx <= r_data[1];
            4'd4: r_uart_tx <= r_data[2];
            4'd5: r_uart_tx <= r_data[3];
            4'd6: r_uart_tx <= r_data[4];
            4'd7: r_uart_tx <= r_data[5];
            4'd8: r_uart_tx <= r_data[6];
            4'd9: r_uart_tx <= r_data[7];
            4'd10: r_uart_tx <= 1;
            4'd11: r_uart_tx <= 1; 
            default:r_uart_tx <= 1;  
        endcase
    end 
end
always@(posedge clk ,negedge rst)begin
    if(!rst)
        r_tx_done <= 0;
    else if(bps_clk==1 && counter1 == 11)
        r_tx_done <= 1;
    else
        r_tx_done <= 0;
end

 

endmodule

​

PS: 1.在编写代码是，counter1从1开始传输起始位，是为了避免ounter1==0时与空闲状态重合。 

2.baud_counter == 1是为了缩小起始位的到达时间，这样就可以很快的进入到counter1== 1 的状态，从而实现起始位的传输。

二、利用uart发送模块设计一个数据发送器

测试实现每10ms以115200的波特率发送一次数据，发送的数据每次+1

uart_tx_tset 的顶层调用

`timescale 1ns / 1ps

module uart_tx_test(
    clk         ,
    rst         ,
    uart_tx     
);

input               clk         ;
input               rst         ;
output              uart_tx     ;

reg[19:0]    counter;
reg          send_go;
reg[7:0]     data   ;
wire         tx_done;

uart_tx uart_tx_u0(
    .clk            (   clk   ) ,
    .rst            (   rst   ) ,
    .baud_set       (    7    ) ,
    .send_go        (send_go  ) ,
    .data           (data     ) ,
    .uart_tx        (uart_tx  ) ,
    .tx_done        (tx_done  ) 
);

always@(posedge clk,negedge rst)begin
    if(!rst)
        counter <= 0;
    else if(counter == 499_999)
        counter <= 0;
    else
        counter <= counter + 1; 
end

always@(posedge clk,negedge rst)begin
    if(!rst)
        send_go <= 0;
    else if(counter == 1)
        send_go <= 1;
    else
        send_go <=0;
end

always@(posedge clk,negedge rst)begin
    if(!rst)
        data <= 8'd0;
    else if(counter == 499_999)
        data <= data + 1; 
    else 
        data <= data;
end

endmodule

TB文件

`timescale 1ns / 1ps
module uart_tx_test_tb();

reg             clk       ;
reg             rst       ;
wire            uart_tx   ;

uart_tx_test uart_tx_test_u0(
    .clk     (clk      )    ,
    .rst     (rst      )    ,
    .uart_tx (uart_tx  )    
);
initial clk = 0;
always #10 clk =~clk;

initial begin
  rst = 0;
  #201;
  rst = 1;
  #50_000_000;
end
endmodule

测试波形

三、实现多字节的传输

利用一个字节的传输子模块，发送5字节的数据

利用状态机（只需关注输入，输出）

`timescale 1ns / 1ps

module uart_tx_5byte(
    clk     ,
    rst     ,
    Data40  ,
    Trans_go,
    uart_tx ,
    Trans_done
    );
input         clk     ;
input         rst     ;
input[39:0]   Data40  ;
input         Trans_go;
output        uart_tx ;
output        Trans_done;

reg[7:0]      data    ;
reg           send_go ;
wire          tx_done ;
reg           Trans_done;
reg[2:0]      state;

uart_tx uart_tx_u0(
    .clk        (clk    ) ,
    .rst        (rst    ) ,
    .baud_set   ( 7     ) ,
    .send_go    (send_go) ,
    .data       (data   ) ,
    .uart_tx    (uart_tx) ,
    .tx_done    (tx_done) 
);


always@(posedge clk , negedge rst)begin
    if(!rst)begin
        state   <= 0;
        data    <= 0;
        send_go <= 0;
        Trans_done <= 0;
    end
    else
        case (state)
            0:  if(Trans_go)begin
                    data    <= Data40[7:0];
                    send_go <= 1;
                    state   <= 1;
                end
                else begin
                    data    <= 0;
                    send_go <= 0;
                    state   <= 0;
                    Trans_done <= 0;
                end
            1:  if(tx_done)begin
                    data    <= Data40[15:8];
                    send_go <= 1;
                    state   <= 2;
                end
                else begin
                    data    <= data;
                    send_go <= 0;
                    state   <= 1;
                end

            2:  if(tx_done)begin
                    data    <= Data40[23:16];
                    send_go <= 1;
                    state   <= 3;
                end
                else begin
                    data    <= data;
                    send_go <= 0;
                    state   <= 2;
                end
            
            3:  if(tx_done)begin
                    data    <= Data40[31:24];
                    send_go <= 1;
                    state   <= 4;
                end
                else begin
                    data    <= data;
                    send_go <= 0;
                    state   <= 3;
                end
            4:  if(tx_done)begin
                    data    <= Data40[39:32];
                    send_go <= 1;
                    state   <= 5;
                end
                else begin
                    data    <= data;
                    send_go <= 0;
                    state   <= 4;
                end
            5:  if(tx_done)begin
                    data    <= 0;
                    send_go <= 0;
                    state   <= 0;
                    Trans_done <= 1;
                end
                else begin
                    data    <= data;
                    send_go <= 0;
                    state   <= 5;
                end                
            default: begin
                        state   <= 0;
                        data    <= 0;
                        send_go <= 0;
                        Trans_done <= 0;
                     end
        endcase
end
endmodule

TB文件

`timescale 1ns / 1ps


module uart_tx_5byte_tb();
reg                    clk     ;
reg                    rst     ;
reg[39:0]              Data40  ;
reg                    Trans_go;
wire                   uart_tx ;
wire                   Trans_done;
uart_tx_5byte uart_tx_5byte_u0(
    .clk           (clk     ),
    .rst           (rst     ),
    .Data40        (Data40  ),
    .Trans_go      (Trans_go),
    .uart_tx       (uart_tx ),
    .Trans_done    (Trans_done)
    );

initial clk = 0;
always #10 clk =~clk;

initial begin
    rst      = 0;
    Data40   = 0;
    Trans_go = 0;
    #201;
    rst      = 1;
    #200;
    Data40   = 40'h123456789a;
    Trans_go = 1;
    #20;
    Trans_go = 0;
    @(posedge Trans_done);
    #20000;
    Data40   = 40'ha987654321;
    Trans_go = 1;
    #20;
    Trans_go = 0;
    @(posedge Trans_done);
    #20000;
    $stop;
end
endmodule

仿真结果


always@(posedge clk,negedge rst)begin
    if(!rst)
        s_counter <= 0;
    else if(s_counter == 5)
        s_counter <= 0;
    else if(tx_done)
        s_counter <= s_counter + 1;
    else
        s_counter <= s_counter;
end
always@(posedge clk,negedge rst)begin
    if(!rst)
        r_Data40 <= 0;
    else if(Trans_go)
        r_Data40 <= Data40;
    else if(tx_done)
        r_Data40 <= r_Data40 >> 8;
    else
        r_Data40 <= r_Data40;
end

always@(posedge clk ,negedge rst)begin
    if(!rst)
        state <= 0;
    else
        state <= n_state;
end

always@(*)begin
  case (state)
    0:  if(Trans_go)
            n_state <= 1;
        else 
            n_state <= 0;
    1:  if(s_counter == 5)
            n_state <= 0;
        else 
            n_state <= 1; 
    default: n_state <= 2'bxx;
  endcase
end
always@(posedge clk ,negedge rst)begin
    if(!rst)
        data <= 0;
    else if(state == 0)
        data <= Data40[7:0];
    else if(state == 1 && tx_done == 1)
        data <= r_Data40[15:8];
    else
        data <= data;
end
always@(posedge clk ,negedge rst)begin
    if(!rst)
        send_go <= 0;
    else if(s_counter == 4 && tx_done)
        send_go <= 0;
    else if((state ==1 && tx_done == 1)||Trans_go)
        send_go <= 1;
    else
        send_go <= 0;
end
always@(posedge clk ,negedge rst)begin
    if(!rst)
        Trans_done <= 0;
    else if(s_counter == 4 && tx_done)
        Trans_done <= 1;
    else
        Trans_done <= 0;
end

MVP-curry-萌神
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FPGA开发UART串口通信通用模块
03-03
fpga uart串口通信通用模块。包含所有模块源文件、测试文件、测试工程、及模块使用介绍和模块测试报告。模块通用性强，可移植性强，可通过测试工程自行修改，或自行例化模块，只需简单配置几个参数，驱动相应信号即可实现。模块可自定义波特率、校验类型。
FPGA：uart原理+tx发送模块+rx接收模块
weixin_53573350的博客
08-15 2561
它在发送数据时将并行数据转换为串行的数据来传输，在接收数据时将接收到的串行数据转换成并行数据。UART串口通信需要两根信号线来实现，一根用于发送，另一个用于接收。串口通信速率用波特率表示，它表示每秒传输二进制数据的位数，单位是bit/s（位/秒），简称bps；tx发送模块：共四个状态，IDLE状态，START状态，DATA状态，FINISH状态。不带时钟同步信号的数据传输，发送方和接收方使用各自的时钟控制数据的发送和接收过程。带时钟同步信号的数据传输，发送方和接收方在同一时钟控制下，同步传输数据。
FPGA学习项目——RAM读写与UART串口数据发送
qq_51535126的博客
11-27 2130
使用正点原子达芬奇A7板子，在学习8位以及多字节数据的UART串口的接受和发送，以及ROM，RAM存储器IP核的建立和使用等课程后，尝试完成了一道自命题项目：向RAM中循环写入2048个16位数据，通过UART串口将数据发送至上位机，且在发送数据的同时还在向RAM中继续存数据。1.数据是16位的，使用串口发送2个字节的数据到电脑上。2.写入的数据这里暂定与写地址相同，因为位宽不等（2048个数据地址是12位的，这里写入的数据是16位的，进行高位补零）。
FPGA——UART串口通信
zhu1289的博客
10-16 500
UART通信——FPGA
串口应用：遵循uart协议，发送多个字节的数据（状态机）
qq_44366923的博客
06-02 6057
串口应用：遵循uart协议，发送多个字节的数据（状态机）
孩子都能学会的FPGA：第九课——多字节数据的发送和接收
CHDAJ58的博客
11-23 1955
当又数据要发送的时候先进入发送帧头（HEAD）状态，帧头发送完毕后（tx_over拉高）进入发送数据长度（LEN）的状态，数据长度发送完毕后（tx_over拉高）进入数据发送（SEND）状态，然后进入数据发送等待状态（WAIT），如果一次数据发送完毕（tx_over拉高）判断已经发送数据的个数（send_cnt），如果有效数据没有发送完毕跳转到数据发送状态，如果有效数据发送完毕进入发送帧尾的状态（TAIL）,帧尾发送完毕后（tx_over拉高）进入IDLE状态等待下一帧数据的发送。
FPGA常用通信协议 —UART（三）---UART发送及TOP文件
weixin_62966975的博客
03-06 362
前面介绍了UART的基本时序和接收器的相关代码，发送器基本逻辑也是一样，只不过相比发送器我们需要反过来思考，从上一个模块里得到的八位并行数据需要在UART时序配合下转成串行数据并从TX端发出。四、数据回环实验TOP文件。五、数据回环实验测试代码。数据有效，也是开始标志。
通信总线协议一 ：UART
园长QwQ
07-24 1501
通信总线协议Uart介绍
FPGA_uart.rar_FPGA 串口通信_UART implementation
09-23
fpga实现串口通信 verilog语言实现
uart_rx.zip_FPGA串口通信_uart_rx
07-15
FPGA与计算机通信的串口接收程序，用于与计算机或者其他FPGA通信
UART模块，多字节发送和接收，可循环。字节长度可更改。
05-19
UART模块，多字节收发可循环，发送几个字节，发送的数据，和接受的数据都可以随意更改，具体更改会在文章中写出https://blog.csdn.net/q35104943/article/details/124857048?spm=1001.2014.3001.5502，用的是之前买的黑金的开发板UART模块更改的，因为我这边有多个板子相互连接，所以加了地址选择器，可以不用管，地址现在默认给04就可以。
FPGA基础入门－开发板USB-UART串口通信配置工程文件
08-19
与教程--FPGA基础入门【11】开发板USB-UART串口通信配置--相应的源代码。 根目录包含： 1. 相关文档，nexys4ddr_rm.pdf是开发板文档；DS_FT2232H.pdf是UART芯片FT2232HQ文档 2. src/包含所有源代码 3. sim/包含...
FPGA与PC通信的UART串口设计-论文
05-18
FPGA与PC通信的UART串口设计
test_uart.rar_fpga_fpga 串口_uart fpga_uart串口_串口通信
09-24
基于fpga的uart串口通信协议，64位数据
串口发送多字节写法
weixin_44367729的博客
10-07 4521
stm32f103串口发送多字节写法 因为串口速度比较慢，所以在多字节逐个发送之前必须查询上一个字节的发送状态。 在官方库文件手册提供了以下说明 从手册可以知道： USART_FLAG_TXE（发送缓冲区空标志） 这个标志说明可以往发送缓冲数据寄存器写入数据，但并不代表字节数据就是发送完成。 USART_FLAG_TC（发送完成标志） 这个标志才是代表在发送缓冲数据寄存器的数据发送完成了。 所以，...
单片机多字节串口接收(转)
weixin_30753873的博客
08-15 1636
转自：http://bbs.ednchina.com/BLOG_ARTICLE_3007162.HTM 　　工作了一年多，写了不少单片机串口程序。感觉串口多字节接收部分的逻辑相对于配置寄存器跟串口回复来说，是有点难度的——寄存器配置基本上都是死的，串口回复多字节跟回复一字节只是多了一个循环。 　　串口接收程序是基于串口中断的，单片机的串口每次接收到一字节数据产生一次中断，然后再读取某个寄...
STM32F10x UART多字节接收，程序卡死
qq_41094339的博客
12-08 1602
问题 STM32F10x用一个UART接收多个字节连续发送的信息的时候，单步调试能正常接收，但全速运行之后会卡在中断服务函数，接收终止。 原因 发生了接收器的溢出错误,以下是STM32F10x参考手册 大致意思就是：RXNE为1的时候再往输入缓冲区读入新的字节会发生溢出错误。 那RXNE什么时候为1呢？答：在输入缓冲区非空的时候。 那怎么时候才能把RXNE复位为1呢：以下摘自STM32F10...
FPGA uart串口通信
最新发布
05-21
在使用FPGA进行UART串口通信时，需要先对FPGA进行配置，将串口模块的参数进行设置，包括波特率、数据位、停止位等等。然后，可以通过编写Verilog或VHDL代码来实现UART通信协议，包括数据的发送和接收过程。 同时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值