• ZYNQ_project:uart(odd,even)

    概念：

    UART（Universal Asynchronous Receiver-Transmitter）：即通用异步收发器，是一种通用串行数据总线，用于异步通信。一般UART接口常指串口。

    UART在发送数据时将并行数据转换成串行数据来传输，在接收数据时将接收到的串行数据转换成并行数据。

    单工通信：数据只能沿一个方向传输。

    半双工通信：数据可以沿两个方向传输，但需要分时进行。

    全双工通信：数据可以同时进行双向传输。

    同步通信：带时钟端口的数据传输。

    异步通信：没有时钟端口，发送方和接收方使用各自的时钟控制数据的收发过程。

    常见串行通信接口：

     模块框图：

    时序图：

     

    代码：

    1. // uart的接收模块，要求波特率可调,回环实验
    2. // 完成回环实验后加入校验位
    3. // 然后加入led与蜂鸣器的控制模块
    4. `include         "para.v"
    5. module rx (
    6.     input       wire                sys_clk     ,
    7.     input       wire                sys_rst_n   ,
    8.     input       wire                rx          ,
    9.  
    10.     output      reg     [7:0]       po_data     , // port_output
    11.     output      reg                 po_flag     
    12. );
    13.     // parameter
    14.     parameter   MAX_BPS_CNT = `CLOCK/`BPS   ,//434 ,
    15.                 MAX_BIT_CNT = `BIT_CHACK    ;//10   ; 
    16.     localparam  RX_MOD      = 1'b1          ,
    17.                 CHECK_MOD   = `EVEN         ;
    18.     // reg signal define
    19.     reg                 rx_r1    ;
    20.     reg                 rx_r2    ;
    21.     reg     [31:0]      cnt_bps  ;
    22.     reg                 work     ;
    23.     reg     [3:0]       cnt_bit  ;
    24.     reg     [7:0]       data_reg ;
    25.     reg                 check    ;
    26.     reg                 check_reg;
    27.     // wire signal define
    28.     wire                nege    ;
    29.     /*******************************************************************/
    30.     // // reg signal define
    31.     // reg                 rx_r1   ;
    32.     always @(posedge sys_clk or negedge sys_rst_n) begin
    33.         if(~sys_rst_n) 
    34.             rx_r1 <= 1'b1 ;
    35.         else
    36.             rx_r1 <= rx ;
    37.     end
    38.     // reg                 rx_r2   ;
    39.     always @(posedge sys_clk or negedge sys_rst_n) begin
    40.         if(~sys_rst_n) 
    41.             rx_r2 <= 1'b1 ;
    42.         else
    43.             rx_r2 <= rx_r1 ;
    44.     end
    45.     // reg                 work    ;
    46.     always @(posedge sys_clk or negedge sys_rst_n) begin
    47.         if(~sys_rst_n) 
    48.             work <= 1'b0 ;
    49.         else if(nege)
    50.             work <= 1'b1 ;
    51.         else if((cnt_bit == ((MAX_BIT_CNT - 1))) && (cnt_bps == (MAX_BPS_CNT - 1))) // 这俩条件可以用end_cnt_XXX来代替，组合逻辑赋
    52.             work <= 1'b0 ;
    53.         else 
    54.             work <= work ;
    55.     end
    56.     // reg     [31:0]      cnt_bps ;
    57.     always @(posedge sys_clk or negedge sys_rst_n) begin
    58.         if(~sys_rst_n) 
    59.             cnt_bps <= 32'd0 ;
    60.         else if(work && (cnt_bps == (MAX_BPS_CNT - 1)))
    61.             cnt_bps <= 32'd0 ;
    62.         else if(work)
    63.             cnt_bps <= cnt_bps + 1'b1 ;
    64.         else 
    65.             cnt_bps <= 32'd0 ;
    66.     end
    67.     // reg     [3:0]       cnt_bit ; 应该会归0
    68.     always @(posedge sys_clk or negedge sys_rst_n) begin
    69.         if(~sys_rst_n) 
    70.             cnt_bit <= 4'd0 ;
    71.         else if (work && (cnt_bps == (MAX_BPS_CNT - 1) && cnt_bit == (MAX_BIT_CNT - 1)))
    72.             cnt_bit <= 4'd0 ;
    73.         else if (work && (cnt_bps == (MAX_BPS_CNT - 1)))
    74.             cnt_bit <= cnt_bit + 1'b1 ;
    75.         else if(work)
    76.             cnt_bit <= cnt_bit ;
    77.         else 
    78.             cnt_bit <= 8'd0 ;
    79.     end
    80.     // reg     [7:0]       data_reg;
    81.     always @(posedge sys_clk or negedge sys_rst_n) begin
    82.         if(~sys_rst_n) 
    83.             data_reg <= 8'd0 ;
    84.         else if(work && cnt_bps == (MAX_BPS_CNT/2)) begin // 采样，采集数据的时刻
    85.             case (cnt_bit)
    86.                 0 : data_reg <= 8'd0 ;
    87.                 1 : data_reg[cnt_bit - 1] <= rx_r2 ;
    88.                 2 : data_reg[cnt_bit - 1] <= rx_r2 ;
    89.                 3 : data_reg[cnt_bit - 1] <= rx_r2 ;
    90.                 4 : data_reg[cnt_bit - 1] <= rx_r2 ;
    91.                 5 : data_reg[cnt_bit - 1] <= rx_r2 ;
    92.                 6 : data_reg[cnt_bit - 1] <= rx_r2 ;
    93.                 7 : data_reg[cnt_bit - 1] <= rx_r2 ;
    94.                 8 : data_reg[cnt_bit - 1] <= rx_r2 ;
    95.                 default: data_reg <= data_reg ;
    96.             endcase
    97.         end else
    98.             data_reg <= data_reg ;
    99.     end
    100.     // // wire signal define
    101.     // wire                nege    ;
    102.     assign  nege = ~rx_r1 && rx_r2 ;
    103.     // reg                 check    ;
    104.     always @(posedge sys_clk or negedge sys_rst_n) begin
    105.         if(~sys_rst_n) 
    106.             check <= 1'b0 ;
    107.         else if(CHECK_MOD && (cnt_bit == ((MAX_BIT_CNT - 2))) && (cnt_bps == (MAX_BPS_CNT - 1)))
    108.             check <= ~^data_reg ;
    109.         else if(~CHECK_MOD && (cnt_bit == ((MAX_BIT_CNT - 2))) && (cnt_bps == (MAX_BPS_CNT - 1)))
    110.             check <= ^data_reg ;    
    111.         else 
    112.             check <= check ;
    113.     end  
    114.     // reg                 check_reg;
    115.     always @(posedge sys_clk or negedge sys_rst_n) begin
    116.         if(~sys_rst_n) 
    117.             check_reg <= 1'b0 ;
    118.         else if((cnt_bit == ((MAX_BIT_CNT - 1))) && (cnt_bps == (MAX_BPS_CNT /2)))
    119.             check_reg <= rx_r2 ;
    120.         else 
    121.             check_reg <= check_reg ;
    122.     end  
    123.     // output      reg     [7:0]       po_data     , // port_output
    124.     always @(posedge sys_clk or negedge sys_rst_n) begin
    125.         if(~sys_rst_n) 
    126.             po_data <= 8'd0 ;
    127.         else if((check == check_reg) && (cnt_bit == ((MAX_BIT_CNT - 1))) && (cnt_bps == (MAX_BPS_CNT - 1)))
    128.             po_data <= data_reg ;
    129.         else if(RX_MOD)
    130.             po_data <= po_data ;
    131.         else 
    132.             po_data <= 8'd0 ;
    133.     end
    134.     // output      reg                 po_flag   
    135.     always @(posedge sys_clk or negedge sys_rst_n) begin
    136.         if(~sys_rst_n) 
    137.             po_flag <= 8'd0 ;
    138.         else if((check == check_reg) && ((cnt_bit == ((MAX_BIT_CNT - 1))) && (cnt_bps == (MAX_BPS_CNT - 1)))) 
    139.             po_flag <= 1'b1 ;
    140.         else 
    141.             po_flag <= 8'd0 ;
    142.     end  
    144. endmodule
    1. // uart的数据发送模块。停止位 1bit
    2. `include         "para.v"
    3. module  tx(
    4.     input       wire                sys_clk     ,
    5.     input       wire                sys_rst_n   ,
    6.     input       wire    [7:0]       pi_data     ,
    7.     input       wire                pi_flag     ,
    8.  
    9.     output      reg                 tx         
    10. );
    11.     // parameter
    12.     parameter   MAX_BPS_CNT = `CLOCK/`BPS   ,
    13.                 MAX_BIT_CNT = `BIT_CHACK + 1;
    14.     localparam  CHECK_MOD   = `EVEN         ;
    15.     // reg signal define
    16.     reg     [7:0]       data_reg ;
    17.     reg                 work     ;
    18.     reg     [31:0]      cnt_bps  ; 
    19.     reg     [3:0]       cnt_bit  ; 
    20.  
    21.     /********************************************************************/
    22.     // // reg signal define
    23.     // reg     [7:0]       data_reg ;
    24.     always @(posedge sys_clk or negedge sys_rst_n) begin
    25.         if(~sys_rst_n) 
    26.             data_reg <= 8'd0 ;
    27.         else if(pi_flag)
    28.             data_reg <= pi_data ;
    29.         else 
    30.             data_reg <= data_reg ;
    31.     end
    32.     // reg                 work     ;
    33.     always @(posedge sys_clk or negedge sys_rst_n) begin
    34.         if(~sys_rst_n) 
    35.             work <= 1'b0 ;
    36.         else if(pi_flag)
    37.             work <= 1'b1 ;
    38.         else if(cnt_bps == (MAX_BPS_CNT - 1) && cnt_bit == (MAX_BIT_CNT - 1))
    39.             work <= 1'b0 ;
    40.         else 
    41.             work <= work ;
    42.     end
    43.     // reg     [31:0]      cnt_bps  ; 
    44.     always @(posedge sys_clk or negedge sys_rst_n) begin
    45.         if(~sys_rst_n) 
    46.             cnt_bps <= 32'd0 ;
    47.         else if((work && (cnt_bps == (MAX_BPS_CNT - 1))) 
    48.             || (work && (cnt_bit == (MAX_BIT_CNT - 1)) && cnt_bps == (MAX_BPS_CNT - 1)))
    49.             cnt_bps <= 32'd0 ;
    50.         else if(work)
    51.             cnt_bps <= cnt_bps + 1'b1 ;
    52.         else 
    53.             cnt_bps <= 32'd0 ;
    54.     end
    55.     // reg     [3:0]       cnt_bit  ; 
    56.     always @(posedge sys_clk or negedge sys_rst_n) begin
    57.         if(~sys_rst_n) 
    58.             cnt_bit <= 4'd0 ;
    59.         else if(work && (cnt_bps == (MAX_BPS_CNT - 1)) && cnt_bit == (MAX_BIT_CNT - 1))
    60.             cnt_bit <= 4'd0 ;
    61.         else if(work && (cnt_bps == (MAX_BPS_CNT - 1)))
    62.             cnt_bit <= cnt_bit + 1'b1 ;
    63.         else if(work)
    64.             cnt_bit <= cnt_bit ;
    65.         else 
    66.             cnt_bit <= 4'd0 ;
    67.     end
    68.     // output      reg                 tx          
    69.     always @(*) begin
    70.         if(~sys_rst_n)
    71.             tx = 1'b1 ;
    72.         else if(work) begin
    73.             case (cnt_bit)
    74.             4'd0:   tx = 1'b0 ; 
    75.             4'd1:   tx = data_reg[cnt_bit - 1] ; 
    76.             4'd2:   tx = data_reg[cnt_bit - 1] ; 
    77.             4'd3:   tx = data_reg[cnt_bit - 1] ; 
    78.             4'd4:   tx = data_reg[cnt_bit - 1] ; 
    79.             4'd5:   tx = data_reg[cnt_bit - 1] ; 
    80.             4'd6:   tx = data_reg[cnt_bit - 1] ; 
    81.             4'd7:   tx = data_reg[cnt_bit - 1] ; 
    82.             4'd8:   tx = data_reg[cnt_bit - 1] ; 
    83.             4'd9:   begin 
    84.                     if(CHECK_MOD)
    85.                         tx = ~^data_reg ;
    86.                     else 
    87.                         tx = ^data_reg ;
    88.                     end
    89.             default: tx = 1'b1 ;
    90.             endcase
    91.         end else 
    92.             tx = 1'b1 ;
    93.     end
    94. endmodule

     

    1. module  top(
    2.     input       wire                sys_clk     ,
    3.     input       wire                sys_rst_n   ,
    4.     input       wire                rx          ,
    5.  
    6.     output      wire                tx          
    7. );
    8.     // 例化间连线 Wiring between instantiations
    9.     wire                clk_100Mhz  ;
    10.     wire                clk_50Mhz   ;
    11.     wire                locked      ; 
    12.     wire                rst_n       ; 
    13.     assign              rst_n   = sys_rst_n && locked ;
    14.     wire    [7:0]       po_data     ;
    15.     wire                po_flag     ;
    16. pll pll_inst(
    17.   .clk_in1          ( sys_clk       ) ,
    18.   .resetn           ( sys_rst_n     ) ,
    19.  
    20.   .clk_out1         ( clk_100Mhz    ) ,
    21.   .clk_out2         ( clk_50Mhz     ) ,
    22.   .locked           ( locked        ) 
    23.  );
    24.  
    25. rx rx_inst(
    26.     .sys_clk        ( clk_50Mhz     ) ,
    27.     .sys_rst_n      ( rst_n         ) ,
    28.     .rx             ( rx            ) ,
    29.  
    30.     .po_data        ( po_data       ) ,
    31.     .po_flag        ( po_flag       )  
    32. );
    33.  
    34. tx tx_inst(
    35.     .sys_clk        ( clk_50Mhz     ) ,
    36.     .sys_rst_n      ( rst_n         ) ,
    37.     .pi_data        ( po_data       ) ,
    38.     .pi_flag        ( po_flag       ) ,
    39.  
    40.     .tx             ( tx            )
    41. );
    42. endmodule

     

    仿真：

  • 相关阅读:
    git新建仓库上传项目步骤
    Python自学教程7：字典类型有什么用
    基于功能安全的车载计算平台开发：硬件层面
    压缩包系列
    stm32定时器之简单封装
    为什么使用RedisDesktopManager可以连上redis，微服务似乎无法访问redis
    可变电阻元件封装
    C语言之自定义类型_结构体篇（1）
    写给前端的 react-native 入门指南
    腾讯云GPU云服务器计算型GN7有哪些特点？适用于哪些场景？
  • 原文地址：https://blog.csdn.net/Meng_long2022/article/details/134470262