今天給大俠帶來基于FPGA的擴頻系統設計，由于篇幅較長，分三篇。今天帶來第一篇，下篇。話不多說，上貨。

在無線通信系統中，普遍使用擴頻通信技術，因此擴頻技術對通信系統具有重要的現實意義。直接序列擴頻技術是應用最廣的一種擴頻技術，FPGA具備高速度的并行性特點在無線通信系統中的優勢日益增強，利用FPGA實現直接序列擴頻技術，可增大傳輸速率，可以使擴頻技術有更好的發展與應用。

(資料圖)

本篇利用本原多項式產生偽隨機序列用作擴頻，通過同步模塊對擴頻后的信號進行捕獲，通過直接序列解擴模塊進行解擴。本篇給出了編解碼、擴頻解擴、同步的整體方案，使用Quartus實現功能，并結合Matlab和ModelSim對模塊進行調試和測試，實現擴頻通信模塊的搭建仿真，驗證其設計的正確性。首先概述了方案設計與論證、整體方案的設計、各個模塊的設計、個別模塊的調試與各個模塊的仿真驗證。本篇主要實現的模塊有：漢明編碼模塊、直接序列擴頻模塊、量化器模塊、同步模塊、直接序列解擴模塊和漢明譯碼模塊。各位大俠可依據自己的需要進行閱讀，參考學習。

第三篇內容摘要：本篇會介紹分析調試，包括漢明碼解碼模塊調試、直接序列擴頻模塊調試、同步模塊調試、整體設計資源占用率、整體設計RTL設計圖，還會介紹系統測試，包括漢明編碼模塊測試、直接序列擴頻模塊測試、量化器模塊測試、同步模塊測試、直接序列解擴模塊測試、漢明譯碼模塊測試、系統整體測試等相關內容。

四、分析調試

漢明編解碼模塊調試

首先利用Matlab該模塊進行調試，利用隨機函數生成10個隨機數，通過74漢明碼編碼函數對10個隨機函數進行編碼，隨機數分別為4’h0、4’hb、4’h6、4’h1、4’h3、4’h9、4’h7、4’h9、4’h7和4’hd，編碼后分別為7’h00、7’h4b、7’h46、7’h51、7’h23、7’h39、7’h17、7’h39、7’h17和7’h0d。具體如圖所示，對應Matlab代碼詳見附錄A。

圖 漢明碼編碼Matlab仿真圖

利用Matlab的隨機函數生成10個隨機數，通過74漢明碼編碼函數對10個隨機函數進行編碼，編碼后引入噪聲如圖所示：

圖 編碼后與加入噪聲后對比圖

通過譯碼函數進行譯碼，如下圖所示：

圖 編碼前與譯碼后對比圖

根據圖可知，當發生一位碼值錯誤時，漢明譯碼模塊可以正確糾錯；當發生一位以上碼值錯誤時，漢明譯碼模塊不能正確糾錯，導致譯碼錯誤。利用Matlab可知漢明譯碼模塊具有譯碼能力和一位碼值的糾錯能力。

利用Verilog對漢明碼編碼模塊和漢明譯碼模塊進行編寫，然后一同進行調試，在兩個模塊中間加一噪聲模塊，保證編碼后數據任意一位發生錯誤，通過譯碼模塊后，判斷是否能夠進行正確糾錯，編碼前數據與編碼后的數據是否一致，判斷兩個模塊的正確性，調試模型如圖所示：

圖 斷言調試模型

ModelSim仿真波形截圖如圖所示：

圖 漢明編解碼模塊仿真波形圖

利用斷言的仿真方式打印報告如圖所示，通過確認編解碼前后數據一致，也證明漢明編碼模塊和漢明譯碼模塊正確性。

圖 打印結果圖

直接序列擴頻模塊調試

利用Matlab對該模塊進行調試，利用Matlab偽隨機函數生成偽隨機數，通過設置初始值來與節表的結果進行對比，通過對比可以確定生成偽隨機序列滿足要求，為采用Verilog設計打好堅實的基礎。如圖為Matlab生成的偽隨機數，對應Matlab代碼詳見附錄A。

圖 Matlab生成偽隨機數圖

同步模塊調試

在進行同步調試時出現對不齊同步頭的問題，例如計算所延時時間應為29個系統時鐘周期，即計數器僅需要延時29個時鐘周期，因為計數器是從“0”開始進行計數，當計數值等于延時時間-1時，模塊可以進行同步頭解擴處理，由于沒有對齊同步頭，導致利用最小二乘法計算結果均大于預設閾值，系統無法進行下去。仿真波形截圖如圖所示：

圖 同步錯誤情況仿真波形圖

根據仿真波形結合設計代碼最終找到原因，由于同步模塊對延時時間信號進行捕獲也需要一個系統時鐘周期，所以計數器的計數值應該等于延時時間-2，模塊才可以進行同步頭解擴處理，仿真波形截圖如圖所示：

圖 同步修改正確仿真波形圖

整體設計資源占用率

在設計完成后，在如圖所示，該整體設計共使用3735個組合邏輯，占5%；使用1782個寄存器，占3%；使用39個I/O引腳，占6%；使用5888個存儲器，約占1%；使用2個9bit嵌入式硬件乘法器，約占1%。

圖 FPGA資源占用率

整體設計RTL視圖

由于例化的原因導致與整體設計框圖不一致，因為例化對其整體設計功能無影響。所以設計整體RTL視圖如圖所示：

圖 設計整體RTL圖

五、系統測試

對整體系統設計進行測試，通過發送端到接收端的各個模塊逐級進行測試，確保每個環節的正確性。

漢明編碼模塊模塊測試

利用Verilog進行漢明碼編碼模塊進行編寫。在testbench測試文件總輸入數據初始化為8’h55，通過時鐘上升沿到來進行取反，所以數據依次為8’h55、8’haa、8’h55…8’haa等，接口采用同步fifo進行數據緩沖，如圖所示，在測試文件中通過判斷t_full信號高有效來判斷fifo是否為滿狀態，若不是滿狀態，則置寫操作的使能信號t_wrreq高電平有效，對fifo進行寫操作，否則不進行寫操作。漢明碼編碼模塊通過判斷h_empty信號來判斷fifo是否為空狀態，若不為空，則置讀操作使能信號h_rdreq高電平有效對fifo進行讀操作，否則不進行讀操作。

圖 fifo接口圖

通過漢明碼編碼模塊對數據進行漢明碼編碼，如圖所示，信號ha_data為對應編碼結果。4’h5編碼為7’h2d，4’ha編碼為7’h52，如圖表明，漢明編碼模塊能夠正確編碼。

圖 漢明碼編碼模塊ModelSim仿真波形圖

直接序列擴頻模塊測試

利用Verilog進行偽隨機數模塊編寫，初始值為5’b00001，生成序列為如圖所示。信號m_bit為偽隨機數，在進行編碼數據信號進行擴頻之前，應將數據信息加上幀頭14’b11111111111110，信號m_data為漢明編碼模塊編碼后的7bits數據信息，信號s_bit為幀頭或編碼數據信息并串轉換后的信號，信號bc控制信號s_bit哪個數據位于信號m_bit相異或，得到的結果為輸出信號q_data，從而實現直接序列擴頻的功能。如圖表明，直接序列擴頻模塊能夠正確完成擴頻。

圖 直接序列擴頻模塊ModelSim仿真波形圖

量化器模塊測試

量化器模塊將單比特的信號變為8bits有符號數，仿真波形截圖如圖所示，可以確定量化器模塊能夠正確進行對信號量化。

圖 量化器模塊ModelSim仿真波形圖

同步模塊測試

為了模擬實際傳輸過程，擴頻信號再進入同步模塊前引入±46的噪聲，實際輸入值信號line如圖所示：

圖 加入噪聲后ModelSim仿真波形圖

利用最小二乘法對輸入信號與31個模板進行計算，得到小于閾值的唯一的延時數據信號xx如圖所示，模板2滿足要求，信號xx計算值為29，因此要進行29拍解擴時鐘周期的延時，來對齊同步頭。

圖 計算延時ModelSim仿真波形圖

通過延時達到對齊同步頭的目的，對齊使能信號en_m為高電平，說明已對齊。如圖所示：

圖 同步頭對齊ModelSim仿真波形圖

對齊后將數據信號每31bits與模板“0”模板“1”進行最小二乘法計算，如圖所示：

圖 同步頭解擴ModelSim仿真波形圖

信號data_tm為判斷出的信號數據，當檢測到同步頭最后一位的“0”數據信息后，說明同步頭已結束，同步功能已實現。如圖所示，同步模塊能夠正確實現同步。

圖 同步頭識別ModelSim仿真波形圖

直接序列解擴模塊測試

當檢測到最后一位為“0”后，進入數據信號解擴過程，與同步頭解擴相類似，只是把解擴后的數據利用計數器的計數值，寫到寄存器對應的位置，同時進行串并轉換功能，信號bc為計數器，信號hdata_reg1為串并轉換后存儲數據的寄存器。如圖所示，直接序列解擴模塊能夠正確實現解擴。

圖 數據信息解擴ModelSim仿真波形圖

漢明譯碼模塊測試

利用Verilog對漢明譯碼模塊進行編寫。通過直接序列解擴模塊后的數據經過漢明譯碼模塊后，如圖所示：

圖 漢明譯碼ModelSim仿真波形圖

信號data_reg被譯碼正確后通過對fifo的滿標志信號H_full高電平進行判斷，若為高電平則不進行寫操作，若為低電平則將fifo的寫使能信號置高進行寫操作，將譯碼后的數據寫入fifo中。如圖所示，漢明譯碼模塊能夠對數據進行正確譯碼。

圖 數據輸出端口仿真截圖

系統整體測試

通過打印信息確認，原始數據與譯碼后的數據一致，能夠確認系統整體設計正確，如圖所示：

圖 打印結果截圖

引用節設計要求，總結系統整體設計完成對應功能情況，如表所示：

表 系統功能測試表

結　　論

直接序列擴頻是主流的擴頻通信之一，有著許多重要特點與優點，本篇利用FPGA的處理速度和并行運行等特點，設計完成了一個基于FPGA擴頻模塊設計。在利用Quartus II、Matlab和ModelSim對直接序列擴頻模塊進行了仿真分析。利用偽隨機序列進行擴頻，是擴頻模塊獲得高抗噪聲性能和抗干擾性能的關鍵。

本文首先對直接序列擴頻模塊一般原理進行介紹，然后重點分析直接序列擴頻解擴，合理分配功能模塊、準確掌握各個模塊之間的控制和被控制的關系，以及整體時序關系。通過從接口fifo讀取數據后，采用漢明編碼模塊，完成了對數據的編碼，在完成編碼后加入同步頭，為同步做準備。利用本原多項式產生偽隨機數，偽隨機數與編碼后的數據進行異或處理，已達到擴頻的目的，擴頻后的數據進行量化且引入噪聲送入同步模塊。同步模塊利用31個偽隨機數的模板，采用最小二乘法對數據進行計算，計算值小于預定閾值，則該數據對應的信息為接收端需要進行延拍的個數，對齊后利用2個偽隨機數的模板對數據進行“0”和“1”的判斷，當同步頭數據值出現“0”后，代表下一位開始為數據信息，直接序列解擴模塊開始進行解擴處理，和同步模塊同理，將數據與2個偽隨機進行最小二乘法的計算，從而達到解擴的目的。解擴后的數據通過漢明譯碼模塊進行譯碼后寫入接口fifo，再通過fifo輸出。經過驗證該整體模塊達到擴頻的目的，提高了抗噪聲的能力，各個模塊能夠正確完成對應功能。

附錄部分源代碼

偽隨機數Matlab代碼：

polynomial=[1 0 0 1 0 1];reg=[0 0 0 0 1];grade=length(polynomial)-1;PN_Length=(2^grade-1);pn=zeros(1,PN_Length);n=0; c=zeros(1,grade);for i=grade:-1:1if polynomial(i)==1n=n+1;c(n)=grade+1-i;endendq=0;for i=1:PN_Lengthp(i)=reg(1)m=reg(grade+1-c(1));for q=2:gradeif (c(q)>0) & (reg(grade+1-c(q))==1)m=~m;endendfor q=1:(grade-1)reg(q)=reg(q+1);endreg(5)=m;end

漢明碼編碼譯碼Matlab代碼：

k=4;n=7;msg=randint(10,4,2)code=encode(msg,n,k)code_noise=rem(code+rand(10,7)>,2)rcv=decode(code_noise,n,k)disp(["Error rate in the received code:" num2str(symerr(code,code_noise)/length(code))])disp(["Error rate after decode:" num2str(symerr(msg,rcv)/length(msg))])

漢明碼編碼Verilog代碼：

module hamming74(clk_10, rst_n, hi_data, ha_data, hm_sel);input clk_10;input rst_n;input [7:0] hi_data;output reg [6:0] ha_data;input hm_sel;

wire [3:0] hm_data;wire q0,q1,q2;

assign hm_data = hm_sel ? hi_data[7:4] : hi_data[3:0];

always @ (posedge clk_10)beginif(!rst_n)beginha_data <= 0;endelsebeginha_data[6] <= hm_data[3];ha_data[5] <= hm_data[2];ha_data[4] <= hm_data[1];ha_data[3] <= q2;ha_data[2] <= hm_data[0];ha_data[1] <= q1;ha_data[0] <= q0;endend

assign q0 = hm_data[0] ^ hm_data[1] ^ hm_data[3];assign q1 = hm_data[0] ^ hm_data[2] ^ hm_data[3];assign q2 = hm_data[1] ^ hm_data[2] ^ hm_data[3];endmodule

偽隨機數產生Verilog代碼：

module m_generator(clk_10, rst_n, m_bit);

input clk_10;input rst_n;output m_bit;

reg [4:0] q;parameter KEY = 5"b00001;

always @ (posedge clk_10)beginif(!rst_n)beginq <= KEY;// q <= 0;endelse beginq[0] <= q[1];q[1] <= q[2];q[2] <= q[3];q[3] <= q[4];q[4] <= q[3] ^ q[0];endend

assign m_bit = q[0];

endmodule

偽隨機序列與數據信息異或處理Verilog代碼：

module me_xor(clk, rst_n, s_bit, m_bit, q_data);

input clk, rst_n;input s_bit, m_bit;output reg q_data;

always @ (posedge clk)beginif (!rst_n)q_data <= 0;elseq_data <= s_bit ^ m_bit;end

endmodule

量化器模塊Verilog代碼：

module quantizer(clk, rst_n, qdata, line_out);

input clk, rst_n;input qdata;output reg signed [7:0] line_out;

always @ (posedge clk)beginif (!rst_n)line_out <= 0;elseif (qdata)line_out <= 63;elseline_out <= -64;end

endmodule

最小二乘法Verilog代碼：

module m_leastsquare(clk_10, rst_n, line, distance);input clk_10, rst_n;input signed [7:0] line;output reg signed [21:0] distance;parameter KEY = 5"b00001;wire m;reg [4:0] count;reg signed [21:0] int_distance;

always @ (posedge clk_10)beginif (!rst_n || count >= 5"d30)count <= 0;elsecount <= count + 5"d1;endm_generator #(.KEY(KEY)) u_mg(.clk_10(clk_10), .rst_n(rst_n), .m_bit(m));always @ (posedge clk_10)beginif (!rst_n)beginint_distance <= 0;distance <= 0;endelseif (count < 5"d30)if (!m)int_distance <= int_distance + (line - 63) * (line - 63);elseint_distance <= int_distance + (line + 64) * (line + 64);elsebeginint_distance <= 0;if (!m)distance <= int_distance + (line - 63) * (line - 63);elsedistance <= int_distance + (line + 64) * (line + 64);endendendmodule

同步模塊Verilog部分代碼：

module test_mdecoder_ls(clk_10, rst_n, line, xx);input clk_10, rst_n;input signed [7:0] line;output reg [5:0] xx;wire signed [21:0] distance [30:0];wire [30:0] xx_reg;integer i;m_leastsquare #(.KEY(5"h01)) u0(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[0]));m_leastsquare #(.KEY(5"h10)) u1(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[1]));m_leastsquare #(.KEY(5"h08)) u2(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[2]));m_leastsquare #(.KEY(5"h14)) u3(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[3]));m_leastsquare #(.KEY(5"h0A)) u4(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[4]));m_leastsquare #(.KEY(5"h15)) u5(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[5]));m_leastsquare #(.KEY(5"h1A)) u6(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[6]));m_leastsquare #(.KEY(5"h1D)) u7(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[7]));m_leastsquare #(.KEY(5"h0E)) u8(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[8]));m_leastsquare #(.KEY(5"h17)) u9(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[9]));m_leastsquare #(.KEY(5"h1B)) u10(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[10]));m_leastsquare #(.KEY(5"h0D)) u11(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[11]));m_leastsquare #(.KEY(5"h06)) u12(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[12]));m_leastsquare #(.KEY(5"h03)) u13(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[13]));m_leastsquare #(.KEY(5"h11)) u14(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[14]));m_leastsquare #(.KEY(5"h18)) u15(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[15]));m_leastsquare #(.KEY(5"h1C)) u16(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[16]));m_leastsquare #(.KEY(5"h1E)) u17(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[17]));m_leastsquare #(.KEY(5"h1F)) u18(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[18]));m_leastsquare #(.KEY(5"h0F)) u19(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[19]));m_leastsquare #(.KEY(5"h07)) u20(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[20]));m_leastsquare #(.KEY(5"h13)) u21(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[21]));m_leastsquare #(.KEY(5"h19)) u22(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[22]));m_leastsquare #(.KEY(5"h0C)) u23(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[23]));m_leastsquare #(.KEY(5"h16)) u24(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[24]));m_leastsquare #(.KEY(5"h0B)) u25(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[25]));m_leastsquare #(.KEY(5"h05)) u26(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[26]));m_leastsquare #(.KEY(5"h12)) u27(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[27]));m_leastsquare #(.KEY(5"h09)) u28(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[28]));m_leastsquare #(.KEY(5"h04)) u29(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[29]));m_leastsquare #(.KEY(5"h02)) u30(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[30]));assign xx_reg[0] = (distance[0]>0 && distance[0]< 19"d50000)? 1"b1:1"b0;assign xx_reg[1] = (distance[1]>0 && distance[1]< 19"d50000)? 1"b1:1"b0;assign xx_reg[2] = (distance[2]>0 && distance[2]< 19"d50000)? 1"b1:1"b0;assign xx_reg[3] = (distance[3]>0 && distance[3]< 19"d50000)? 1"b1:1"b0;assign xx_reg[4] = (distance[4]>0 && distance[4]< 19"d50000)? 1"b1:1"b0;assign xx_reg[5] = (distance[5]>0 && distance[5]< 19"d50000)? 1"b1:1"b0;assign xx_reg[6] = (distance[6]>0 && distance[6]< 19"d50000)? 1"b1:1"b0;assign xx_reg[7] = (distance[7]>0 && distance[7]< 19"d50000)? 1"b1:1"b0;assign xx_reg[8] = (distance[8]>0 && distance[8]< 19"d50000)? 1"b1:1"b0;assign xx_reg[9] = (distance[9]>0 && distance[9]< 19"d50000)? 1"b1:1"b0;assign xx_reg[10] = (distance[10]>0 && distance[10]< 19"d50000)? 1"b1:1"b0;assign xx_reg[11] = (distance[11]>0 && distance[11]< 19"d50000)? 1"b1:1"b0;assign xx_reg[12] = (distance[12]>0 && distance[12]< 19"d50000)? 1"b1:1"b0;assign xx_reg[13] = (distance[13]>0 && distance[13]< 19"d50000)? 1"b1:1"b0;assign xx_reg[14] = (distance[14]>0 && distance[14]< 19"d50000)? 1"b1:1"b0;assign xx_reg[15] = (distance[15]>0 && distance[15]< 19"d50000)? 1"b1:1"b0;assign xx_reg[16] = (distance[16]>0 && distance[16]< 19"d50000)? 1"b1:1"b0;assign xx_reg[17] = (distance[17]>0 && distance[17]< 19"d50000)? 1"b1:1"b0;assign xx_reg[18] = (distance[18]>0 && distance[18]< 19"d50000)? 1"b1:1"b0;assign xx_reg[19] = (distance[19]>0 && distance[19]< 19"d50000)? 1"b1:1"b0;assign xx_reg[20] = (distance[20]>0 && distance[20]< 19"d50000)? 1"b1:1"b0;assign xx_reg[21] = (distance[21]>0 && distance[21]< 19"d50000)? 1"b1:1"b0;assign xx_reg[22] = (distance[22]>0 && distance[22]< 19"d50000)? 1"b1:1"b0;assign xx_reg[23] = (distance[23]>0 && distance[23]< 19"d50000)? 1"b1:1"b0;assign xx_reg[24] = (distance[24]>0 && distance[24]< 19"d50000)? 1"b1:1"b0;assign xx_reg[25] = (distance[25]>0 && distance[25]< 19"d50000)? 1"b1:1"b0;assign xx_reg[26] = (distance[26]>0 && distance[26]< 19"d50000)? 1"b1:1"b0;assign xx_reg[27] = (distance[27]>0 && distance[27]< 19"d50000)? 1"b1:1"b0;assign xx_reg[28] = (distance[28]>0 && distance[28]< 19"d50000)? 1"b1:1"b0;assign xx_reg[29] = (distance[29]>0 && distance[29]< 19"d50000)? 1"b1:1"b0;assign xx_reg[30] = (distance[30]>0 && distance[30]< 19"d50000)? 1"b1:1"b0;always @ (*)beginif(!rst_n)beginxx <= 6"d32;endelsebeginfor(i=0;i<30;i=i+1)if(xx_reg[i]==1)xx <= 31-i;endendendmodule

直接序列解擴模塊部分Verilog代碼：

module test_mdecoder_2s(clk_10, rst_n, line, data_tm, en_m); //測試，最小二乘法

input clk_10, rst_n;input signed [7:0] line;output data_tm;input en_m;wire signed [30:0] distance [1:0];wire [30:0] reg1 , reg0 ;

m_leastsquare_nl #(.KEY(5"h01)) u32(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[0]), .en_m(en_m));//0m_leastsquare_no #(.KEY(5"h01)) u33(.clk_10(clk_10), .rst_n(rst_n), .line(line), .distance(distance[1]), .en_m(en_m));//1

assign data_tm = ( distance[1]>distance[0])? 1"b0:1"b1;//比較倆數據大小

endmodule

漢明碼譯碼Verilog代碼：

module deserialzer(clk_10, rst_n, data_tm, en_m, hdata, h_full, h_wrreq);/* 串轉并模塊加漢明譯碼模塊 */input clk_10;input rst_n;input data_tm;input en_m;output reg [7:0] hdata;input h_full;output reg h_wrreq;reg [5:0] count;reg [2:0] bc;reg [6:0] hdata_reg1;reg start;wire c0,c1,c2;reg lh;reg [3:0] data_reg;/* 用來計算數據位 */always @ (posedge clk_10)beginif(!rst_n)begincount <= 0;bc <= 0;endelse if(en_m && count < 30)count <= count + 6"d1;elsebeginif(count == 6"d30 && bc < 3"d6)bc <= bc + 3"d1;elsebc <= 0;count <= 0;endend/* 用來緩沖數據 */always @ (posedge clk_10)beginhdata_reg1[bc] <= data_tm;end/* 用來控制數據寫在高低位，同時控制發送寫使能 */always @ (posedge clk_10)beginif(!rst_n)beginh_wrreq <= 0;lh <= 1;endelse if(!h_full && bc == 3"d6 && count == 6"d30)beginlh <= ~lh;if(lh)h_wrreq <= 0;elseh_wrreq <= 1;endelseh_wrreq <= 0;end/* 用來控制譯碼的使能 */always @ (posedge clk_10)beginif(!rst_n)beginstart <= 0;

endelse if(!h_full && bc == 3"d6 && count == 6"d29)beginstart <= 1;endelsestart <= 0;endassign c0 = hdata_reg1[0] ^ hdata_reg1[2] ^ hdata_reg1[4] ^ hdata_reg1[6];assign c1 = hdata_reg1[1] ^ hdata_reg1[2] ^ hdata_reg1[5] ^ hdata_reg1[6];assign c2 = hdata_reg1[3] ^ hdata_reg1[4] ^ hdata_reg1[5] ^ hdata_reg1[6];/* 用來高低位數據賦值 */always @ (*)beginif(lh)hdata[7:4] <= data_reg;elsehdata[3:0] <= data_reg;endalways @ (posedge clk_10)beginif(!rst_n)begindata_reg <= 0;endelse if (start)case({c2,c1,c0})3"b000:begin//沒錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b001:begin//校驗位hc_in[0]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b010:begin//校驗位hc_in[1]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b011:begin//校驗位hc_in[0]、hc_in[1]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= ~hdata_reg1[2];end3"b100:begin//校驗位hc_in[2]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b101:begin//校驗位hc_in[0]、hc_in[2]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= ~hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b110:begin//校驗位hc_in[1]、hc_in[2]有錯誤data_reg[3] <= hdata_reg1[6];data_reg[2] <= ~hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];end3"b111:begin//校驗位hc_in[1]、hc_in[2]、hc_in[0]有錯誤data_reg[3] <= ~hdata_reg1[6];data_reg[2] <= hdata_reg1[5];data_reg[1] <= hdata_reg1[4];data_reg[0] <= hdata_reg1[2];endendcaseend

endmodule