实现功能

显示待测信号频率; 输出特定频率信号; 蓝牙通信: 从手机发送特定信息给下位机改变输出信号频率并显示。

自顶向下的管理

顶模块根据三个SW开关选择进行不同行为模式。

1、显示学号模式,数码管译码模块根据预设数字字典进行显示。

2、显示待测信号频率,信号整型方波模块将输入信号变为0,1的数字方波,频率计数模块将整型后的方波进行计数(这里采用计算1s内有几个方波信号的方法)。

3、输出特定频率正弦信号,通过分频模块改变输入时钟与DDS模块产生正弦波,输出特定频率正弦信号。

4、蓝牙通信:通过蓝牙模块接收上位机发送的消息,改变数码管显示值,输出对应频率正弦信号。

项目难点

蓝牙通信

注意传送时序(波特率限制) 注意传送逻辑(传送时是8位(8bit) 传送, 0和1之间包裹8bit 信息) 传送时是1位1位传送 需要考虑传送数据位数,最终填满32位信息,对应四个传送周期(4*8bit)

顶模块

负责管理子模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
`timescale 1ns / 1ps
module Top_module(
input wire clk,clr ,//模式、时钟、清零
input wire [2:0] mode,
input [7:0] SW,
input [9:0]din,//输入D/A信号
input rx,//输入串行的蓝牙信号,0101010...
input pause,
output wire [6:0] a_to_g0,//两个段选
output wire [6:0] a_to_g1,
output wire [7:0] position,//8个位选
output wire point4,//小数点
output wire point5,
output [5:0] D,
output aclk,//给D/A转换器一个时钟
output clk_AD,
// output [31:0] fre_Hz,
output wire [7 : 0] douta, // output wire [7 : 0] douta
output [1:0] led,
output [4:0]BTD,
output tx
);
assign BTD=5'b10111;
assign D=6'b000000; //DA转换上六位输入
wire [31:0]fre_Hz;
assign fre_Hz=c1.fre_Hz;
sub_Frequency_div d1(
.clk(clk),
.clr(clr),
.d(5000)
);//分频10000 10kHx

//七段译码显示:三种模式

sub_7seg s1 (
.B3_BCD(B3.BCD),
.B4_BCD(B4.BCD),
.B5_BCD(B5.BCD),
.pause(pause),
.clk1(clk),
.clk(d1.div_frequency),
.SW(SW),
.mode(mode),
.point4(point4),
.point5(point5),
.a_to_g1(a_to_g1),
.a_to_g0(a_to_g0),
.position(position)
// .din(sin1.douta)
);
//.....................DDS,调用ROM IP核................................//
sub_Frequency_div d2(
.clk(clk),
.clr(clr),
.d(5)
);//分频10 10MHx
assign aclk=d2.div_frequency;
assign clk_AD=d2.div_frequency;
reg[7:0]SW_inside;

sub_DDS_sine sin1(
.clk(d2.div_frequency),
.clr(clr),
.SW(SW_inside),
.douta(douta)
);
//。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。//

//转换为0,1方波
clk_ut u1(
.clk(clk),
.din(din)//输入信号
//.din(douta)//仿真测试
);

sub_cal_freq c1( //高频
.clk(clk),
.clr(clr),
.ulk(u1.ulk)
);
sub_cal_low_freq c2( //低频
.clk(clk),
.clr(clr),
.ulk(u1.ulk)
);

sub_get_f_BCD B3(
.clk(clk),
.f(c1.fre_Hz)
);



sub_get_f_BCD B4( //测量低频
.clk(clk),
.f(c2.Fre_Hz_low)
);



//蓝牙
wire [31:0]f2;
assign f2=(SW_inside[0]+SW_inside[1]*2+SW_inside[2]*4+SW_inside[3]*8+SW_inside[4]*16+SW_inside[5]*32+SW_inside[6]*64+SW_inside[7]*128)*78125/2;
wire[31:0] message;
assign message=bt.message;
always@(posedge clk)begin
if(mode==3'b111)
SW_inside<=message;
else
SW_inside<=SW;
end
sub_Blue_teeth bt(
.sys_clk(clk),
.rx(rx),
.led(led)
);
sub_get_f_BCD B5(
.clk(clk),
.f(f2)
);



endmodule

分频模块

通过每隔n基准脉冲翻转一次进行分频,分频结果为 f/(2n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
`timescale 1ns / 1ps
module sub_Frequency_div(
input clk,clr,
input [18:0]d,
output div_frequency
);
reg[32:0] div=1;
reg y=1;
assign div_frequency=y;
always@(posedge clk)
begin
if(div<=d)//10000
begin
div<=div+1;
y<=0;
end
else if(div>=d+d)
begin
div<=1;
y<=1;
end
else
begin
div<=div+1;
y<=1;
end
end

endmodule

数码管译码模块

模块主控

根据 SW 3位开关输入改变显示模式; 模式1: 显示学号; 模式2: 显示待测信号频率; 模式3: 显示输出信号频率; 显示思路: 片选+段选,循环导通每一位数码管进行显示,只要频率够快,看起来是同时显示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
`define zero 7'b1111110
`define one 7'b0110000
`define two 7'b1101101
`define three 7'b1111001
`define four 7'b0110011
`define five 7'b1011011
`define six 7'b1011111
`define seven 7'b1110000
`define eight 7'b1111111
`define nine 7'b1111011
module sub_7seg(
input clk,clk1,clr,
input [7:0]SW,
input [2:0]mode,
input [7:0]din,//输入频待测D/A波形
input [31:0]B3_BCD,
output wire [6:0] a_to_g0,//两个段选
output wire [6:0] a_to_g1,
output wire [7:0] position,//8个位选
output wire point4,//小数点
output wire point5
);

reg [6:0]S0,S1,S2,S3,S4,S5,S6,S7;//8个BCD?码的译码值
reg [6:0]a_to_g1_t=7'b1111110;//预设值
reg [6:0]a_to_g0_t=7'b1111110;
reg point4_t;
reg point5_t=0;
reg point4_mode;//小数点中间变量
reg point5_mode;
reg [7:0] position_t=8'b10000000;
assign a_to_g1=a_to_g1_t;
assign a_to_g0=a_to_g0_t;
assign point4=point4_mode;
assign point5=point5_mode;
assign position=position_t;



//模式1译码。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
sub_7seg_translate mode1_7(
.seg7(2),
.clk(clk1)
);
sub_7seg_translate mode1_6(
.seg7(0),
.clk(clk1)
);
sub_7seg_translate mode1_5(
.seg7(2),
.clk(clk1)
);
sub_7seg_translate mode1_4(
.seg7(2),
.clk(clk1)
);
sub_7seg_translate mode1_3(
.seg7(0),
.clk(clk1)
);
sub_7seg_translate mode1_2(
.seg7(8),
.clk(clk1)
);
sub_7seg_translate mode1_1(
.seg7(4),
.clk(clk1)
);
sub_7seg_translate mode1_0(
.seg7(4),
.clk(clk1)
);
//。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。



//。。。。。。。。。模式2译码。。。。。。。。。。。。。。
wire [31:0]f;
assign f=(SW[0]+SW[1]*2+SW[2]*4+SW[3]*8+SW[4]*16+SW[5]*32+SW[6]*64+SW[7]*128)*78125/2;
//换算BCD
sub_get_f_BCD B2(
.clk(clk1),
.f(f)
);
wire [4:0] BCD8,BCD7,BCD6,BCD5,BCD4,BCD3,BCD2,BCD1;//不加这个中间变量会变成x
assign BCD1=B2.BCD[3:0];
assign BCD2=B2.BCD[7:4];
assign BCD3=B2.BCD[11:8];
assign BCD4=B2.BCD[15:12];
assign BCD5=B2.BCD[19:16];
assign BCD6=B2.BCD[23:20];
assign BCD7=B2.BCD[27:24];
assign BCD8=B2.BCD[31:27];
//。。。。。。。。。。译码开始。。。。。。。。
sub_7seg_translate mode2_7(
.seg7(BCD8),
.clk(clk1)
);
sub_7seg_translate mode2_6(
.seg7(BCD7),
.clk(clk1)
);
sub_7seg_translate mode2_5(
.seg7(BCD6),
.clk(clk1)
);
sub_7seg_translate mode2_4(
.seg7(BCD5),
.clk(clk1)
);
sub_7seg_translate mode2_3(
.seg7(BCD4),
.clk(clk1)
);
sub_7seg_translate mode2_2(
.seg7(BCD3),
.clk(clk1)
);
sub_7seg_translate mode2_1(
.seg7(BCD2),
.clk(clk1)
);
sub_7seg_translate mode2_0(
.seg7(BCD1),
.clk(clk1)
);
//。。。译码结束。。。。。。


//模式3测量频率
//.......输入时钟。。。。。测量频率..................
//。。。。。。。。。。译码开始。。。。。。。。
wire [4:0] BCD81,BCD71,BCD61,BCD51,BCD41,BCD31,BCD21,BCD11;//不加这个中间变量再放进译码器会变成x
assign BCD11=B3_BCD[3:0];
assign BCD21=B3_BCD[7:4];
assign BCD31=B3_BCD[11:8];
assign BCD41=B3_BCD[15:12];
assign BCD51=B3_BCD[19:16];
assign BCD61=B3_BCD[23:20];
assign BCD71=B3_BCD[27:24];
assign BCD81=B3_BCD[31:27];
//。。。。。。。。。。译码开始。。。。。。。。
sub_7seg_translate mode3_7(
.seg7(BCD81),
.clk(clk1)
);
sub_7seg_translate mode3_6(
.seg7(BCD71),
.clk(clk1)
);
sub_7seg_translate mode3_5(
.seg7(BCD61),
.clk(clk1)
);
sub_7seg_translate mode3_4(
.seg7(BCD51),
.clk(clk1)
);
sub_7seg_translate mode3_3(
.seg7(BCD41),
.clk(clk1)
);
sub_7seg_translate mode3_2(
.seg7(BCD31),
.clk(clk1)
);
sub_7seg_translate mode3_1(
.seg7(BCD21),
.clk(clk1)
);
sub_7seg_translate mode3_0(
.seg7(BCD11),
.clk(clk1)
);


//。。根据不同模式进行不同显示行为。。。。。。。。。。。。。。。
wire [6:0] ss0,ss1,ss2,ss3,ss4,ss5,ss6,ss7;
assign ss0=mode3_0.seg_output;
assign ss1=mode3_1.seg_output;
assign ss2=mode3_2.seg_output;
assign ss3=mode3_3.seg_output;
assign ss4=mode3_4.seg_output;
assign ss5=mode3_5.seg_output;
assign ss6=mode3_6.seg_output;
assign ss7=mode3_7.seg_output;
reg [6:0]t0=`one;
reg [6:0]t1=`one;
reg [6:0]t2=`one;
reg [6:0]t3=`one;
reg [6:0]t4=`one;
reg [6:0]t5=`one;
reg [6:0]t6=`one;
reg [6:0]t7=`one;


always@(negedge clk1)
begin
//显示输出信号频率
case(mode)
2'b10:begin
S0<= mode2_0.seg_output;
S1<= mode2_1.seg_output;
S2<= mode2_2.seg_output;
S3<= mode2_3.seg_output;
S4<= mode2_4.seg_output;
S5<= mode2_5.seg_output;
S6<= mode2_6.seg_output;
S7<= mode2_7.seg_output;
point5_mode<=point5_t;
point4_mode<=0;
end
//显示待测信号频率
2'b01:begin
S0<= mode1_0.seg_output;
S1<= mode1_1.seg_output;
S2<= mode1_2.seg_output;
S3<= mode1_3.seg_output;
S4<= mode1_4.seg_output;
S5<= mode1_5.seg_output;
S6<= mode1_6.seg_output;
S7<= mode1_7.seg_output;
point4_mode<=point4_t;
point5_mode<=0;
end
//显示学号
3'b100:begin
S0<= ss0;
S1<= ss1;
S2<= ss2;
S3<= ss3;
S4<= ss4;
S5<=ss5;
S6<=ss6;
S7<=ss7;
point5_mode<=point5_t;
point4_mode<=0;
end
default:begin
S0<=`zero;
S1<=`zero;
S2<=`zero;
S3<=`zero;
S4<=`zero;
S5<=`zero;
S6<=`zero;
S7<=`zero;
point4_mode<=0;
point5_mode<=0;
end
endcase
end


//。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
//段选。。。。。。。。。。。。。。。。。。。。。。。。。。。
always@(negedge clk1)
begin
case(position_t)
8'b10000000:begin
a_to_g1_t<= S7;
end
8'b01000000:begin
a_to_g1_t<=S6;
end
8'b00100000: begin
a_to_g1_t<=S5;
end
8'b00010000:begin
a_to_g1_t<=S4;
end
8'b00001000:begin
a_to_g0_t<=S3;
end
8'b00000100: begin
a_to_g0_t<=S2;
end
8'b00000010: begin
a_to_g0_t<=S1;
end
8'b00000001:begin
a_to_g0_t<=S0;
end
default: begin
a_to_g1_t<=`two;
a_to_g0_t<=S0;
end
endcase
end
//第五个小数点
always@(negedge clk1)begin

case(position_t)
8'b10000000:begin
point4_t<=0;
point5_t<=0;
end
8'b01000000:begin
point4_t<=0;
point5_t<=0;
end
8'b00100000: begin
point4_t<=0;
point5_t<=0;
end
8'b00010000:begin
point4_t<=1;
point5_t<=0;
end
8'b00001000:begin
point4_t<=0;
point5_t<=1;
end
8'b00000100: begin
point4_t<=0;
point5_t<=0;
end
8'b00000010: begin
point4_t<=0;
point5_t<=0;
end
8'b00000001:begin
point5_t<=0;
point4_t<=0;
end
default begin
point4_t<=0;
point5_t<=0;
end
endcase
end
//。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。


//片选。。。。。。。。。。。。。。。。。。。。。。。。。。。。
always@(posedge clk)
begin

case(position_t)
8'b10000000: position_t<=8'b01000000;
8'b01000000: position_t<= 8'b00100000;
8'b00100000: position_t<= 8'b00010000;
8'b00010000: position_t<=8'b00001000;
8'b00001000:position_t<=8'b00000100;
8'b00000100 : position_t<= 8'b00000010;
8'b00000010 :position_t<=8'b00000001;
8'b00000001 :position_t<=8'b10000000;
default:
position_t<=8'b10000000;
endcase

end
//,。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。


endmodule

译码子模块

进行简单的字典翻译工作,只翻译一位七段译码管 输出脚控制七段译码管 a_to_g 七个二极管

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
`timescale 1ns / 1ps

`define zero 7'b1111110
`define one 7'b0110000
`define two 7'b1101101
`define three 7'b1111001
`define four 7'b0110011
`define five 7'b1011011
`define six 7'b1011111
`define seven 7'b1110000
`define eight 7'b1111111
`define nine 7'b1111011

module sub_7seg_translate(
input [4:0] seg7,
input clk

);
wire [4:0]seg77;
assign seg77=seg7;
reg [6:0] seg_output;
always@(posedge clk)begin
case(seg7)
0: seg_output<=`zero;
1: seg_output<=`one;
2:seg_output<=`two;
3:seg_output<=`three;
4:seg_output<=`four;
5:seg_output<=`five;
6:seg_output<=`six;
7:seg_output<=`seven;
8:seg_output<=`eight;
9:seg_output<=`nine;
endcase
end


endmodule

DDS模块

DDS原理 根据 DDS 原理产生正弦信号,SW为步进

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
`timescale 1ns / 1ps
module sub_DDS_sine(
input clk,clr,
input[7:0]SW,
output wire [7 : 0] douta
);
//相位累加器
reg [7:0]Fre_acc;
always @(posedge clk or negedge clr)
if(!clr)
Fre_acc <= 9'd0;
else
Fre_acc <= Fre_acc + SW;

blk_mem_gen_0 rom_addr_douta (
.clka(clk), // input wire clka
.addra(Fre_acc), // input wire [7 : 0] addra
.douta(douta) // output wire [7 : 0] douta
);

endmodule

信号整型为方波模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
`timescale 1ns / 1ps
module clk_ut(
input clk,
input [7:0] din,//输入D/A信号
output ulk
);

reg clk_ut1=0;
assign ulk=clk_ut1;
always@(posedge clk)begin
if(din>=8'b10000000)clk_ut1<=1;
else clk_ut1<=0;
end
endmodule

频率计数模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
`timescale 1ns / 1ps
module sub_cal_freq(
input clk,clr,
input ulk,
output [31:0] fre_Hz//输出频率
);
//
reg [31:0] fre;
reg [31:0] fre_out=0;
reg [31:0] clk_count=0;
reg [31:0] ulk_count=0;
reg converse_flag=1;//等于0提示clk_count该清零
assign fre_Hz=fre_out;
reg [31:0]clk_count_pre=1;

always@(posedge clk)begin
if (!clr)
clk_count<=0;
else if (clk_count<=100000000)
clk_count<=clk_count+1;
else begin
clk_count<=0;
end
end

always@(negedge clk)begin
if(clk_count_pre>clk_count)begin
converse_flag<=0;
end
else if(!ulk_count)
converse_flag<=1;
end

always@(posedge clk)begin//基准计数及向下跳变
clk_count_pre<=clk_count;
end

//always@(negedge clk_count)begin//基准计数器向下跳变,标志位提示清零

//end


always@(posedge ulk) begin
if(!clr)
ulk_count<=0;
else if((clk_count<=99999999)&&converse_flag)
ulk_count<=ulk_count+1;
else if (!converse_flag)begin
ulk_count<=0;
end
end

//1s内待测时钟计数值
always@(posedge clk)begin
if(!clr)
fre<=0;
else if(clk_count==99999999)//每999999刷新一次
fre<=ulk_count;
else fre<=0;
end

always@(posedge clk)
if(fre)
fre_out=fre;

endmodule

BCD译码模块

Q:

为什么要进行 BCD 译码?

A:

为了知道八个七段数码管每一位都是哪个数字,需要对测量出来的频率 f 每一位进行分割,对于 f 每一位来说,都是正常的四位二进制表示,对于32位的f来说,它被转换成了 BCD 码 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
`timescale 1ns / 1ps
module sub_get_f_BCD(
input clk,
input [31:0]f
);
integer i;
wire [31:0] BCD ;//八位的十进制
reg [3:0] s7,s6,s5,s4,s3,s2,s1,s0;
always@(*)begin
s0=4'd0;
s1=4'd0;
s2=4'd0;
s3=4'd0;
s4=4'd0;
s5=4'd0;
s6=4'd0;
s7=4'd0;
for(i=31;i>=0;i=i-1)begin//移位+3
if(s0>=5) s0=s0+3;
if(s1>=5) s1=s1+3;
if(s2>=5) s2=s2+3;
if(s3>=5) s3=s3+3;
if(s4>=5) s4=s4+3;
if(s5>=5) s5=s5+3;
if(s6>=5) s6=s6+3;
if(s7>=5) s7=s7+3;
s7={s7[2:0],s6[3]};
s6={s6[2:0],s5[3]};
s5={s5[2:0],s4[3]};
s4={s4[2:0],s3[3]};
s3={s3[2:0],s2[3]};
s2={s2[2:0],s1[3]};
s1={s1[2:0],s0[3]};
s0={s0[2:0],f[i]};
end

end
assign BCD={s7,s6,s5,s4,s3,s2,s1,s0} ;


endmodule

蓝牙模块(接收)

注意传送时序(波特率限制) 注意传送逻辑(传送时是8位(8bit) 传送, 0和1之间包裹8bit 信息) 传送时是1位1位传送 cycle_4 为偏移量,0,1,2,3 循环变化,最终填满32位信息,对应四个传送周期(4*8bit) message 用来输出32位接收内容 r_start 用来判断第一个 0位(8bit 信息传送开始)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
`timescale 1ns / 1ps
module sub_bt_receiver(
input clk,
input wire rx,
output reg [31:0]message,
output reg over=0
); //clk为FPGA板载时钟(100MHz),rx为读入的串行信号,message为对应的并行信号,over的下降沿将表示读入转换完成

reg [13:0]cnt_clk=0; //需要一个量来数clk的个数,每10416个clk,对应0.104us,即波特率9600对应的1bit占用的时常
reg [4:0]cnt_message=0; //计数message的位数,表征传递进行到了第几位
reg [31:0]message_mid=0; //message的前体,在over的下降沿传递给message,避免传递没结束,message就有输出值了
reg r_start=1; //判断第一个0位,表示传递开始
reg [1:0]cycle_4=0; //偏移量倍数
wire [5:0]move;
assign move=(cycle_4*8);
reg [13:0]cnt_clk2=0;
reg r_start_pre=0;
always@(posedge clk)
begin
//判断是否为开始位,是时开始计算clk,数5208下(0.5bit)即在开始位中间,开始读数
if (rx==0&&r_start==1) begin
cnt_clk<=cnt_clk+1;
if (cnt_clk==5208&&rx==0) begin
r_start<=0;
cnt_clk<=0;
cnt_message<=0;
message_mid<=0;
end
end
//开始传送
else if (r_start==0) begin
cnt_clk<=cnt_clk+1;
if (cnt_clk==10416) begin //每10416个clk读一次,对应波特率
message_mid[cnt_message+move]<=rx;
cnt_message<=cnt_message+1;
cnt_clk<=0;
end
//读完第8位不读了
else if (cnt_message==8) begin
if(cnt_clk==100)begin
//在不读数据时传入稳定的数据,让数据更可靠,每次共8bit
message[cnt_message+move-1]<=message_mid[cnt_message+move-1];
message[cnt_message+move-2]<=message_mid[cnt_message+move-2];
message[cnt_message+move-3]<=message_mid[cnt_message+move-3];
message[cnt_message+move-4]<=message_mid[cnt_message+move-4];
message[cnt_message+move-5]<=message_mid[cnt_message+move-5];
message[cnt_message+move-6]<=message_mid[cnt_message+move-6];
message[cnt_message+move-7]<=message_mid[cnt_message+move-7];
message[cnt_message+move-8]<=message_mid[cnt_message+move-8];
end
if (cnt_clk==6000) begin //在数据位第8位的中间往右走2604个clk进入终止位(默认无奇偶校验位),在终止位中(往右走3000个clk和5000个clk之间)输出一个over信号
over<=1;

end
if (cnt_clk==10000) begin
//over下降沿,传递完成,message_mid赋值给message,所有信号还原
over<=0;
cnt_clk<=0;
cnt_message<=0;
r_start<=1;
message_mid<=0;
cycle_4<=cycle_4+1;
end
end
end
//开始读数,每5208个clk读一次
else begin
r_start<=1;
over<=0;
end
end

endmodule

DDS coe 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
MEMORY_INITIALIZATION_RADIX=10;
MEMORY_INITIALIZATION_VECTOR=
128,131,134,137,140,144,147,150,153,156,159,162,165,168,171,
174,177,179,182,185,188,191,193,196,199,201,204,206,209,211,
213,216,218,220,222,224,226,228,230,232,234,235,237,239,240,
241,243,244,245,246,248,249,250,250,251,252,253,253,254,254,
254,255,255,255,255,255,255,255,254,254,254,253,253,252,251,
250,250,249,248,246,245,244,243,241,240,239,237,235,234,232,
230,228,226,224,222,220,218,216,213,211,209,206,204,201,199,
196,193,191,188,185,182,179,177,174,171,168,165,162,159,156,
153,150,147,144,140,137,134,131,128,125,122,119,116,112,109,
106,103,100,97,94,91,88,85,82,79,77,74,71,68,65,
63,60,57,55,52,50,47,45,43,40,38,36,34,32,30,
28,26,24,22,21,19,17,16,15,13,12,11,10,8,7,
6,6,5,4,3,3,2,2,2,1,1,1,1,1,1,
1,2,2,2,3,3,4,5,6,6,7,8,10,11,12,
13,15,16,17,19,21,22,24,26,28,30,32,34,36,38,
40,43,45,47,50,52,55,57,60,63,65,68,71,74,77,
79,82,85,88,91,94,97,100,103,106,109,112,116,119,122,
125

约束文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

#输入频率
set_property -dict {PACKAGE_PIN P4 IOSTANDARD LVCMOS33} [get_ports {SW[6]}]
set_property -dict {PACKAGE_PIN P3 IOSTANDARD LVCMOS33} [get_ports {SW[5]}]
set_property -dict {PACKAGE_PIN P2 IOSTANDARD LVCMOS33} [get_ports {SW[4]}]
set_property -dict {PACKAGE_PIN R2 IOSTANDARD LVCMOS33} [get_ports {SW[3]}]
set_property -dict {PACKAGE_PIN M4 IOSTANDARD LVCMOS33} [get_ports {SW[2]}]
set_property -dict {PACKAGE_PIN N4 IOSTANDARD LVCMOS33} [get_ports {SW[1]}]
set_property -dict {PACKAGE_PIN R1 IOSTANDARD LVCMOS33} [get_ports {SW[0]}]
#模式
#set_property -dict {PACKAGE_PIN U4 IOSTANDARD LVCMOS33} [get_ports {mode[0]}]
#set_property -dict {PACKAGE_PIN V1 IOSTANDARD LVCMOS33} [get_ports {mode[1]}]
#set_property -dict {PACKAGE_PIN R15 IOSTANDARD LVCMOS33} [get_ports {mode[2]}]
#set_property -dict {PACKAGE_PIN R17 IOSTANDARD LVCMOS33} [get_ports {mode[3]}]
#set_property -dict {PACKAGE_PIN R11 IOSTANDARD LVCMOS33} [get_ports {mode[4]}]
set_property -dict {PACKAGE_PIN T3 IOSTANDARD LVCMOS33} [get_ports {mode[1]}]
set_property -dict {PACKAGE_PIN T5 IOSTANDARD LVCMOS33} [get_ports {mode[0]}]
#数码管
set_property -dict {PACKAGE_PIN B4 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[6]}]
set_property -dict {PACKAGE_PIN A4 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[5]}]
set_property -dict {PACKAGE_PIN A3 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[4]}]
set_property -dict {PACKAGE_PIN B1 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[3]}]
set_property -dict {PACKAGE_PIN A1 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[2]}]
set_property -dict {PACKAGE_PIN B3 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[1]}]
set_property -dict {PACKAGE_PIN B2 IOSTANDARD LVCMOS33} [get_ports {a_to_g1[0]}]

set_property -dict {PACKAGE_PIN D5 IOSTANDARD LVCMOS33} [get_ports point4]
set_property -dict {PACKAGE_PIN H2 IOSTANDARD LVCMOS33} [get_ports point5]

set_property -dict {PACKAGE_PIN D4 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[6]}]
set_property -dict {PACKAGE_PIN E3 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[5]}]
set_property -dict {PACKAGE_PIN D3 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[4]}]
set_property -dict {PACKAGE_PIN F4 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[3]}]
set_property -dict {PACKAGE_PIN F3 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[2]}]
set_property -dict {PACKAGE_PIN E2 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[1]}]
set_property -dict {PACKAGE_PIN D2 IOSTANDARD LVCMOS33} [get_ports {a_to_g0[0]}]

#清零
set_property -dict {PACKAGE_PIN P15 IOSTANDARD LVCMOS33} [get_ports clr]
#时钟
set_property -dict {PACKAGE_PIN P17 IOSTANDARD LVCMOS33} [get_ports clk]




set_property IOSTANDARD LVCMOS33 [get_ports {position[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[6]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {position[0]}]
set_property PACKAGE_PIN G2 [get_ports {position[7]}]
set_property PACKAGE_PIN C2 [get_ports {position[6]}]
set_property PACKAGE_PIN C1 [get_ports {position[5]}]
set_property PACKAGE_PIN G1 [get_ports {position[3]}]
set_property PACKAGE_PIN F1 [get_ports {position[2]}]
set_property PACKAGE_PIN E1 [get_ports {position[1]}]
set_property PACKAGE_PIN G6 [get_ports {position[0]}]
set_property PACKAGE_PIN H1 [get_ports {position[4]}]


set_property PACKAGE_PIN P5 [get_ports {SW[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {SW[7]}]

set_property PACKAGE_PIN B11 [get_ports {D[0]}]
set_property PACKAGE_PIN C14 [get_ports {D[1]}]
set_property PACKAGE_PIN B14 [get_ports {D[3]}]
set_property PACKAGE_PIN B13 [get_ports {D[4]}]
set_property PACKAGE_PIN F14 [get_ports {D[5]}]
set_property PACKAGE_PIN D14 [get_ports {D[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[6]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {douta[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {D[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports aclk]
set_property PACKAGE_PIN B17 [get_ports {douta[7]}]
set_property PACKAGE_PIN A15 [get_ports {douta[6]}]
set_property PACKAGE_PIN A16 [get_ports {douta[5]}]
set_property PACKAGE_PIN A13 [get_ports {douta[4]}]
set_property PACKAGE_PIN A14 [get_ports {douta[3]}]
set_property PACKAGE_PIN B18 [get_ports {douta[2]}]
set_property PACKAGE_PIN A18 [get_ports {douta[1]}]
set_property PACKAGE_PIN F13 [get_ports {douta[0]}]
set_property PACKAGE_PIN B16 [get_ports aclk]

set_property PACKAGE_PIN R3 [get_ports {mode[2]}]
set_property PACKAGE_PIN H16 [get_ports {din[7]}]
set_property PACKAGE_PIN F16 [get_ports {din[6]}]
set_property PACKAGE_PIN F15 [get_ports {din[5]}]
set_property PACKAGE_PIN G14 [get_ports {din[4]}]
set_property PACKAGE_PIN D17 [get_ports {din[3]}]
set_property PACKAGE_PIN E17 [get_ports {din[2]}]
set_property PACKAGE_PIN J3 [get_ports {din[1]}]
set_property PACKAGE_PIN K13 [get_ports {din[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[6]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {din[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {mode[2]}]