OFDM学习-（二）长短序列和PPDU团体数据处置惩罚流程

OFDM学习


  

---

媒介

根据框图可以知道发射机这部门信号在DA转换之前，数据是两路，分别是实部和虚部8位信号。通过DA转换也是两路模拟信号，通过IQ调制搞到射频。
PPDU包罗3部门数据，长短序列是不须要举行ofdm操作的，signal和data的信号须要举行ofdm操作，也就是下面图中扰码、卷积编码、交错等等的操作，最后通过ifft和cp加窗后举行输出，最后将实部信号与虚部信号与训练序列的实部和虚部按照位置分别发送。

一、短序列

子载波有效数量是52个，短序列只用到了其中的12个子载波，每个载波之间的隔断为4，位置序号是：
{-24，-20，-16，-12，-8，-4, 4,8，12,16,20,24}，直流分量不能使用。又因为短序列采用的是BPSK模式，因此可以通过载波位置以及调制方式决定他的数据格式。确定[9:0] STS_IM[8] 和[9:0] STS_RE[8]，就实现了短序列的产生，按照位置依次将实部序列和虚部序列信号发送即可。
因此短序列在频域上就是
% STS频域表现
S=[0,0,0,0,0,0,0,0,1+i,0,0,0,-1-i,0,0,0,1+i,0,0,0,-1-i,0,0,0,-1-i,0,0,0,1+i,0,0,0,0,0,0,0,-1-i,0,0,0,-1-i,0,0,0,1+i,0,0,0,1+i,0,0,0,1+i,0,0,0,1+i,0,0,0,0,0,0,0];
但是最终须要发出去的是时域信号，以是这个频域信号理论上是要经过ifft模块处置惩罚之后发送出去，但是因为短序列都是固定的数值，因此时序信号的实部和虚部也是固定的，以是短训练序列的产生也就是通过MATLAB将频域转换为时域后，将固定的时域信号的实部值和虚部值直接使用。短训练序列的数据格式，1位符号位，1位整数位，6位小数位。
从时域上看，每一个短序列是16个采样点，也就是总共10*16=160点。
短序列的作用

吸收机举行分组检测、同步等
二、长序列

类似短序列，根本原理相同，各自作用不同。
三、PLCP/SIGNAL/DATA数据处置惩罚流程

训练序列直接按照时域产生实部信号和虚部信号，不须要举行ofdm调制。
SIGNAL信号和DATA信号须要从单比特流数据经过扰码、卷积编码、交错、符号调制、16QAM调制、导频插入、IFFT模块、CP加窗等步调最后与训练序列组合发送到DAC举行射频端的处置惩罚。
三、fpga实现

STS模块

1. `timescale 1ns / 1ps
2. ///
3. // Company:                                                                     
4. // Engineer: YWang                                                                    
5. //                                                                                   
6. // Create Date: 2023-03-10  14:53:45
7. // Design Name:                                                                    
8. // Module Name: STS_generator.v                                                         
9. // Project Name:                                                                  
10. // Target Devices:                                                                  
11. // Tool versions:                                                                  
12. // Description:                                                                  
13. //                                                                                 
14. // Dependencies: 0                                                                  
15. //                                                                                 
16. // Revision:                                                                    
17. // Revision 0.01 - File Created                                                     
18. // Additional Comments:                                                        
19. //                                                                                   
20. ///
21. module   STS_generator(  
22.     input                   clk         ,   
23.     input                   rst_n       ,   
24.     input                   Tx_Clr      ,   
25.     input                   Start_En    ,
27.     output reg [7:0]        STS_Im      ,
28.     output reg [7:0]        STS_Re      ,
29.     output reg              STS_Vld     ,
30.     output reg [7:0]        STS_Index   ,
31.     output reg              STS_Done            
32. );                 
34.     reg  [15:0] Short_Mem [15:0];
35.     reg  [3:0]  i,j;
36.     wire        STS_Req;
38.     assign STS_Req = Start_En || (STS_Index>0);
40.     always @(posedge clk or negedge rst_n) begin
41.         if(~rst_n) begin  
42.             Short_Mem[0]  <= {8'b00001100,8'b00001100};
43.             Short_Mem[1]  <= {8'b11011110,8'b00000001};
44.             Short_Mem[2]  <= {8'b11111101,8'b11101100};
45.             Short_Mem[3]  <= {8'b00100100,8'b11111101};
46.             Short_Mem[4]  <= {8'b00011000,8'b00000000};
47.             Short_Mem[5]  <= {8'b00100100,8'b11111101};
48.             Short_Mem[6]  <= {8'b11111101,8'b11101100};
49.             Short_Mem[7]  <= {8'b11011110,8'b00000001};
50.             Short_Mem[8]  <= {8'b00001100,8'b00001100};
51.             Short_Mem[9]  <= {8'b00000001,8'b11011110};
52.             Short_Mem[10] <= {8'b11101100,8'b11111101};
53.             Short_Mem[11] <= {8'b11111101,8'b00100100};
54.             Short_Mem[12] <= {8'b00000000,8'b00011000};
55.             Short_Mem[13] <= {8'b11111101,8'b00100100};
56.             Short_Mem[14] <= {8'b11101100,8'b11111101};
57.             Short_Mem[15] <= {8'b00000001,8'b11011110};
59.             STS_Vld <= 0;
60.             STS_Index <=  0;
61.             STS_Done <= 0;
62.             STS_Re <= 0;
63.             STS_Im <= 0;
64.             i <= 0;
65.             j <= 0;
66.            end  
67.         else if( Tx_Clr  ) begin
68.             i <= 0;
69.             j <= 0;
70.             STS_Vld <= 0;
71.             STS_Index <= 0;
72.             STS_Done <= 0;
73.         end
74.         else if( STS_Req && (STS_Index<161) ) begin
75.             STS_Index <= STS_Index + 1;
76.             STS_Vld <=  1'b1;
77.             if(i<10)    begin
78.                 if(j==15) begin
79.                     j <= 0;
80.                     i <= i+ 1;
81.                     STS_Re <= Short_Mem[j][15:8];  
82.                     STS_Im <= Short_Mem[j][7:0];
83.                 end
84.                 else  begin
85.                     if(i==0 && j==0) begin
86.                         STS_Re <= Short_Mem[j][15:8]>>1; //鍔犵獥锛屽乏绉讳竴
87.                         STS_Im <= Short_Mem[j][7:0]>>1;//娉ㄦ剰锛歋hort_Mem銆�0銆戜负姝ｆ暟
88.                     end
89.                     else begin
90.                         STS_Re <= Short_Mem[j][15:8];  
91.                         STS_Im <= Short_Mem[j][7:0];
92.                     end
93.                     j <= j + 1;
94.                 end
95.             end
96.             else begin  //鏈�鍚庝竴浣�
97.                 STS_Re <= Short_Mem[0][15:8]>>1; //鍔犵獥锛屽乏绉讳竴  绗竴涓��
98.                 STS_Im <= Short_Mem[0][7:0]>>1;
99.                 STS_Done <= 1'b1;
100.             end
101.         end
102.         else begin
103.             STS_Vld <= 1'b0;
104.         end
105.     end
108.                   
109. endmodule         

复制代码

LTS模块

1. `timescale 1ns / 1ps
2. ///
3. // Company:                                                                     
4. // Engineer: YWang                                                                    
5. //                                                                                   
6. // Create Date: 2023-03-10  14:53:45
7. // Design Name:                                                                    
8. // Module Name: LTS_generator.v                                                         
9. // Project Name:                                                                  
10. // Target Devices:                                                                  
11. // Tool versions:                                                                  
12. // Description:                                                                  
13. //                                                                                 
14. // Dependencies: 0                                                                  
15. //                                                                                 
16. // Revision:                                                                    
17. // Revision 0.01 - File Created                                                     
18. // Additional Comments:                                                        
19. //                                                                                   
20. ///
21. module   LTS_generator(  
22.     input                   clk         ,   
23.     input                   rst_n       ,   
24.     input                   Tx_Clr      ,   
25.     input                   Start_En    ,
27.     output reg [7:0]        LTS_Im      ,
28.     output reg [7:0]        LTS_Re      ,
29.     output reg              LTS_Vld     ,
30.     output reg [7:0]        LTS_Index   ,
31.     output reg              LTS_Done            
32. );                 
34.     reg  [15:0] Long_Mem [63:0];
35.     reg  [6:0]  i,j;
36.     wire        LTS_Req;
38.     assign LTS_Req = Start_En || (LTS_Index>0);
40.     always @(posedge clk or negedge rst_n) begin
41.         if(~rst_n) begin  //鏃跺煙鏍峰�� Re      Im
42.             Long_Mem[0]  <= {8'b00101000 , 8'b00000000};
43.                 Long_Mem[1]  <= {8'b11111111 , 8'b11100001};
44.                 Long_Mem[2]  <= {8'b00001010 , 8'b11100100};
45.                 Long_Mem[3]  <= {8'b00011001 , 8'b00010101};
46.                 Long_Mem[4]  <= {8'b00000101 , 8'b00000111};
47.                 Long_Mem[5]  <= {8'b00001111 , 8'b11101010};
48.                 Long_Mem[6]  <= {8'b11100011 , 8'b11110010};
49.                 Long_Mem[7]  <= {8'b11110110 , 8'b11100101};
50.                 Long_Mem[8]  <= {8'b00011001 , 8'b11111001};
51.                 Long_Mem[9]  <= {8'b00001110 , 8'b00000001};
52.                 Long_Mem[10] <= {8'b00000000 , 8'b11100011};
53.                 Long_Mem[11] <= {8'b11011101 , 8'b11110100};
54.                 Long_Mem[12] <= {8'b00000110 , 8'b11110001};
55.                 Long_Mem[13] <= {8'b00001111 , 8'b11111100};
56.                 Long_Mem[14] <= {8'b11111010 , 8'b00101001};
57.                 Long_Mem[15] <= {8'b00011111 , 8'b11111111};
58.                 Long_Mem[16] <= {8'b00010000 , 8'b11110000};
59.                 Long_Mem[17] <= {8'b00001001 , 8'b00011001};
60.                 Long_Mem[18] <= {8'b11110001 , 8'b00001010};
61.                 Long_Mem[19] <= {8'b11011110 , 8'b00010001};
62.                 Long_Mem[20] <= {8'b00010101 , 8'b00011000};
63.                 Long_Mem[21] <= {8'b00010010 , 8'b00000100};
64.                 Long_Mem[22] <= {8'b11110001 , 8'b00010101};
65.                 Long_Mem[23] <= {8'b11110010 , 8'b11111010};
66.                 Long_Mem[24] <= {8'b11110111 , 8'b11011001};
67.                 Long_Mem[25] <= {8'b11100001 , 8'b11111100};
68.                 Long_Mem[26] <= {8'b11011111 , 8'b11111011};
69.                 Long_Mem[27] <= {8'b00010011 , 8'b11101101};
70.                 Long_Mem[28] <= {8'b11111111 , 8'b00001110};
71.                 Long_Mem[29] <= {8'b11101000 , 8'b00011101};
72.                 Long_Mem[30] <= {8'b00010111 , 8'b00011011};
73.                 Long_Mem[31] <= {8'b00000011 , 8'b00011001};
74.                 Long_Mem[32] <= {8'b11011000 , 8'b00000000};
75.                 Long_Mem[33] <= {8'b00000011 , 8'b11100111};
76.                 Long_Mem[34] <= {8'b00010111 , 8'b11100101};
77.                 Long_Mem[35] <= {8'b11101000 , 8'b11100011};
78.                 Long_Mem[36] <= {8'b11111111 , 8'b11110010};
79.                 Long_Mem[37] <= {8'b00010011 , 8'b00010011};
80.                 Long_Mem[38] <= {8'b11011111 , 8'b00000101};
81.                 Long_Mem[39] <= {8'b11100001 , 8'b00000100};
82.                 Long_Mem[40] <= {8'b11110111 , 8'b00100111};
83.                 Long_Mem[41] <= {8'b11110010 , 8'b00000110};
84.                 Long_Mem[42] <= {8'b11110001 , 8'b11101011};
85.                 Long_Mem[43] <= {8'b00010010 , 8'b11111100};
86.                 Long_Mem[44] <= {8'b00010101 , 8'b11101000};
87.                 Long_Mem[45] <= {8'b11011110 , 8'b11101111};
88.                 Long_Mem[46] <= {8'b11110001 , 8'b11110110};
89.                 Long_Mem[47] <= {8'b00001001 , 8'b11100111};
90.                 Long_Mem[48] <= {8'b00010000 , 8'b00010000};
91.                 Long_Mem[49] <= {8'b00011111 , 8'b00000001};
92.                 Long_Mem[50] <= {8'b11111010 , 8'b11010111};
93.                 Long_Mem[51] <= {8'b00001111 , 8'b00000100};
94.                 Long_Mem[52] <= {8'b00000110 , 8'b00001111};
95.                 Long_Mem[53] <= {8'b11011101 , 8'b00001100};
96.                 Long_Mem[54] <= {8'b00000000 , 8'b00011101};
97.                 Long_Mem[55] <= {8'b00001110 , 8'b11111111};
98.                 Long_Mem[56] <= {8'b00011001 , 8'b00000111};
99.                 Long_Mem[57] <= {8'b11110110 , 8'b00011011};
100.                 Long_Mem[58] <= {8'b11100011 , 8'b00001110};
101.                 Long_Mem[59] <= {8'b00001111 , 8'b00010110};
102.                 Long_Mem[60] <= {8'b00000101 , 8'b11111001};
103.                 Long_Mem[61] <= {8'b00011001 , 8'b11101011};
104.                 Long_Mem[62] <= {8'b00001010 , 8'b00011100};
105.                 Long_Mem[63] <= {8'b11111111 , 8'b00011111};
107.             LTS_Vld <= 0;
108.             LTS_Index <=  0;
109.             LTS_Done <= 0;
110.             LTS_Re <= 0;
111.             LTS_Im <= 0;
112.             i <= 0;
113.             j <= 0;
114.            end  
115.         else if( Tx_Clr  ) begin
116.             i <= 0;
117.             j <= 0;
118.             LTS_Vld <= 0;
119.             LTS_Index <= 0;
120.             LTS_Done <= 0;
121.         end
122.         else if( LTS_Req && (LTS_Index<161) ) begin
123.             LTS_Index <= LTS_Index + 1;
124.             LTS_Vld <=  1'b1;
125.             if(i==0)    begin
126.                 if(j==31) begin
127.                     j <= 0;
128.                     i <= i+ 1;
129.                     LTS_Re <= Long_Mem[j+32][15:8];  
130.                     LTS_Im <= Long_Mem[j+32][7:0];
131.                 end
132.                 else  begin
133.                     if(i==0 && j==0) begin
134.                         LTS_Re <= 8'b11101100; //鐭缁冨簭鍒楀埌闀胯缁冨簭鍒楃殑绐楀彛鍑芥暟
135.                         LTS_Im <= Long_Mem[j+32][7:0];
136.                     end
137.                     else begin
138.                         LTS_Re <= Long_Mem[j+32][15:8];  
139.                         LTS_Im <= Long_Mem[j+32][7:0];
140.                     end
141.                     j <= j + 1;
142.                 end
143.             end
144.             else if( i==1 || i==2 )    begin
145.                 if(j==63) begin
146.                     j <= 0;
147.                     i <= i+ 1;
148.                     LTS_Re <= Long_Mem[j][15:8];  
149.                     LTS_Im <= Long_Mem[j][7:0];
150.                 end
151.                 else  begin
152.                     LTS_Re <= Long_Mem[j][15:8];  
153.                     LTS_Im <= Long_Mem[j][7:0];
154.                     j <= j + 1;
155.                 end
156.             end
157.             else begin  //  鍔犵獥澶勭悊
158.                 LTS_Re <= Long_Mem[0][15:8]>>1; //鍔犵獥锛屽乏绉讳竴浣�  
159.                 LTS_Im <= Long_Mem[0][7:0]>>1;
160.                 LTS_Done <= 1'b1;
161.             end
162.         end
163.         else begin
164.             LTS_Vld <= 1'b0;
165.         end
166.     end
169.                   
170. endmodule         

复制代码

训练序列模块

1. `timescale 1ns / 1ps
2. ///
3. // Company:                                                                     
4. // Engineer: YWang                                                                    
5. //                                                                                   
6. // Create Date: 2023-03-10  14:22:41
7. // Design Name:                                                                    
8. // Module Name: symbol_train.v                                                         
9. // Project Name:                                                                  
10. // Target Devices:                                                                  
11. // Tool versions:                                                                  
12. // Description:                                                                  
13. //                                                                                 
14. // Dependencies: 0                                                                  
15. //                                                                                 
16. // Revision:                                                                    
17. // Revision 0.01 - File Created                                                     
18. // Additional Comments:????????????????                                                     
19. //                                                                                   
20. ///
21. module   symbol_train(  
22.     input               clk         ,   
23.     input               rst_n       ,   
24.     input               Tx_Clr      ,   
25.     input               Start_En    ,
27.     output  [7:0]       Train_Im    ,
28.     output  [7:0]       Train_Re    ,
29.     output              Train_Vld   ,
30.     output  [8:0]       Train_Index ,
31.     output              Train_Done           
32. );              
34.     wire                STS_Start_En;
35.     wire    [7:0]       STS_Im      ;
36.     wire    [7:0]       STS_Re      ;
37.     wire                STS_Vld     ;
38.     wire    [7:0]       STS_Index   ;
39.     wire                STS_Done    ;
41.     wire                LTS_Start_En;
42.     wire    [7:0]       LTS_Im      ;
43.     wire    [7:0]       LTS_Re      ;
44.     wire                LTS_Vld     ;      
45.     wire    [7:0]       LTS_Index   ;
46.     wire                LTS_Done    ;
48.     STS_generator  u_STS
49.     (
50.         .clk                (clk            ),
51.         .rst_n              (rst_n          ),
52.         .Tx_Clr             (Tx_Clr         ),
53.         .Start_En           (STS_Start_En   ),
54.         .STS_Im             (STS_Im         ),
55.         .STS_Re             (STS_Re         ),
56.         .STS_Vld            (STS_Vld        ),
57.         .STS_Index          (STS_Index      ),
58.         .STS_Done           (STS_Done       )
60.     );
63.     LTS_generator  u_LTS
64.     (
65.         .clk                (clk            ),
66.         .rst_n              (rst_n          ),
67.         .Tx_Clr             (Tx_Clr         ),
68.         .Start_En           (LTS_Start_En   ),
69.         .LTS_Im             (LTS_Im         ),
70.         .LTS_Re             (LTS_Re         ),
71.         .LTS_Vld            (LTS_Vld        ),
72.         .LTS_Index          (LTS_Index      ),
73.         .LTS_Done           (LTS_Done       )
75.     );
79.     assign Train_Im = STS_Vld ? STS_Im : LTS_Vld ? LTS_Im : 8'b0 ;
80.     assign Train_Re = STS_Vld ? STS_Re : LTS_Vld ? LTS_Re : 8'b0 ;
81.     assign Train_Vld = STS_Vld ? 1'b1 : LTS_Vld ? 1'b1 : 1'b0;
82.     assign Train_Index = STS_Index + LTS_Index;
83.     assign Train_Done = LTS_Done;
85.     assign STS_Start_En = Start_En;
86.     assign LTS_Start_En = STS_Done;
88.                   
89. endmodule         

复制代码

仿真波形

总结

训练序列的产生要明确：
频域上用了12个子载波，隔断为4，BPSK符号格式，功率因数1.4几来着？。
频域固定，因此时域实部和虚部也是固定，通过MATLAB就可以直接得到时域的训练序列的实部和虚部的数值，因此直接在步伐中写死循环即可。
数据格式：1位符号，1位整数，6位小数
代码参考：基于FPGA的OFDM基带发射机的计划与实现
训练模块代码未做修改。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。