前言

四月到現(xiàn)在一直比較忙，有一段時間沒有做京微齊力器件的開發(fā)了，本次做一個新器件 H7 的曼徹斯特（編碼&解碼&通信）系統(tǒng)。

方案講解

一關于曼徹斯特編碼

曼徹斯特編碼（Manchester coding），又稱自同步碼、相位編碼（phase encoding，PE），能夠用信號的變化來保持發(fā)送設備和接收設備之間的同步。

值得一提的是，曼徹斯特編碼有兩種截然相反的約定：

它用電壓的變化來分辨0和1，從高電平到低電平的跳變代表1，而從低電平到高電平的跳變代表0(G.E.Tomas編碼方式)。

從高電平到低電平的跳變代表0，而從低電平到高電平的跳變代表1(IEEE 802.3編碼方式)，信號的保持不會超過一個比特位的時間間隔。即使是0或1的序列，信號也將在每個時間間隔的中間發(fā)生跳變。這種跳變將允許接收設備的時鐘與發(fā)送設備的時鐘保持一致。

兩種曼徹斯特編碼：

優(yōu)點：

與 NRZ 相比，曼徹斯特編碼提供一種同步機制，保證發(fā)送端與接收端信號同步。

缺點：

曼徹斯特編碼的頻率要比 NRZ 高一倍，傳輸?shù)攘繑?shù)據(jù)所需的帶寬大一倍。

編碼：

曼徹斯特編碼是將時鐘和數(shù)據(jù)包含在信號流中，在傳輸代碼信息的同時，也將時鐘同步信號一起傳輸?shù)綄Ψ健Ｂ鼜厮固卮a是用“01”和“10”來表示普通二進制數(shù)據(jù)中的“1””和“0”的，因此在實際電路設計中，我們可以用采一個2選1數(shù)字選擇器來完成此項功能。（IEEE 802.3編碼方式）

解碼：

曼徹斯特譯碼電路設計的目的，是如何準確地從曼徹斯特碼的碼流中提取出“10”和“01”信號，并將其轉換成普通二進制編碼中的“0”和“1”。

在實際設計電路中，可以采用一個緩存器，保存上一個時鐘采集到的信號和當前時鐘采集到的信號，當緩存器的內容是“01”時，輸出“1”；當緩存器的內容是“10”時，輸出“0”；當緩存器的內容是“00”或“11”時，輸出維持不變。

曼徹斯特編碼在 FPGA 領域的運用比較廣泛：

以太網(wǎng)：在以太網(wǎng)中，曼徹斯特編碼被用來將數(shù)據(jù)轉換為數(shù)字信號，并通過物理媒介（如同軸電纜或光纖）傳輸。

遠程控制系統(tǒng)：在無線遙控器中，曼徹斯特編碼被用來將指令編碼并通過無線信道發(fā)送給接收器。

工業(yè)自動化系統(tǒng)：在工業(yè)自動化系統(tǒng)中，曼徹斯特編碼被用來將傳感器測量值、控制信號等轉換為數(shù)字信號，并通過數(shù)據(jù)總線傳輸。

汽車電子系統(tǒng)：在汽車電子系統(tǒng)中，曼徹斯特編碼被用來將控制信號、傳感器信號等轉換為數(shù)字信號，并通過汽車網(wǎng)絡傳輸。

曼徹斯特編碼的時鐘線與數(shù)據(jù)線結合一體，同步性高，錯誤檢測性能好，去年在接觸屏顯項目的時候，便是用到了這一編碼。

二任務&實驗效果

用兩塊 FPGA 開發(fā)板設計一個曼徹斯特碼編碼和解碼系統(tǒng)；

第1塊板負責在按鍵后將撥碼開關撥出的8位二進制碼用曼徹斯特碼發(fā)出；

第2塊板負責在收到曼徹斯特碼號將其解析并在數(shù)碼管上顯示。兩塊板記得共地。（也可以用 debugware 進行波形讀取）

進入正文前，先看實驗效果：

京微齊力：基于H7的曼徹斯特（編碼&解碼&串口）系統(tǒng)

可以看到，H7 端按下發(fā)送鍵后，第二塊開發(fā)板，接收到信號并進行解碼，結果（1111_0000）顯示在8位數(shù)碼管上。（具體過程請看程序解析）

三硬件選擇

1、H7P20N0L176-M2H1

本次實驗使用 H7 作為主控板，HME-H7 系列采用低功耗22nm 技術，集成了高性能 ARM Cortex-M3 MCU(頻率高達300M）、外圍設備與大容量片上 SRAM。本次實驗只使用邏輯部分，后面根據(jù)需要再擴展 MCU 實驗。

H7 具有12K的6輸入查找表，1個 OSC（80Mhz片內振蕩器），128個 10x10 DSP 模塊，18個32K x 32位 SRAM，擁有多個封裝，能夠兼容Altera 的 EP4CE10 和 Xilinx Spartan-6，適用于伺候電機、圖像處理及通信網(wǎng)絡等多種場景。

2、XC7A35TFGG484-2

因為 H7 板卡沒有數(shù)碼管，這里借助一塊 Spartan-7 板卡展示實驗效果。（如果沒有多余板載數(shù)碼管的開發(fā)板，可以使用 FUXI 軟件的 debugware IP 進行波形觀看）

四程序設計

1、頂層模塊

本模塊，實現(xiàn)的是 H7 對 tx_data(8’b11110000)進行編碼，按下按鍵（tx_en_n）后，會以 UART 的方式發(fā)送數(shù)據(jù)到第2塊開發(fā)板 （這里模擬一個通信的效果，如果有 Lora 模塊的同學，可以接上模塊，這樣就實現(xiàn)了無線通信)。關于編碼部分，原本是計劃使用撥碼開關來模擬需要發(fā)送的8bit數(shù)據(jù)，但是板卡沒有撥碼開關，這里例化的時候，直接對端口進行賦值。程序里仍保留了撥碼開關接口，有需要的同學，可以自行例化。

1 //************Message***************//
2 //技術交流：bumianzhe@126.com
3 //關注CSDN博主：“千歌嘆盡執(zhí)夏”
4 //Author: 千歌嘆盡執(zhí)夏
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數(shù)據(jù)（本實驗支持回環(huán)）
20 output tx_d, //將tx_data進行編碼并以串口方式發(fā)送出去
21 //發(fā)送使能
22 input tx_en_n,//發(fā)送使能，使用按鍵控制
23 input [7:0] tx_data,//發(fā)送的8bits數(shù)據(jù)，撥碼開關控制
24 output sh_cp, //串行數(shù)據(jù)輸出
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; //最終顯示的接收數(shù)據(jù)
32 wire [7:0] sel; //數(shù)碼管位選（選擇當前要顯示的數(shù)碼管）
33 wire [6:0] seg; //數(shù)碼管段選（當前要顯示的內容)
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), //待發(fā)送的字節(jié)數(shù)據(jù)
47 .tx_data(8'b11110000), //由于板卡上沒有撥碼開關，這里直接輸入數(shù)據(jù)進行模擬
48 .tx_en(!tx_en_n), //發(fā)送使能
49 .tx_ready(),
50 .tx_d(tx_d)
51 );
52 //如果沒有兩塊板卡的，可以將manchester_tx的tx_d信號接到manchester_rx的rx_d
53 //形成回環(huán)實驗，并利用debugware進行數(shù)據(jù)查看。
54 manchester_rx u_manchester_rx_0(
55 .clk(clk), //高頻時鐘，可以是50MHz
56 .rst_n(rst_n),
57 .rx_d(rx_d), //接收到的bit數(shù)據(jù)
58 //.rx_d(tx_d), //回環(huán)實驗
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、編碼&發(fā)送模塊

本模塊，對需要發(fā)送的8bit數(shù)據(jù)進行曼徹斯特編碼，并以串口的方式發(fā)送出去（波特率9600）。

首先，當復位信號 rst_n 為低電平時，將會執(zhí)行 if(rst_n==1’b0) 語句中的代碼，對模塊中的所有寄存器進行初始化。

接著，在每一個時鐘周期的上升沿，如果時鐘倍頻使能信號 clk_bps_en 為真，則將執(zhí)行 case(state)語句中當前狀態(tài)下對應的代碼。

當狀態(tài)機處于 IDLE 狀態(tài)時，如果 tx_en 為真，則需要開始發(fā)送數(shù)據(jù)。此時，需要將狀態(tài)切換為 TXS，將要發(fā)送的數(shù)據(jù)寫入 tx_data_reg，設置 tx_ready_r 為低電平，并將 tx_cnt 設置為0。

當狀態(tài)機處于 TXS 狀態(tài)時，需要根據(jù)已經(jīng)發(fā)送的數(shù)據(jù)字節(jié)數(shù) tx_cnt 來進行數(shù)據(jù)編碼，同時更新 tx_ready_r、tx_d_r 和 tx_data_reg 的值。

具體編碼過程如下：

當 tx_cnt 為 0 時，需要發(fā)送兩個高電平（1bit 數(shù)據(jù)編制成 2bit 數(shù)據(jù)）。當 tx_cnt 的值在 [1, 8] 之間時，需要按照 Manchester 編碼方式編碼數(shù)據(jù)并發(fā)送出去。

具體操作如下：

根據(jù) tx_data_reg 的最高位來計算當前發(fā)送的是01還是10。如果最高位為1，則當前發(fā)送的是01，否則當前發(fā)送的是10。對于 tx_cnt 中的每一位（從右往左數(shù)），如果是0，則發(fā)送的是10，否則發(fā)送的是01。

將 tx_data_reg 向左移動一位，為下一次計算做準備。

當 tx_cnt 的值大于8時，需要發(fā)送一個低電平，因此將 tx_d_r 設置為低電平。

如果 tx_cnt 達到了指定長度（這里是19），則需要重新將狀態(tài)切換為 IDLE，設置 tx_ready_r 為高電平，并將 tx_cnt 設置為0。

1 //************Message***************//
2 //技術交流：bumianzhe@126.com
3 //關注CSDN博主：“千歌嘆盡執(zhí)夏”
4 //Author: 千歌嘆盡執(zhí)夏
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 編碼&發(fā)送模塊模塊

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

16 input clk, //高頻時鐘，可以是50MHz

17 input rst_n,

18 input [7:0] tx_data,//待發(fā)送的字節(jié)數(shù)據(jù)

19 input tx_en, //發(fā)送使能

20 output tx_ready,

21 output tx_d

22 );

23 parameter IDLE = 1'b0;//空閑狀態(tài)

24 parameter TXS = 1'b1;//發(fā)送狀態(tài)

25 reg tx_ready_r;

26 reg tx_d_r;

27 reg state;

28 reg [4:0] tx_cnt;//發(fā)送的bits計數(shù)器

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;//發(fā)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、解碼&接收模塊

接收到的串行數(shù)據(jù)進行解串行化，然后進行解碼。

解碼與編碼原理差不多，這里不做贅述。

1 //*********** Message **********//
2 //技術交流：bumianzhe@126.com
3 //關注CSDN博主：“千歌嘆盡執(zhí)夏”
4 //Author: 千歌嘆盡執(zhí)夏
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數(shù)據(jù)
19 output [7:0] rx_data,
20 output rx_valid
21 );
22
23 parameter IDLE = 1'b0;//空閑狀態(tài)
24 parameter RXS = 1'b1;//接收狀態(tài)
25 reg state;
26 reg rx_valid_r0,rx_valid_r;
27 reg [15:0] rx_data_reg;//緩存16bits的rx數(shù)據(jù)，每2bits代表1bit數(shù)據(jù)//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倍波特率的時鐘計數(shù)
32 reg [3:0] byte_cnt;//對已接收的字節(jié)計數(shù)
33 assign rx_data = rx_data_r;
34 assign rx_valid = rx_valid_r;
35
36 //將一組長度為16的串行數(shù)據(jù)rx_data_reg轉換成一組長度為8的并行數(shù)據(jù)rx_data_w，
37 //即將接收到的串行數(shù)據(jù)進行解串行化。
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，該芯片的作用是移位寄存器，通過移位的方式，節(jié)省 FPGA 的管腳。FPGA 只需要輸出3個管腳，即可達到發(fā)送數(shù)碼管數(shù)據(jù)的目的，與傳統(tǒng)的選位選方式相比，大大節(jié)省了 IO 設計資源。（考慮到部分同學，只有普通的8段數(shù)碼管模塊，沒有74HC595，在文末會添加傳統(tǒng)的數(shù)碼管驅動代碼，方便大家做兼容設計）。

1 //************Message ***************//
2 //技術交流：bumianzhe@126.com
3 //關注CSDN博主：“千歌嘆盡執(zhí)夏”
4 //Author: 千歌嘆盡執(zhí)夏

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，發(fā)出數(shù)據(jù)和選通信號
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;//分頻計數(shù)器;
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位數(shù)碼管，采用動態(tài)掃描的顯示方式，即輪流向各位數(shù)碼管送出字形碼和相應的位選，利用發(fā)光管的余輝和人眼視覺暫留作用，使人的感覺好像各位數(shù)碼管同時都在顯示。

比較簡單的數(shù)碼管段選、位選模塊，這里不做贅述。

1 //************* Message *************//
2 //技術交流：bumianzhe@126.com
3 //關注CSDN博主：“千歌嘆盡執(zhí)夏”
4 //Author: 千歌嘆盡執(zhí)夏
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: 分頻信號，段選和位選信號生成，輸出需要顯示的數(shù)據(jù)、段選和位選值
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; //數(shù)碼管顯示使能，1使能，0關閉
27
28 input [31:0]disp_data;
29
30 output [7:0] sel;//數(shù)碼管位選（選擇當前要顯示的數(shù)碼管）
31 output reg [6:0] seg;//數(shù)碼管段選（當前要顯示的內容）
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;//數(shù)據(jù)緩存
39
40// 分頻計數(shù)器計數(shù)模塊
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位循環(huán)移位寄存器
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 回環(huán)實驗

本節(jié)適用于只有一塊板卡的同學，將發(fā)送模塊的 tx_d 信號接到接收模塊的 rx_d 信號，形成回環(huán)實驗，并調用 debugware 進行數(shù)據(jù)分析。

1 //如果沒有兩塊板卡的，可以將 manchester_tx 的 tx_d 信號接到 manchester_rx 的 rx_d

2 //形成回環(huán)實驗，并利用debugware進行數(shù)據(jù)查看。

3 manchester_rx u_manchester_rx_0(

4 .clk(clk), //高頻時鐘，可以是50MHz
5 .rst_n(rst_n),
6 //.rx_d(rx_d), //接收到的bit數(shù)據(jù)7 .rx_d(tx_d)//回環(huán)實驗

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}),//數(shù)據(jù)拼接

5 .ref_clk_0(clk)

6 );

從 debugware 的波形看，使能按鍵按下后，編碼模塊將預留的數(shù)據(jù)進行編碼并以串口的形式發(fā)送，rx_data_dis 顯示解碼后的數(shù)據(jù)。

六兼容設計

4.4節(jié)提到，為了方便只有傳統(tǒng)數(shù)碼管模塊的同學進行設計，這里提供了傳統(tǒng)的數(shù)碼管驅動模塊。

1 module hme_manchester(
2 //其他信號-略
3 //數(shù)碼管
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

審核編輯：湯梓紅