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

前言

四月到现在一直比较忙，有一段时间没有做京微齐力器件的开发了，本次做一个新器件 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 //技术交流：[e-mail]
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

70

71

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。

1 //************Message***************//
2 //技术交流：[e-mail]
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏
5 //All rights reserved
6 //-------------------------------
7 // Target Devices: H7P20N0L176-M2H1
8 // Tool Versions: Fuxi 2023.1
9 // File name: manchester_tx
10 // Last modified Date: 2023年6月17日900
11 // Last Version: V1.1
12 // Descriptions 编码&发送模块模块

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 //技术交流：[e-mail]
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 //技术交流：[e-mail]
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏

5 //All rights reserved

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位数码管，采用动态扫描的显示方式，即轮流向各位数码管送出字形码和相应的位选，利用发光管的余辉和人眼视觉暂留作用，使人的感觉好像各位数码管同时都在显示。

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

1 //************* Message *************//
2 //技术交流：[e-mail]
3 //关注CSDN博主：“千歌叹尽执夏”
4 //Author: 千歌叹尽执夏
5 //All rights reserved

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

审核编辑：汤梓红