FPGA学习记录——实验二 串口传输

最新推荐文章于 2024-07-22 12:58:06 发布
最新推荐文章于 2024-07-22 12:58:06 发布
阅读量193 收藏 1
点赞数
文章标签： fpga开发 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73949653/article/details/131349376
版权

232串口协议是通信接口中最简单的协议之一，使用两根线(一根为接收数据线，一根为发送数据线)就能完成数据传输。数据在这两根线上串行传输。

 

其协议原理如下：

 空闲状态时传输线被置为高电平。开始传输数据的时候要先给一个开始标志，此时将传输线电平置低。然后由低位到高位依次传输数据。数据传输完成后，要给一个停止标志，此时传输线必须保持一段时间的高电平然后再进入空闲状态。

串口传输时需要设置波特率，波特率决定了数据传输的速度，波特率越高数据传的越快。一般常用的波特率有9600bps 19200bps 38400bps 115200bps等。如上图所示，在9600bps波特率情况下，每个状态要保持1/9600s。

串口接收代码：

// Company: 
// Engineer: Abshdbeh
// 
// Create Date: 
// Design Name: 
// Module Name: 
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module uart_rx
#(parameter CLK_FREQ='d100_000_000,
            BAUD_FREQ='d9600)
(
    input clk,
    input rst,
    input rxd,
    output reg [7:0] rx_data,
    output reg rx_done

    );
    
    parameter MAX   =   CLK_FREQ/BAUD_FREQ;
    parameter IDLE  =   4'd0    ,
              START =   4'd1    ,
              RD0   =   4'd2    ,
              RD1   =   4'd3    ,
              RD2   =   4'd4    ,
              RD3   =   4'd5    ,
              RD4   =   4'd6    ,
              RD5   =   4'd7    ,
              RD6   =   4'd8    ,
              RD7   =   4'd9    ,
              END   =   4'd10   ;
    
    reg rxd0             ;
    reg rxd1             ;
    reg [3:0] state     ;
    reg flag            ;
    reg [13:0] baud_cnt ;
    reg rd_flag         ;
    reg clr_flag        ;
    
    initial
        begin
            state=IDLE;
        end
    
    always@(posedge clk or negedge rst)
        if(!rst)
            rxd0 <= 1'b1;
        else
            rxd0 <= rxd;
    
   always@(posedge clk or negedge rst)
        if(!rst)
            rxd1 <= 1'b1;
        else
            rxd1 <= rxd0; 
            
   always@(posedge clk or negedge rst)
        if(!rst)
            flag <= 1'b0;
        else if(baud_cnt==MAX-2)
            flag <= 1'b1;
        else
            flag <= 1'b0;
    
   always@(posedge clk or negedge rst)
        if(!rst)
            baud_cnt <= 14'd0;
        else if(state==IDLE)
            baud_cnt <= 14'd0;
        else if(baud_cnt==MAX-1)
            baud_cnt <= 14'd0;
        else
            baud_cnt <= baud_cnt+1'b1;         
            
   always@(posedge clk or negedge rst)
        if(!rst)
            state <= IDLE;
        else
            case(state)
                IDLE:   
                    if(!rxd1)
                        state <= START;
                START:
                    if(flag)
                        state <= RD0;
                RD0:
                    if(flag)
                        state <= RD1;
                RD1:
                    if(flag)
                        state <= RD2;        
                RD2:
                    if(flag)
                        state <= RD3;        
                RD3:
                    if(flag)
                        state <= RD4;
                RD4:
                    if(flag)
                        state <= RD5; 
                RD5:
                    if(flag)
                        state <= RD6;
                RD6:
                    if(flag)
                        state <= RD7;
                RD7:
                    if(flag)
                        state <= END; 
                END:
                    if(flag)
                        state <= IDLE;             
               default: state <= IDLE;         
            endcase
            
    always@(posedge clk or negedge rst)
        if(!rst)
            rd_flag <= 1'b0;
        else 
            case(state)
                RD0,RD1,RD2,RD3,RD4,RD5,RD6,RD7:
                    if(baud_cnt==((MAX/2)-1))
                        rd_flag <= 1'b1;
                    else
                        rd_flag <= 1'b0;
                default: rd_flag <= 1'b0;    
            endcase
            
    always@(posedge clk or negedge rst)
        if(!rst)
            rx_data <= 8'd0;
        else if(rd_flag)
                case(state)
                    RD0:    rx_data[0] <= rxd1;
                    RD1:    rx_data[1] <= rxd1;
                    RD2:    rx_data[2] <= rxd1;
                    RD3:    rx_data[3] <= rxd1;
                    RD4:    rx_data[4] <= rxd1;
                    RD5:    rx_data[5] <= rxd1;
                    RD6:    rx_data[6] <= rxd1;
                    RD7:    rx_data[7] <= rxd1;
                    default: rx_data <= 8'd0;
                endcase
        else if(clr_flag)
            rx_data <= 8'd0;
            
     always@(posedge clk or negedge rst)
        if(!rst)
            rx_done <= 1'b0;
        else if(state==END && baud_cnt==14'd1)
            rx_done <= 1'b1;
        else
            rx_done <= 1'b0;
            
    always@(posedge clk or negedge rst)
        if(!rst)
            clr_flag <= 1'b0;
        else if(state==END && baud_cnt==((MAX/2)-1))
            clr_flag <= 1'b1;
        else
            clr_flag <= 1'b0;
    
endmodule

串口发送代码：

// Company: 
// Engineer: Abshdbeh
// 
// Create Date: 
// Design Name: 
// Module Name: 
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module uart_tx        
#(parameter CLK_FREQ='d100_000_000,              
            BAUD_RATE='d9600,
            BIT_NUM='d64)
(
    input clk,
    input rst,
    input [BIT_NUM-1:0] tx_data,
    input tx_start,
    output reg txd,
    output reg tx_done
    );
    
    localparam BAUD_CNT_MAX=CLK_FREQ/BAUD_RATE,
              BYTE_CNT_MAX=BIT_NUM/8;
    localparam IDLE  =   4'd0,
              START =   4'd1,
              TX0   =   4'd2,
              TX1   =   4'd3,
              TX2   =   4'd4,
              TX3   =   4'd5,
              TX4   =   4'd6,
              TX5   =   4'd7,
              TX6   =   4'd8,
              TX7   =   4'd9,
              END   =   4'd10;
              
    reg [13:0] baud_cnt;
    reg [4:0] byte_cnt;
    reg [3:0] state;
    reg turn_flag;
    reg byte_flag;
    reg [7:0] date_temp;
    
    initial
        begin
            state=IDLE;
            date_temp=0;
            txd=1;
            byte_cnt=0;
        end
    
    always@(posedge clk or negedge rst)         
        if(!rst)
            state <= IDLE;
        else
            case(state)
                IDLE:   if(tx_start)
                            state <= START;
                START:  if(turn_flag)
                            state <= TX0;
                TX0:    if(turn_flag)
                            state <= TX1;
                TX1:    if(turn_flag)
                            state <= TX2;
                TX2:    if(turn_flag)
                            state <= TX3;
                TX3:    if(turn_flag)
                            state <= TX4;
                TX4:    if(turn_flag)
                            state <= TX5;
                TX5:    if(turn_flag)
                            state <= TX6;
                TX6:    if(turn_flag)
                            state <= TX7;
                TX7:    if(turn_flag)
                            state <= END;
                END:    begin
                            if(tx_done)
                                state <= IDLE;
                            else if(turn_flag)
                                state <= START;
                        end
                default:    state <= IDLE;    
            endcase
    
   always@(posedge clk or negedge rst)
        if(!rst)
            turn_flag <= 1'b0;
        else
            case(state)
                START,TX0,TX1,TX2,TX3,TX4,TX5,TX6,TX7,END:
                    if(baud_cnt==BAUD_CNT_MAX-2)
                        turn_flag <= 1'b1;
                    else
                        turn_flag <= 1'b0;
                default: turn_flag <= 1'b0;
            endcase
            
    always@(posedge clk or negedge rst)
        if(!rst)
           baud_cnt <= 14'd0;
        else
            case(state)
               START,TX0,TX1,TX2,TX3,TX4,TX5,TX6,TX7,END:
                    if(baud_cnt==BAUD_CNT_MAX-1)
                        baud_cnt <= 14'd0;
                    else
                        baud_cnt <= baud_cnt+1'b1;
            default:    baud_cnt <= 14'd0;
            endcase
            
    always@(posedge clk or negedge rst)
        if(!rst)
             byte_flag  <= 1'b0;
        else
            case(state)
               END:
                    if(baud_cnt==BAUD_CNT_MAX-2)
                        byte_flag <= 1'b1;
                    else
                        byte_flag <= 1'b0;
            default:    byte_flag<= 1'b0;
            endcase  
    
    always@(posedge clk or negedge rst)
        if(!rst)
            byte_cnt <= 5'd0;
        else
            case(state)
                END:
                    if(tx_done)
                        byte_cnt <= 5'd0;
                    else if(byte_flag)
                        byte_cnt <= byte_cnt+1'b1;
                default:    byte_cnt <= byte_cnt;
            endcase
     
    always@(*)
                date_temp <= tx_data[(byte_cnt*8)+:8];
            
    always@(posedge clk or negedge rst)
        if(!rst)
            txd <= 1'b1;
        else 
            case(state)
                IDLE,END:   txd <= 1'b1;
                START:  txd <= 1'b0;
                TX0:    txd <= date_temp[0];
                TX1:    txd <= date_temp[1];
                TX2:    txd <= date_temp[2];
                TX3:    txd <= date_temp[3];
                TX4:    txd <= date_temp[4];
                TX5:    txd <= date_temp[5];
                TX6:    txd <= date_temp[6];
                TX7:    txd <= date_temp[7];
                default:    txd <= 1'b1;
            endcase
            
    always@(posedge clk or negedge rst)
        if(!rst)
            tx_done <= 1'b0;
        else if((state==END) && (byte_cnt==BYTE_CNT_MAX-1) && (baud_cnt==BAUD_CNT_MAX-2))
            tx_done <= 1'b1;
        else
            tx_done <= 1'b0;
    
endmodule

 串口环回顶层代码：

`timescale 1ns / 1ps
//
// Company: 
// Engineer: Abshdbeh
// 
// Create Date: 
// Design Name: 
// Module Name: uart_loop
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module uart_loop(
    input clk,
    input rst,
    input rxd,
    
    output txd
    );
    
    wire [7:0] rx_data;
    wire rx_done;
    
    uart_rx
#(.CLK_FREQ  ('d100_000_000  ),
  .BAUD_FREQ ('d9600         ))
  uart_rx_inst
(
    .clk        (clk),
    .rst        (rst),
    .rxd        (rxd ),
    .rx_data    (rx_data),
    
    .rx_done    (rx_done)

    );
    
    wire tx_done;
    reg [7:0] tx_data;
    reg tx_start;
    
    always@(posedge clk or negedge rst)
        if(!rst)
            tx_start <= 1'b0;
        else if(rx_done==1'b1)
            tx_start <= 1'b1;
        else
            tx_start <= 1'b0;
            
    always@(posedge clk or negedge rst)
        if(!rst)
            tx_data <= 'd0;
        else if(rx_done==1'b1)
            tx_data <= rx_data;
    
    uart_tx        
#(.CLK_FREQ     ('d100_000_000  ),              
  .BAUD_RATE    ('d9600         ),
  .BIT_NUM      ('d8           ))
   uart_tx_inst
(
    .clk            (clk),
    .rst            (rst),
    .tx_data        (tx_data),
    .tx_start       (tx_start),
    
    .txd            (txd),
    .tx_done        (tx_done)
    
    );

    
endmodule

将程序下载到板子上，打开串口助手，进行测试，结果如下：

 

 注意：要勾选十六进制显示和十六进制发送，否则不会显示结果

Abshdbeh
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
基于FPGA的串口发送
weixin_45739895的博客
09-21 2102
待8位数据传输完成之后。
RS485串口通信实验（使用两块开发板通过RS-485串口通信，由各自开发板上的四个按键分别控制对方开发板上四个LED灯的亮灭。）
qq_43811597的博客
10-26 2995
RS485只有两根数据线，只能实现半双工传输 系统框图 1.按键模块 module key_debounce( //按键消抖 input sys_clk, //外部50M时钟 input sys_rst_n, //外部复位信号，低有效 input [3:0] key, //外部按键输入 output reg k.
FPGA——串口收发
a17377547725的博客
03-23 2533
FPGA——串口收发
FPGA实验之串口接收
qq_26924543的博客
05-10 2503
FPGA实验之串口接收串口数据的接收采样在每个数据位的中间，这样能够采集到比较准确的数据。（1）    建立工程（2）    编写程序module UART_receive(input CLK,RST,RXD,                                            output Receive_done,Odd_data,                      ...
FPGA uart串口回环实验
10-24
本实验——"FPGA uart串口回环实验" 是一个典型的FPGA应用，它涉及到UART接口的设计与测试，旨在验证FPGA通过UART与外部设备通信的能力。 实验的核心目标是实现UART回环功能。回环测试是指发送的数据经过UART接口...
FPGA——精选推荐 fpga开发.pdf
04-22
本文档主要介绍了FPGA开发中的关键技术和组件，包括芯片选信号、时钟信号、串口通信、数据解码、PWM调制、模拟信号读取、波形生成、DAC输出、地址生成、波形查找表、串行数据输出、状态机控制等。 芯片选信号（CS）...
xilinx FPGA封装库大全——Xilinx.zip
11-16
3. **IP核封装**：IP核是预设计好的功能模块，如串行接口（SPI、I2C）、并行接口（PCIe、USB）、内存接口（DDR3、DDR4）等，它们大大简化了系统集成的复杂性。 4. **时钟管理封装**：时钟管理模块包括锁相环（PLL）...
零基础学FPGA（十）牛刀小试——串行口通信电路设计
08-30
本篇文章是针对初学者的FPGA学习教程，主要讲解如何利用FPGA实现串行口通信电路设计，这对于理解和应用FPGA至关重要。 串行口通信是一种常见的数据传输方式，相比并行通信，它只需要较少的引脚，但传输速度相对较慢...
FPGA串口发送例程
12-08
FPGA串口发送例程,
FPGA ，Uart通讯——波特率115200、奇校验。
06-05
UART（通用异步收发传输器）是一种广泛用于设备间串行通信的接口，它允许数据以特定的波特率在两个设备之间传输。在本文中，我们将深入探讨如何使用FPGA（现场可编程门阵列）来实现UART通信，特别关注115200波特率和...
FPGA自学教程 07 串口发送 入门
shock-shock的博客
06-13 227
双非硕士 研一下学期视觉转（在b站跟小梅哥视频）长路漫漫，但希望前途光明FPGA教程。
FPGA 串口发送
function0101的博客
07-04 87
FPGA串口发送学习记录
【小月电子】安路国产FPGA开发板系统学习教程-LESSON7串口通信
Moon_3181961725的博客
09-12 2299
国产FPGA安路系统学习教程-串口通信
FPGA学习之串口发送程序设计（来自小梅哥的教程学习者）
湮雨塵飛的博客
04-20 840
1. UART说明可参考维基百科的文档：https://zh.wikipedia.org/wiki/UART2. 实现逻辑图示3. 程序实现module UART_TX(rst_n,clk,send_en,baud_set,data_in,data_tx,flag,state); input rst_n; input clk; input send_en; inp...
FPGA实现串口（UART）
热门推荐
孤独的单刀
03-10 26万+
通过本文您会学到：1、什么是UART？2、如何用FPGA实现它？
【STM32代码移植问题4：字符串拼接/数字转换、共用体与时间戳】
qq_45539458的博客
03-13 1563
【STM32代码移植问题4：字符串拼接/数字转换、共用体与时间戳】
FPGA内数据传输模型
weixin_50810761的博客
03-02 1454
根据D触发器的数据传输原理，对建立时间，数据传输延迟，D触发器延迟，时钟偏斜，数据传输时间，数据到达时间进行讲解，最后推出建立时间余量表达式以及数据需求时间，数据到达时间等
实验一 FPGA使用Verilog HDL设计选择器
最新发布
m0_74102824的博客
07-22 385
本次实验旨在通过Vivado软件设计一个四选一数据选择器，并对其进行仿真，以加深对Verilog HDL语言的理解和实践能力。在完成实验过程中，我学会了如何使用Vivado软件进行设计和仿真，以及如何下载FPGA程序。使用Verilog HDL语言编写了一个四选一数据选择器的功能。在设计过程中，我考虑了数据选择器的输入端口、输出端口以及逻辑功能，确保了设计的正确性和完整性。我对设计进行了仿真，验证了数据选择器的功能和正确性。通过仿真结果，我确认了设计的准确性，并对其进行了必要的调试和优化。
PWM再理解（1）
weixin_45547259的博客
07-18 835
昨天过于劳累，十点睡觉，本来想梳理一下PWM，今天补上。
FPGA高速ADC接口实战——250MSPS采样率ADC9481
05-16
FPGA与高速ADC之间的数据传输可以使用并行接口或者串行接口。串行接口可以减少传输线路的数量，但是需要考虑时钟同步问题。并行接口可以提高传输速率，但是需要考虑布线和调试的问题。 2. 数据帧同步 FPGA与ADC...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Abshdbeh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值