基于H7的曼彻斯特编码/解码/串口系统设计

HME京微齐力 2023-07-02 3847

描述

前言

四月到现在一直比较忙，有一段时间没有做京微齐力器件的开发了，本次做一个新器件 H7 的曼彻斯特（编码&解码&通信）系统。

方案讲解

一关于曼彻斯特编码

曼彻斯特编码（Manchester coding），又称自同步码、相位编码（phase encoding，PE），能够用信号的变化来保持发送设备和接收设备之间的同步。

值得一提的是，曼彻斯特编码有两种截然相反的约定：

它用电压的变化来分辨0和1，从高电平到低电平的跳变代表1，而从低电平到高电平的跳变代表0(G.E.Tomas编码方式)。

从高电平到低电平的跳变代表0，而从低电平到高电平的跳变代表1(IEEE 802.3编码方式)，信号的保持不会超过一个比特位的时间间隔。即使是0或1的序列，信号也将在每个时间间隔的中间发生跳变。这种跳变将允许接收设备的时钟与发送设备的时钟保持一致。

两种曼彻斯特编码：

优点：

与 NRZ 相比，曼彻斯特编码提供一种同步机制，保证发送端与接收端信号同步。

缺点：

曼彻斯特编码的频率要比 NRZ 高一倍，传输等量数据所需的带宽大一倍。

编码：

曼彻斯特编码是将时钟和数据包含在信号流中，在传输代码信息的同时，也将时钟同步信号一起传输到对方。曼彻斯特码是用“01”和“10”来表示普通二进制数据中的“1””和“0”的，因此在实际电路设计中，我们可以用采一个2选1数字选择器来完成此项功能。（IEEE 802.3编码方式）

解码：

曼彻斯特译码电路设计的目的，是如何准确地从曼彻斯特码的码流中提取出“10”和“01”信号，并将其转换成普通二进制编码中的“0”和“1”。

在实际设计电路中，可以采用一个缓存器，保存上一个时钟采集到的信号和当前时钟采集到的信号，当缓存器的内容是“01”时，输出“1”；当缓存器的内容是“10”时，输出“0”；当缓存器的内容是“00”或“11”时，输出维持不变。

曼彻斯特编码在 FPGA 领域的运用比较广泛：

以太网：在以太网中，曼彻斯特编码被用来将数据转换为数字信号，并通过物理媒介（如同轴电缆或光纤）传输。

远程控制系统：在无线遥控器中，曼彻斯特编码被用来将指令编码并通过无线信道发送给接收器。

工业自动化系统：在工业自动化系统中，曼彻斯特编码被用来将传感器测量值、控制信号等转换为数字信号，并通过数据总线传输。

汽车电子系统：在汽车电子系统中，曼彻斯特编码被用来将控制信号、传感器信号等转换为数字信号，并通过汽车网络传输。

曼彻斯特编码的时钟线与数据线结合一体，同步性高，错误检测性能好，去年在接触屏显项目的时候，便是用到了这一编码。

二任务&实验效果

用两块 FPGA 开发板设计一个曼彻斯特码编码和解码系统；

第1块板负责在按键后将拨码开关拨出的8位二进制码用曼彻斯特码发出；

第2块板负责在收到曼彻斯特码号将其解析并在数码管上显示。两块板记得共地。（也可以用 debugware 进行波形读取）

进入正文前，先看实验效果：

京微齐力：基于H7的曼彻斯特（编码&解码&串口）系统

可以看到，H7 端按下发送键后，第二块开发板，接收到信号并进行解码，结果（1111_0000）显示在8位数码管上。（具体过程请看程序解析）

三硬件选择

1、H7P20N0L176-M2H1

本次实验使用 H7 作为主控板，HME-H7 系列采用低功耗22nm 技术，集成了高性能 ARM Cortex-M3 MCU(频率高达300M）、外围设备与大容量片上 SRAM。本次实验只使用逻辑部分，后面根据需要再扩展 MCU 实验。

H7 具有12K的6输入查找表，1个 OSC（80Mhz片内振荡器），128个 10x10 DSP 模块，18个32K x 32位 SRAM，拥有多个封装，能够兼容Altera 的 EP4CE10 和 Xilinx Spartan-6，适用于伺候电机、图像处理及通信网络等多种场景。

2、XC7A35TFGG484-2

因为 H7 板卡没有数码管，这里借助一块 Spartan-7 板卡展示实验效果。（如果没有多余板载数码管的开发板，可以使用 FUXI 软件的 debugware IP 进行波形观看）

四程序设计

1、顶层模块

本模块，实现的是 H7 对 tx_data(8’b11110000)进行编码，按下按键（tx_en_n）后，会以 UART 的方式发送数据到第2块开发板（这里模拟一个通信的效果，如果有 Lora 模块的同学，可以接上模块，这样就实现了无线通信)。关于编码部分，原本是计划使用拨码开关来模拟需要发送的8bit数据，但是板卡没有拨码开关，这里例化的时候，直接对端口进行赋值。程序里仍保留了拨码开关接口，有需要的同学，可以自行例化。

1 //************Message***************//
2 //技术交流：bumianzhe@126.com
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏
5 //All rights reserved
6 //-------------------------------
7 // Target Devices: H7P20N0L176-M2H1
8 // Tool Versions: Fuxi 2023.1
9 // File name:     hme_manchester
10 // Last modified Date: 2023年6月27日2000
11 // Last Version:        V1.1
12 // Descriptions:        曼彻斯特解码&编码&串口
13 //-------------------------------------
14 //***********************************//
15
16 module hme_manchester(
17      input        sys_clk,    //高频时钟，可以是50MHz,本次入20MHz
18      input        rst_n,
19      input        rx_d,   //接收到的bit数据（本实验支持回环）
20      output       tx_d,   //将tx_data进行编码并以串口方式发送出去
21      //发送使能
22      input        tx_en_n,//发送使能，使用按键控制
23      input [7:0] tx_data,//发送的8bits数据，拨码开关控制
24      output        sh_cp, //串行数据输出
25      output        st_cp,   //移位寄存器的时钟输出
26      output        ds       //存储寄存器的时钟输出
27 );
28
29 wire [7:0] rx_data;
30 wire       rx_valid;
31 reg [7:0] rx_data_dis;          //最终显示的接收数据
32 wire [7:0] sel;                   //数码管位选（选择当前要显示的数码管）
33 wire [6:0] seg;                   //数码管段选（当前要显示的内容)
34
35 pll_v1 u_pll_v1(
36    .clkin0       (sys_clk),       //输入20MHz时钟
37    .locked       (),
38    .clkout0   (clk)           //输出50MHz时钟
39 );
40
41
42
43 manchester_tx u_manchester_tx_0(
44      .clk(clk),               //高频时钟，可以是50MHz
45      .rst_n(rst_n),
46    //.tx_data(tx_data),     //待发送的字节数据
47      .tx_data(8'b11110000), //由于板卡上没有拨码开关，这里直接输入数据进行模拟
48      .tx_en(!tx_en_n),     //发送使能
49      .tx_ready(),
50      .tx_d(tx_d)
51      );
52 //如果没有两块板卡的，可以将manchester_tx的tx_d信号接到manchester_rx的rx_d
53 //形成回环实验，并利用debugware进行数据查看。
54 manchester_rx u_manchester_rx_0(
55      .clk(clk),                //高频时钟，可以是50MHz
56      .rst_n(rst_n),
57      .rx_d(rx_d),             //接收到的bit数据
58    //.rx_d(tx_d),             //回环实验
59      .rx_data(rx_data),
60      .rx_valid(rx_valid)
61      );
62
63 always@(posedge clk or negedge rst_n)
64 begin
65 if(!rst_n)
66    rx_data_dis <= 8'd0;
67 else
68    rx_data_dis <= rx_valid?rx_data:rx_data_dis;

69 end

72 HC595_driver u_HC595_driver(
73      .clk(clk),
74      .reset_n(rst_n),
75      .data({1'd0,seg,sel}),
76      .s_en(1'b1),
77      .sh_cp(sh_cp),
78      .st_cp(st_cp),
79      .ds(ds)
80    );
81
82 Hex8 u_Hex8(
83      .clk(clk),
84      .reset_n(rst_n),
85      .en(1'b1),

86 .disp_data({3'd0,rx_data_dis[7],3'd0,rx_data_dis[6],3'd0,rx_data_dis[5],3'd0,rx_data_dis[4],3'd0,rx_data_dis[3],3'd0,rx_data_dis[2],3'd0,rx_data_dis[1],3'd0,rx_data_dis[0]}),
87      .sel(sel),
88      .seg(seg)
89    );
90 //使用debugware查看编码&解码波形
91 debugware_v2_1 u_debugware_v2_1(
92    .trig_out_0       (),
93    .data_in_0

94 ({tx_en_n,tx_d,rx_data}),
.ref_clk_0 (clk)
95 );
96
97 endmodule

2、编码&发送模块

本模块，对需要发送的8bit数据进行曼彻斯特编码，并以串口的方式发送出去（波特率9600）。

首先，当复位信号 rst_n 为低电平时，将会执行 if(rst_n==1’b0) 语句中的代码，对模块中的所有寄存器进行初始化。

接着，在每一个时钟周期的上升沿，如果时钟倍频使能信号 clk_bps_en 为真，则将执行 case(state)语句中当前状态下对应的代码。

当状态机处于 IDLE 状态时，如果 tx_en 为真，则需要开始发送数据。此时，需要将状态切换为 TXS，将要发送的数据写入 tx_data_reg，设置 tx_ready_r 为低电平，并将 tx_cnt 设置为0。

当状态机处于 TXS 状态时，需要根据已经发送的数据字节数 tx_cnt 来进行数据编码，同时更新 tx_ready_r、tx_d_r 和 tx_data_reg 的值。

具体编码过程如下：

当 tx_cnt 为 0 时，需要发送两个高电平（1bit 数据编制成 2bit 数据）。当 tx_cnt 的值在 [1, 8] 之间时，需要按照 Manchester 编码方式编码数据并发送出去。

具体操作如下：

根据 tx_data_reg 的最高位来计算当前发送的是01还是10。如果最高位为1，则当前发送的是01，否则当前发送的是10。对于 tx_cnt 中的每一位（从右往左数），如果是0，则发送的是10，否则发送的是01。

将 tx_data_reg 向左移动一位，为下一次计算做准备。

当 tx_cnt 的值大于8时，需要发送一个低电平，因此将 tx_d_r 设置为低电平。

如果 tx_cnt 达到了指定长度（这里是19），则需要重新将状态切换为 IDLE，设置 tx_ready_r 为高电平，并将 tx_cnt 设置为0。

13 //-------------------------------------
14 //***********************************//
15 module manchester_tx(

16 input clk, //高频时钟，可以是50MHz

17 input rst_n,

18 input [7:0] tx_data,//待发送的字节数据

19 input tx_en, //发送使能

20 output tx_ready,

21 output tx_d

22 );

23 parameter IDLE = 1'b0;//空闲状态

24 parameter TXS = 1'b1;//发送状态

25 reg tx_ready_r;

26 reg tx_d_r;

27 reg state;

28 reg [4:0] tx_cnt;//发送的bits计数器

29 reg [7:0] tx_data_reg;

30 wire clk_bps_en;

31 assign tx_ready = tx_ready_r;

32 assign tx_d = tx_d_r;
33 precise_divider//分频模块

34 #(

35 //DEVIDE_CNT = 85.89934592 * fo @50M

36 //DEVIDE_CNT = 42.94967296 * fo @100M

37 .DEVIDE_CNT(32'd1649267)//9600Hz * 2

38 )u_precise_divider_0

39 (

40 //global clock

41 .clk(clk),

42 .rst_n(rst_n),

43
44 //user interface

45 //.divide_clk()

46 .divide_clken(clk_bps_en)

47 );

48 always@(posedge clk or negedge rst_n)

49 begin

50 if(rst_n == 1'b0)

51 begin

52 state <= IDLE;

53 tx_ready_r <= 1'b1;

54 tx_d_r <= 1'b0;
55 tx_data_reg <= 8'd0;

56 tx_cnt <= 5'd0;

57 end
58 else if(clk_bps_en)

59 begin

60 case(state)

61 IDLE:begin

62 state <= tx_en?TXS:IDLE;

63 tx_data_reg <= tx_en?tx_data:tx_data_reg;

64 tx_ready_r <= tx_en?1'b0:1'b1;

65 tx_cnt <= 5'd0;

66 end

67 TXS:begin
68 tx_cnt <= (tx_cnt >= 5'd19)?5'd0:tx_cnt+1'b1;

69 state <= (tx_cnt >= 5'd19)?IDLE:TXS;

70 tx_ready_r <= (tx_cnt >= 5'd19)?1'b1:1'b0;

71 if(tx_cnt[4:1] == 4'd0)

72 tx_d_r <= 1'b1;//发2个高电平

73 else if(tx_cnt[4:1] <= 4'd8)

74 begin

75 //如果tx_data_reg[7]的值为1，则将tx_cnt[0]的值赋给tx_d_r；

76 //否则将tx_cnt[0]的逻辑反值（即0变成1，1变成0）赋给tx_d_r。

77 tx_d_r <= tx_data_reg[7]?tx_cnt[0]:!tx_cnt[0];//1--01 0--10

78 tx_data_reg <= tx_cnt[0]?(tx_data_reg<<1):tx_data_reg;

79 end

80 else begin

81 tx_d_r <= 1'b0;

82 end

83 end

84 endcase

85 end

86 end

87 endmodule
88

3、解码&接收模块

接收到的串行数据进行解串行化，然后进行解码。

解码与编码原理差不多，这里不做赘述。

1 //*********** Message **********//
2 //技术交流：bumianzhe@126.com
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏
5 //All rights reserved
6 //----------------------------------------
7 // Target Devices:        H7P20N0L176-M2H1
8 // Tool Versions:       Fuxi 2023.1
9 // File name:           manchester_rx
10 // Last modified Date: 2023年6月18日1500
11 // Last Version:        V1.1
12 // Descriptions:        解码&接收模块
13 //--------------------------------------------------------
14 //********************************************************************//
15 module manchester_rx(
16      input        clk,    //高频时钟，可以是50MHz
17      input        rst_n,
18       input        rx_d,   //接收到的bit数据
19       output [7:0] rx_data,
20      output       rx_valid
21 );
22
23    parameter IDLE = 1'b0;//空闲状态
24    parameter RXS = 1'b1;//接收状态
25    reg state;
26    reg rx_valid_r0,rx_valid_r;
27    reg [15:0] rx_data_reg;//缓存16bits的rx数据，每2bits代表1bit数据//01：1 10：0
28    reg [7:0] rx_data_r;
29    wire [7:0] rx_data_w;
30    wire clk_bps_en;
31    reg [3:0] rx_cnt;//对16倍波特率的时钟计数
32    reg [3:0] byte_cnt;//对已接收的字节计数
33    assign rx_data = rx_data_r;
34    assign rx_valid = rx_valid_r;
35
36    //将一组长度为16的串行数据rx_data_reg转换成一组长度为8的并行数据rx_data_w，
37    //即将接收到的串行数据进行解串行化。
38    generate
30      genvar i;
40      for(i=0;i<8;i=i+1) begin:u1
41          assign rx_data_w[i] = !rx_data_reg[i*2+1] && rx_data_reg[i*2];
42      end
43    endgenerate
44
45    precise_divider//分频模块
46    #(
47      //DEVIDE_CNT = 85.89934592 * fo @50M
48      //DEVIDE_CNT = 42.94967296 * fo @100M
49 .DEVIDE_CNT(32'd13194139)   //9600Hz * 16
50    )u_precise_divider_0
51    (
52      //global clock
53      .clk(clk),
54      .rst_n(rst_n),
55
56      //user interface
57      //.divide_clk()
58      .divide_clken(clk_bps_en)
59    );
60
61    always@(posedge clk or negedge rst_n)
62    begin
63    if(rst_n == 1'b0)
64      begin
65      rx_data_r <= 8'd0;
66      rx_valid_r <= 1'b0;
67      end
68    else
69      begin
70      rx_data_r <= rx_data_w;
71      rx_valid_r <= rx_valid_r0;
72      end
73    end
74    always@(posedge clk or negedge rst_n)
75    begin
76    if(rst_n == 1'b0)
77      begin
78      state <= IDLE;
79      rx_data_reg <= 16'd0;
80
81      rx_cnt <= 4'd0;
82      byte_cnt <= 4'd0;
83      rx_valid_r0 <= 1'b0;
84      end
85    else if(clk_bps_en)
86      begin
87      case(state)
88      IDLE:begin
89          rx_cnt      <= rx_d?(rx_cnt >= 4'd10)?4'd0:rx_cnt+1'b1:
90                      4'd0
91                      ;
92          state       <= (rx_cnt >= 4'd10)?RXS:IDLE;
93          rx_data_reg <= 16'd0;
94          byte_cnt    <= 4'd0;
95          rx_valid_r0 <= 1'b0;
96      end
97      RXS:begin
98          rx_cnt <= (rx_cnt >= 4'd7)?4'd0:rx_cnt+1'b1;
99          if(rx_cnt >= 4'd7)
100              rx_data_reg <= {rx_data_reg[14:0],rx_d};
101          else
102              rx_data_reg <= rx_data_reg;
103          byte_cnt <= (rx_cnt >= 4'd7)?byte_cnt+1'b1:byte_cnt;
104          state <= ((rx_cnt >= 4'd7) && byte_cnt == 4'd15)?IDLE:RXS;
105          rx_valid_r0 <= ((rx_cnt >= 4'd7) && byte_cnt == 4'd15);
106      end
107      endcase
108      end
109    end
110 endmodule
111

4、HC595驱动模块

第二块板卡的电路设计用到了芯片 74HC595，该芯片的作用是移位寄存器，通过移位的方式，节省 FPGA 的管脚。FPGA 只需要输出3个管脚，即可达到发送数码管数据的目的，与传统的选位选方式相比，大大节省了 IO 设计资源。（考虑到部分同学，只有普通的8段数码管模块，没有74HC595，在文末会添加传统的数码管驱动代码，方便大家做兼容设计）。

1 //************Message ***************//
2 //技术交流：bumianzhe@126.com
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏

6 //---------------------------------------------------------

7 // Target Devices:        H7P20N0L176-M2H1
8 // Tool Versions:       Fuxi 2023.1
9 // File name:           HC595_driver
10 // Last modified Date: 2023年6月11日2000
11 // Last Version:        V1.1
12 // Descriptions:        驱动HC595，发出数据和选通信号
13 //--------------------------------------------------------
14//*******************************************************************************//
15 module HC595_driver(
16    clk,
17    reset_n,
18    data,
19    s_en,
20
21    sh_cp,
22    st_cp,
23    ds
24 );
25
26    input clk;
27    input reset_n;
28    input [15:0]data;
29    input s_en;
30
31    output reg sh_cp;
32    output reg st_cp;
33    output reg ds;
34
35    assign reset=~reset_n;
36    parameter CNT_MAX = 2;
37
38    reg [15:0]r_data;
39    always@(posedge clk)
40    if(s_en)
41      r_data <= data;
42
43    reg [7:0]divider_cnt;//分频计数器;
44
45    always@(posedge clk or posedge reset)
46    if(reset)
47      divider_cnt <= 0;
48    else if(divider_cnt == CNT_MAX - 1'b1)
49      divider_cnt <= 0;
50    else
51      divider_cnt <= divider_cnt + 1'b1;
52
53    wire sck_plus;
54    assign sck_plus = (divider_cnt == CNT_MAX - 1'b1);
55
56    reg [5:0]SHCP_EDGE_CNT;
57
58    always@(posedge clk or posedge reset)
59    if(reset)
60      SHCP_EDGE_CNT <= 0;
61    else if(sck_plus)begin
62      if(SHCP_EDGE_CNT == 6'd32)
63          SHCP_EDGE_CNT <= 0;
64      else
65          SHCP_EDGE_CNT <= SHCP_EDGE_CNT + 1'b1;
66    end
67    else
68      SHCP_EDGE_CNT <= SHCP_EDGE_CNT;
69
70    always@(posedge clk or posedge reset)
71    if(reset)begin
72      st_cp <= 1'b0;
73      ds <= 1'b0;
74      sh_cp <= 1'd0;
75    end
76   else begin
77      case(SHCP_EDGE_CNT)
78    0: begin sh_cp <= 0; st_cp <= 1'd0;ds <= r_data[15];end
79 1: begin sh_cp <= 1; st_cp <= 1'd0;end
80     2: begin sh_cp <= 0; ds <= r_data[14];end
81 3: begin sh_cp <= 1; end
82     4: begin sh_cp <= 0; ds <= r_data[13];end
83     5: begin sh_cp <= 1; end
84     6: begin sh_cp <= 0; ds <= r_data[12];end
85 7: begin sh_cp <= 1; end
86     8: begin sh_cp <= 0; ds <= r_data[11];end
87 9: begin sh_cp <= 1; end
88    10: begin sh_cp <= 0; ds <= r_data[10];end
89    11: begin sh_cp <= 1; end
90    12: begin sh_cp <= 0; ds <= r_data[9];end
91    13: begin sh_cp <= 1; end
92    14: begin sh_cp <= 0; ds <= r_data[8];end
93    15: begin sh_cp <= 1; end
94    16: begin sh_cp <= 0; ds <= r_data[7];end
95    17: begin sh_cp <= 1; end
96    18: begin sh_cp <= 0; ds <= r_data[6];end
97    19: begin sh_cp <= 1; end
98    20: begin sh_cp <= 0; ds <= r_data[5];end
99    21: begin sh_cp <= 1; end
100   22: begin sh_cp <= 0; ds <= r_data[4];end
101 23: begin sh_cp <= 1; end
102   24: begin sh_cp <= 0; ds <= r_data[3];end
103 25: begin sh_cp <= 1; end
104   26: begin sh_cp <= 0; ds <= r_data[2];end
105 27: begin sh_cp <= 1; end
106   28: begin sh_cp <= 0; ds <= r_data[1];end
107 29: begin sh_cp <= 1; end
108 30: begin sh_cp <= 0; ds <= r_data[0];end
109 31: begin sh_cp <= 1; end
110 32: st_cp <= 1'd1;
111          default:
112              begin
113                  st_cp <= 1'b0;
114                  ds <= 1'b0;
115                  sh_cp <= 1'd0;
116              end
117      endcase
118    end
119
120 endmodule
121

5、段选&位选模块

2个共阳极的7段4位数码管，采用动态扫描的显示方式，即轮流向各位数码管送出字形码和相应的位选，利用发光管的余辉和人眼视觉暂留作用，使人的感觉好像各位数码管同时都在显示。

比较简单的数码管段选、位选模块，这里不做赘述。

6 //---------------------------------------------------------
7 // Target Devices:        H7P20N0L176-M2H1
8 // Tool Versions:       Fuxi 2023.1
9 // File name:           Hex8
10 // Last modified Date: 2023年6月11日1300
11 // Last Version:        V1.1
12 // Descriptions:        分频信号，段选和位选信号生成，输出需要显示的数据、段选和位选值
13 //--------------------------------------------------------
14//****************************************************************************************//
15 module Hex8(
16    clk,
17    reset_n,
18    en,
19    disp_data,
20    sel,
21    seg
22);
23    assign reset=~reset_n;
24    input clk;   //50M
25    input reset_n;
26    input en;   //数码管显示使能，1使能，0关闭
27
28    input [31:0]disp_data;
29
30    output [7:0] sel;//数码管位选（选择当前要显示的数码管）
31    output reg [6:0] seg;//数码管段选（当前要显示的内容）
32
33    reg [14:0]divider_cnt;//25000-1
34
35    reg clk_1K;
36    reg [7:0]sel_r;
37
38    reg [3:0]data_tmp;//数据缓存
39
40//   分频计数器计数模块
41    always@(posedge clk or posedge reset)
42    if(reset)
43      divider_cnt <= 15'd0;
44    else if(!en)
45      divider_cnt <= 15'd0;
46    else if(divider_cnt == 24999)
47      divider_cnt <= 15'd0;
48    else
49      divider_cnt <= divider_cnt + 1'b1;
50
51 //1K扫描时钟生成模块
52    always@(posedge clk or posedge reset)
53    if(reset)
54      clk_1K <= 1'b0;
55    else if(divider_cnt == 24999)
56      clk_1K <= ~clk_1K;
57    else
58      clk_1K <= clk_1K;
59
60 //8位循环移位寄存器
61    always@(posedge clk_1K or posedge reset)
62    if(reset)
63      sel_r <= 8'b0000_0001;
64    else if(sel_r == 8'b1000_0000)
65      sel_r <= 8'b0000_0001;
66    else
67      sel_r <= sel_r << 1;
68
69    always@(*)
70      case(sel_r)
71          8'b0000_0001:data_tmp = disp_data[3:0];
72          8'b0000_0010:data_tmp = disp_data[7:4];
73          8'b0000_0100:data_tmp = disp_data[11:8];
74          8'b0000_1000:data_tmp = disp_data[15:12];
75          8'b0001_0000:data_tmp = disp_data[19:16];
76          8'b0010_0000:data_tmp = disp_data[23:20];
77          8'b0100_0000:data_tmp = disp_data[27:24];
78          8'b1000_0000:data_tmp = disp_data[31:28];
79          default:data_tmp = 4'b0000;
80      endcase
81
82    always@(*)
83      case(data_tmp)
84          4'h0:seg = 7'b1000000;
85          4'h1:seg = 7'b1111001;
86          4'h2:seg = 7'b0100100;
87          4'h3:seg = 7'b0110000;
88          4'h4:seg = 7'b0011001;
89          4'h5:seg = 7'b0010010;
90          4'h6:seg = 7'b0000010;
91          4'h7:seg = 7'b1111000;
92          4'h8:seg = 7'b0000000;
93          4'h9:seg = 7'b0010000;
94      endcase
95
96    assign sel = (en)?sel_r:8'b0000_0000;
97
98 endmodule
99

五debugware 回环实验

本节适用于只有一块板卡的同学，将发送模块的 tx_d 信号接到接收模块的 rx_d 信号，形成回环实验，并调用 debugware 进行数据分析。

1 //如果没有两块板卡的，可以将 manchester_tx 的 tx_d 信号接到 manchester_rx 的 rx_d

2 //形成回环实验，并利用debugware进行数据查看。

3 manchester_rx u_manchester_rx_0(

4    .clk(clk), //高频时钟，可以是50MHz
5     .rst_n(rst_n),
6     //.rx_d(rx_d), //接收到的bit数据7     .rx_d(tx_d)//回环实验

8 .rx_data(rx_data),

9 .rx_valid(rx_valid)

10 );

例化一个 debugware IP:

1 //使用debugware查看编码&解码波形

2 debugware_v2_1 u_debugware_v2_1(

3 .trig_out_0(),

4 .data_in_0({tx_en_n,tx_d,rx_data_dis}),//数据拼接

5 .ref_clk_0(clk)

6 );

从 debugware 的波形看，使能按键按下后，编码模块将预留的数据进行编码并以串口的形式发送，rx_data_dis 显示解码后的数据。

六兼容设计

4.4节提到，为了方便只有传统数码管模块的同学进行设计，这里提供了传统的数码管驱动模块。

1 module hme_manchester(
2        //其他信号-略
3        //数码管
4        output [6:0] odata0,odata1,odata2,odata3,odata4,odata5,odata6,odata7
5 );
6 //其他模块-略-自行复制补充
7
8 HEX HEX_u(
9 .idata({3'd0,rx_data_dis[7],3'd0,rx_data_dis[6],3'd0,rx_data_dis[5],3'd0,rx_data_dis[4],3'd0,rx_data_dis[3],3'd0,rx_data_dis[2],3'd0,rx_data_dis[1],3'd0,rx_data_dis[0]}),
10 .rst(1'b1),
11 .clk(clk),
12 .odata0(odata0),
13 .odata1(odata1),
14 .odata2(odata2),
15 .odata3(odata3),
16 .odata4(odata4),
17 .odata5(odata5),
18 .odata6(odata6),
19 .odata7(odata7)
20 );
21 endmodule

1 module HEX(idata,rst,clk,odata0,odata1,odata2,odata3,odata4,odata5,odata6,odata7);
2 input [31:0] idata ;
3 input clk,rst;
4 output [6:0] odata0,odata1,odata2,odata3,odata4,odata5,odata6,odata7;
5 wire [6:0] d0,d1,d2,d3,d4,d5,d6,d7;
6 reg [6:0] odata0_r,odata1_r,odata2_r,odata3_r,odata4_r,odata5_r,odata6_r,odata7_r;
7
8 assign odata0=odata0_r;
9 assign odata1=odata1_r;
10 assign odata2=odata2_r;
11 assign odata3=odata3_r;
12 assign odata4=odata4_r;
13 assign odata5=odata5_r;
14 assign odata6=odata6_r;
15 assign odata7=odata7_r;
16 SHEX SHEX0 (.idata(idata[3:0]),
17            .rst(rst),
18            .clk(clk),
19            .odata(d0));
20 SHEX SHEX1 (.idata(idata[7:4]),
21            .rst(rst),
22            .clk(clk),
23            .odata(d1));
24 SHEX SHEX2 (.idata(idata[11:8]),
25            .rst(rst),
26            .clk(clk),
27            .odata(d2));
28 SHEX SHEX3 (.idata(idata[15:12]),
29            .rst(rst),
30            .clk(clk),
31            .odata(d3));
32 SHEX SHEX4 (.idata(idata[19:16]),
33            .rst(rst),
34            .clk(clk),
35            .odata(d4));
36 SHEX SHEX5 (.idata(idata[23:20]),
37            .rst(rst),
38           .clk(clk),
39            .odata(d5));
40 SHEX SHEX6 (.idata(idata[27:24]),
41            .rst(rst),
42            .clk(clk),
43            .odata(d6));
44 SHEX SHEX7 (.idata(idata[31:28]),
45            .rst(rst),
46            .clk(clk),
47            .odata(d7));
48 always@(posedge clk or negedge rst)
49 begin
50 if(rst==1'b0)
51 begin
52    odata0_r<=7'd0;
53    odata1_r<=7'd0;
54    odata2_r<=7'd0;
55    odata3_r<=7'd0;
56    odata4_r<=7'd0;
57    odata5_r<=7'd0;
58    odata6_r<=7'd0;
59    odata7_r<=7'd0;
60 end
61   else
62 begin
63    odata0_r<=d0;
64    odata1_r<=d1;
65    odata2_r<=d2;
66    odata3_r<=d3;
67    odata4_r<=d4;
68    odata5_r<=d5;
69    odata6_r<=d6;
70    odata7_r<=d7;
71 end
72 end
73 endmodule
74

1 module SHEX (idata,rst,clk,odata);
2 input [3:0] idata;
3 input rst,clk;
4 output [6:0] odata;
5 reg [6:0] odata_r;
6 assign odata=odata_r;
7 always@(posedge clk or negedge rst)
8 begin
9   if(rst==1'b0)
10    begin
11     odata_r<=7'd0;
12    end
13    else
14     begin
15      case(idata)
16       4'd0:odata_r<=7'b1000000;
17       4'd1:odata_r<=7'b1111001;
18       4'd2:odata_r<=7'b0100100;

19       4'd3:odata_r<=7'b0110000;
20       4'd4:odata_r<=7'b0011001;
21       4'd5:odata_r<=7'b0010010;
22       4'd6:odata_r<=7'b0000010;
23       4'd7:odata_r<=7'b1111000;
24       4'd8:odata_r<=7'b0000000;
25       4'd9:odata_r<=7'b0010000;
26      default:odata_r<=7'b0111111;
27      endcase
28     end
29 end
30 endmodule
31

　　审核编辑：汤梓红

打开APP阅读更多精彩内容