• FOC：【2】SVPWM（七段式）的Verilog实现与仿真

    经过近一周的调试与查错（不好意思我实在太菜了），才终于从MATLAB代码的基础上，实现了Verilog对SVPWM算法的实现，同时给出仿真的结果。

    目录

    1 主要思路

    2 模块代码

    2.1 my_SVPWM 模块

    2.2 Jud_sec 模块

    2.3 Cal_time 模块

    2.4 Switch_time 模块

    2.5 Tri_gener 模块

    2.6 测试模块

    3 仿真结果

    3.1 MATLAB计算结果

    3.2 Quartus仿真结果

    1 主要思路

    思路与上一篇文章基本一致，但是针对Verilog中的部分特点（包括精度以及时序），本文给出各个模块的代码，以及Modelsim的仿真结果。

    读者可以自行和上一篇文章进行对比：FOC：【1】浅析SVPWM算法（七段式）以及MATLAB仿真验证

    2 模块代码

    2.1 my_SVPWM 模块

    用来实现SVPWM,输入是Park 逆变换后的Vα与Vβ,输出是三个桥臂的控制信号。

    1.  
    2. // SVPWM模块
    3. // Type    : synthesizable
    4. // Standard: SystemVerilog 2005 (IEEE1800-2005)
    5. // 功能： 用来实现SVPWM,输入是Park 逆变换后的Vα与Vβ,输出是三个桥臂的控制信号
    6. // 包含四个部分:
    7. 			// 01 扇区判断  
    8. 			// 02 矢量作用时间计算
    9. 			// 03 逆变器开关切换时间计算
    10. 			// 04 利用三角波改变开关状态
    11.  
    12.  
    13. // module my_SVPWM(
    14. // 	input  wire               clk,         //时钟信号
    15. // 	input  wire               rstn,        //复位信号
    16. // 	input  wire               in_en,       //系统的输入使能信号
    17. // 	input  wire signed [15:0] Valpha,      //Park逆变换的结果Vα
    18. // 	input  wire signed [15:0] Vbeta,       //Park逆变换的结果Vβ
    19. // 	output wire               pwm_a,       //SVPWM的输出1 PWM_a
    20. // 	output wire               pwm_b,       //SVPWM的输出2 PWM_b
    21. // 	output wire               pwm_c        //SVPWM的输出3 PWM_c
    22. // );
    23.  
    24. //下面的是调试版本，用来观察中间变量
    25. module my_SVPWM(
    26. 	input  wire               clk,         //时钟信号
    27. 	input  wire               rstn,        //复位信号
    28. 	input  wire               in_en,       //系统的输入使能信号
    29. 	input  wire signed [15:0] Valpha,      //Park逆变换的结果Vα
    30. 	input  wire signed [15:0] Vbeta,       //Park逆变换的结果Vβ
    31. 	output wire               pwm_a,       //SVPWM的输出1 PWM_a
    32. 	output wire               pwm_b,       //SVPWM的输出2 PWM_b
    33. 	output wire               pwm_c,       //SVPWM的输出3 PWM_c
    34. 	output wire        [3:0]  n,
    35. 	output wire        [3:0]  sector,
    36. 	output wire               Jug_sec_in_en,
    37. 	output wire signed [16:0] x,
    38. 	output wire signed [16:0] y,
    39. 	output wire signed [16:0] z,
    40. 	output wire               Jug_sec_out_en,
    41. 	output wire signed [16:0] Tfirst,
    42. 	output wire signed [16:0] Tsecond,
    43. 	output wire signed [16:0] Tzero,
    44. 	output wire               Cal_time_out_en,
    45. 	output wire signed [16:0] Tcm1,
    46. 	output wire signed [16:0] Tcm2,
    47. 	output wire signed [16:0] Tcm3,
    48. 	output wire               Switch_time_out_en,
    49. 	output wire signed [11:0] Ts_cnt,
    50. 	output wire               Tri_gener_out_en
    51. );
    52.  
    53.  
    54. // SVPWM的实例化过程------------------------------------------------------------------------------------------------------------
    55. // 00 实例化需要使用到的导线
    56. // wire        [3:0]  n;
    57. // wire        [3:0]  sector;
    58. // wire               Jug_sec_in_en;
    59. // wire signed [16:0] x;
    60. // wire signed [16:0] y;
    61. // wire signed [16:0] z;
    62. // wire               Jug_sec_out_en;
    63. // wire signed [16:0] Tfirst;
    64. // wire signed [16:0] Tsecond;
    65. // wire signed [16:0] Tzero;
    66. // wire               Cal_time_out_en;
    67. // wire signed [16:0] Tcm1;
    68. // wire signed [16:0] Tcm2;
    69. // wire signed [16:0] Tcm3;
    70. // wire               Switch_time_out_en;
    71. // wire signed [11:0] Ts_cnt;
    72. // wire               Tri_gener_out_en;
    73.  
    74.  
    75.  
    76. // 01 扇区判断--------------------------------------------------------------------------------------------------------------------------------------------------
    77. // 功能：利用当前的Valpha与Vbeta判断所在的扇区
    78. // 输入：Valpha Vbeta
    79. // 输出：扇区数字sector,以及相关参数N
    80.  
    81. assign Jug_sec_in_en = Tri_gener_out_en || in_en;
    82.  
    83. Jug_sec Jug_sec(
    84. 	.clk         ( clk                ),           //时钟信号
    85. 	.rstn        ( rstn               ),           //复位信号
    86. 	.in_en       ( Jug_sec_in_en      ),           //输入有效信号
    87. 	.Valpha      ( Valpha             ),           //Park逆变换的结果Vα (是有符号数,-32768~32767)
    88. 	.Vbeta       ( Vbeta              ),           //Park逆变换的结果Vβ (是有符号数,-32768~32767)
    89. 	.n           ( n                  ),           //扇区计算中常用的N
    90. 	.sector      ( sector             ),           //扇区的结果
    91. 	.x           ( x                  ),           //就是X
    92. 	.y           ( y                  ),           //就是Y
    93. 	.z           ( z                  ),           //就是Z
    94. 	.out_en      ( Jug_sec_out_en     )            //输出使能信号
    96. );
    97.  
    98.  
    99.  
    100. // 02 矢量作用时间计算--------------------------------------------------------------------------------------------------------------------------------------------------
    101. // 功能：矢量作用时间计算
    102. // 输入： X,Y,Z三个变量以及N
    103. // 输出： 根据N判断出的时间长度
    104.  
    105. Cal_time Cal_time(
    106. 	.clk         ( clk                ),           //时钟信号
    107. 	.rstn        ( rstn               ),           //复位信号
    108. 	.in_en       ( Jug_sec_out_en     ),           //输入使能信号
    109. 	.x           ( x                  ),
    110. 	.y           ( y                  ),
    111. 	.z           ( z                  ),
    112. 	.n           ( n                  ),
    113. 	.Tfirst      ( Tfirst             ),
    114. 	.Tsecond     ( Tsecond            ),
    115. 	.Tzero       ( Tzero              ),
    116.     .out_en      (                    ),           //输出使能信号
    117. 	.out_en2     (                    ),
    118. 	.out_en3     ( Cal_time_out_en    )
    119. );
    120.  
    121.  
    122.  
    123.  
    124. // 03 计算逆变器开关切换的时间--------------------------------------------------------------------------------------------------------------------------------------------------
    125. // 功能：利用查表的方式,计算三个相开关切换的时间
    126. // 输入：
    127. // 输出：
    128.  
    129. Switch_time Switch_time(
    130. 	.clk         ( clk                ),           //时钟信号
    131. 	.rstn        ( rstn               ),           //复位信号
    132. 	.in_en       ( Cal_time_out_en    ),           //输入使能信号
    133. 	.n           ( n                  ),
    134. 	.Tfirst      ( Tfirst             ),
    135. 	.Tsecond     ( Tsecond            ),
    136. 	.Tzero       ( Tzero              ),
    137. 	.Tcm1        ( Tcm1               ),           //三个逆变器的切换时间
    138. 	.Tcm2        ( Tcm2               ),
    139. 	.Tcm3        ( Tcm3               ),
    140. 	.out_en      (                    ),           //输出使能信号 
    141. 	.out_en2     ( Switch_time_out_en )
    142. );
    143.  
    144.  
    145.  
    146. // 04 产生三角波--------------------------------------------------------------------------------------------------------------------------------------------------
    147. // 功能：绘制三角波
    148. // 输入：
    149. // 输出：
    150.  
    151. Tri_gener Tri_gener(
    152.     .clk         ( clk                ),           //输入时钟
    153.     .rst         ( rstn               ),           //复位信号
    154.     .in_en       ( Switch_time_out_en ),           //输入使能信号
    155.     .Ts_cnt      ( Ts_cnt             ),           //Ts的计数器,用来产生一个周期为Ts=2*Tp的三角波
    156.     .deta_clk    ( Tri_gener_out_en   )            //每次输出一个时钟，就给一个高电平
    157. );
    158.  
    159.  
    160. // 05 结合三角波,产生SVPWM结果
    161. // 功能:结合三角波,产生SVPWM的结果
    162. // 输入: 计算出来的输出波形切换时间Tcm1，Tcm2，Tcm3，以及当前的
    163. // 输出: 
    164.  
    165. reg signed [11:0] Tcm1_reg;
    166. reg signed [11:0] Tcm2_reg;
    167. reg signed [11:0] Tcm3_reg;
    168.  
    169. always @(posedge clk)
    170. begin
    171. 	if(~rstn)
    172. 	begin
    173. 		Tcm1_reg <= 12'd3000;
    174. 		Tcm2_reg <= 12'd3000;
    175. 		Tcm3_reg <= 12'd3000;
    176. 	end
    177. 	else
    178. 	begin
    179. 		if(Switch_time_out_en)
    180. 		begin
    181. 			Tcm1_reg <= Tcm1;
    182. 			Tcm2_reg <= Tcm2;
    183. 			Tcm3_reg <= Tcm3;
    184. 		end
    185. 	end
    186. end
    187.  
    188. assign pwm_a = (Ts_cnt >=  Tcm1_reg) ? 1:0;
    189. assign pwm_b = (Ts_cnt >=  Tcm2_reg) ? 1:0;
    190. assign pwm_c = (Ts_cnt >=  Tcm3_reg) ? 1:0;
    191.  
    192.  
    193. endmodule

    2.2 Jud_sec 模块

    用来实现输入是Park 逆变换后的Vα与Vβ,输出扇区的值。

    这里需要注意的细节是，n的计算需要参考三个表达式，但是实际上只需要利用到表达式的具体符号，而不是数值。因此可以通过成乘法，来放大其中的小数部分，从而获得更加准确的正负符号判断。

    相应的，对于XYZ的计算，由于是需要具体数值的，并且对精度要求较高。怎么实现浮点数的运算呢？比较好的方法是先实现所有的乘法，在进行所有的除法，这样可以获得比较好的浮点数精度。

    1.  
    2. // 用来实现扇区的判断
    3. // Type    : synthesizable
    4. // Standard: SystemVerilog 2005 (IEEE1800-2005)
    5. // 功能： 用来实现输入是Park 逆变换后的Vα与Vβ,输出扇区的值
    6.  
    7. module Jug_sec(
    8. 	input  wire                clk,         //时钟信号
    9. 	input  wire                rstn,        //复位信号
    10. 	input  wire                in_en,       //输入有效信号
    11. 	input  wire signed [15:0]  Valpha,      //Park逆变换的结果Vα (是有符号数,-32768~32767)
    12. 	input  wire signed [15:0]  Vbeta,       //Park逆变换的结果Vβ (是有符号数,-32768~32767)
    13. 	output reg         [3:0]   n,           //扇区计算中常用的N
    14. 	output reg         [3:0]   sector,      //扇区的结果
    15. 	output reg  signed [16:0]  x,           //就是X
    16. 	output reg  signed [16:0]  y,           //就是Y
    17. 	output reg  signed [16:0]  z,           //就是Z
    18. 	output reg                 out_en
    19.  
    20. );
    21.  
    22.  
    23. //reg [16:0] Vref1; // 不需要定义,就是 Vbeta本身
    24. reg signed [16:0] Vref1;
    25. reg signed [16:0] Vref2;
    26. reg signed [16:0] Vref3;
    27. reg en_flag;
    28. reg flag2;
    29. //reg [16:0] y;
    30. //reg [16:0] z;
    31.  
    32. wire signed [31:0] alphasqrt3;
    33. parameter  Ts = 2048;
    34. parameter  sqrt3Ts = 3547;
    35. parameter  Vdc = 10;
    36. //parameter  temp = sqrt3Ts/Vdc;
    37.  
    38.  
    39.  
    40. always@(posedge clk)
    41. begin
    42. 	if(en_flag)
    43. 	begin
    44. 		out_en <= 1'd1;
    45. 	end
    46.  
    47. 	else
    48. 	begin
    49. 		out_en <= 1'd0;
    50. 	end
    51.  
    52.  
    53. end
    54.  
    55.  
    56.  
    57.  
    58. always @(posedge clk)
    59. begin
    60. 	if(~rstn) 
    61. 	begin
    62.  
    63. 	end
    64. 	else
    65. 	begin
    66.  
    67. 	end
    68. end
    69.  
    70. always @(*)
    71. begin
    72. 	if(~rstn) 
    73. 	begin
    74. 		n      <= 4'b0000;
    75. 	end
    76. 	else
    77. 	begin
    78.  		n[2:0]<= {~Vref3[16], ~Vref2[16], ~Vbeta[15]};		
    79. 	end
    80. end
    81.  
    82.  
    83. always@(*)
    84. if(~rstn)
    85. begin
    86. 		Vref1  <= 17'd0;
    87. 		Vref2  <= 17'd0;
    88. 		Vref3  <= 17'd0;
    89. 		x      <= 17'd0;
    90. 		y      <= 17'd0;
    91. 		z      <= 17'd0;
    92. 		sector <= 4'b0000;
    93. 		en_flag<= 1'd0;
    94. 		flag2  <= 1'd0;
    95. end
    96.  
    97. else
    98. begin
    99. 		if(flag2)
    100. 		begin
    101. 			flag2  <= 1'd0;
    102. 	 		case(n)  //通过符号来判断
    103. 	 		
    104. 	 		4'd3: //3
    105. 	 		begin
    106. 	 			sector <= 4'd1;
    107. 	 			en_flag<= 1'd1;
    108. 	 		end
    109.  
    110. 	 		4'd1:
    111. 	 		begin
    112. 	 			sector <= 4'd2;
    113. 	 			en_flag<= 1'd1;
    114. 	 		end
    115.  
    116. 	 		4'd5:
    117. 	 		begin
    118. 				sector <= 4'd3;
    119. 				en_flag<= 1'd1;
    120. 	 		end
    121.  
    122. 	  		4'd4:
    123. 	 		begin
    124. 				sector <= 4'd4;
    125. 				en_flag<= 1'd1;
    126. 	 		end
    127.  
    128. 	 		4'd6:
    129. 	 		begin
    130. 				sector <= 4'd5;
    131. 				en_flag<= 1'd1;
    132. 	 		end
    133.  
    134. 	 		4'd2:
    135. 	 		begin
    136. 	 			sector <= 4'd6;
    137. 	 			en_flag<= 1'd1;
    138. 	 		end 		 				 		
    139.  
    140. 	 		default:
    141. 	 		begin
    142. 	 			sector <= 4'd0;
    143. 	 			en_flag<= 1'd0;
    144. 	 		end
    145.  
    146. 	 		endcase
    147. 	 	end
    148.  
    149.  		if(out_en)
    150.  		begin
    151.  			en_flag<= 1'd0;
    152.  		end
    153.  
    154.  		if(in_en)
    155. 		begin
    156. 		//实现高精度的方法，先计算所有的乘法，最后计算除法！
    157. 		//对于只需要计算符号的，不需要除以分母啦
    158. 		Vref1 <= Vbeta;         
    159. 		Vref2 <= (-1*Vbeta*512 + Valpha*887);///1024; //这一步,相当于alphasqrt3*根号三去掉后面的几位就是实现了除以255(新策略，都乘以256，再除以512)
    160.  		Vref3 <= (-1*Vbeta*512 - Valpha*887);///1024; 
    161.  
    162.  		x     <= sqrt3Ts*(Vbeta)/Vdc;
    163.  		y     <= (sqrt3Ts*Vbeta*512 + sqrt3Ts*Valpha*887)/(1024*Vdc);  //这里与Vref是差倍数的
    164.  		z     <= (sqrt3Ts*Vbeta*512 - sqrt3Ts*Valpha*887)/(1024*Vdc);
    165.  		flag2 <= 1'd1;
    166.  		end
    167. end
    168.  
    169.  
    170.  
    171. //将输入的值乘以443,代表根号3,乘以256的就代表乘以1		
    172. // mul1 mul1(
    173. // 	.dataa       ( Valpha      ),     //输入的Vα      
    174. // 	.result      ( alphasqrt3  )      //输出的值,根号3alpha
    175. // 	);
    176.  
    177.  
    178. endmodule

    2.3 Cal_time 模块

    利用输入的XYZ，计算时间的长度。

    1.  
    2. // 计算时间的长度
    3. // Type    : synthesizable
    4. // Standard: SystemVerilog 2005 (IEEE1800-2005)
    5. // 功能： 利用输入的XYZ，计算时间的长度
    6.  
    7. module Cal_time(
    8. 	input  wire                clk,         //时钟信号
    9. 	input  wire                rstn,        //复位信号
    10. 	input  wire                in_en,       //输入使能信号
    11.  
    12. 	input  wire signed [16:0]  x,
    13. 	input  wire signed [16:0]  y,
    14. 	input  wire signed [16:0]  z,
    15.  
    16. 	input  wire        [3:0]   n,
    17.  
    18. 	output reg  signed [16:0]   Tfirst,
    19. 	output reg  signed [16:0]   Tsecond,
    20. 	output reg  signed [16:0]   Tzero,
    21.     output reg                  out_en,      //输出使能信号
    22.     output reg                  out_en2,
    23.     output reg                  out_en3,
    24.     output reg  signed [30:0]   temp2,
    25.     output reg  signed [30:0]   temp3,
    26.     output reg  signed [30:0]   temp                
    27.  
    28.  
    29.     //output reg                  flag2
    30. );
    31.  
    32.  
    33. parameter  Tp = 1024;    //开关周期的一半,对应等腰三角形底边的一半
    34. parameter  Ts = 2048;
    35.  
    36.  
    37. //reg  signed [30:0]   temp2;
    38. //reg  signed [30:0]   temp3;
    39. reg                  flag2;
    40. //wire signed [30:0]   temp;
    41.  
    42. //assign  = 
    43.  
    44.  
    45.  
    46. always @(posedge clk)
    47. begin
    48. 	if(in_en)
    49. 		begin
    50. 			flag2 <= 1'd1;
    51. 		end
    52.  
    53. 	if(~rstn) 
    54. 	begin
    55. 		Tfirst  <= 17'd0;
    56. 		Tsecond <= 17'd0;
    57. 		temp2   <= 31'd0;
    58. 		temp3   <= 31'd0;
    59. 		flag2   <= 1'd0;
    60. 		out_en  <= 1'd0;
    61. 		out_en2 <= 1'd0;
    62. 		out_en3 <= 1'd0;
    63. 		Tzero   <= 17'd0;
    64. 		temp    <= 31'd0;
    65. 	end
    66.  
    67. 	else
    68. 		
    69. 		Tzero <= (Ts - Tfirst - Tsecond)/2;	
    70. 		begin
    71. 			if(flag2)
    72. 				begin
    73. 				flag2 <= 1'd0;
    74. 					case(n)
    75. 						4'd1:begin
    76. 							Tfirst  <= z;
    77. 							Tsecond <= y;
    78. 							out_en <= 1'd1;
    79. 						end
    80.  
    81. 						4'd2:begin
    82. 							Tfirst  <= y;
    83. 							Tsecond <= -1*x;
    84. 							out_en <= 1'd1;
    85. 						end
    86. 						
    87. 						4'd3:begin
    88. 							Tfirst  <= -1*z;
    89. 							Tsecond <= x;
    90. 							out_en <= 1'd1;
    91. 						end
    92. 						
    93. 						4'd4:begin
    94. 							Tfirst  <= -1*x;
    95. 							Tsecond <= z;
    96. 							out_en <= 1'd1;
    97. 						end
    98. 						
    99. 						4'd5:begin
    100. 							Tfirst  <= x;
    101. 							Tsecond <= -1*y;
    102. 							out_en <= 1'd1;
    103. 						end
    104. 						
    105. 						4'd6:begin
    106. 							Tfirst  <= -1*y;
    107. 							Tsecond <= -1*z;
    108. 							out_en <= 1'd1;
    109. 						end
    110.  
    111. 						default:
    112. 						begin
    113. 							Tfirst  <= 17'd0;
    114. 							Tsecond <= 17'd0;
    115. 							out_en <= 1'd0;			
    116. 						end
    117.  
    118. 					endcase 
    119. 				end
    120.  
    121.  
    122.  
    123. 		if(out_en)
    124. 			begin
    125. 				out_en <= 1'd0;
    126. 				out_en2<= 1'd1;  
    127. 			end	
    128.  
    129. 		if(out_en2)
    130. 		begin
    131. 			out_en2 <= 1'd0;
    132. 			out_en3 <= 1'd1;
    133. 		end
    134.  
    135. 		if(out_en3)
    136. 		begin
    137. 			out_en3 <= 1'd0;
    138. 		end		
    139.  
    140.  
    141. 		end
    142.  
    143. 	if(Tfirst + Tsecond > Ts)
    144. 	begin
    145. 		//temp2   <= Ts*Tfirst;
    146. 		//temp3   <= Ts*Tsecond;
    147. 		Tfirst  <= Ts*Tfirst/(Tfirst + Tsecond);
    148. 		Tsecond <= Ts*Tsecond/(Tfirst + Tsecond);
    149. 	end	
    150. 	
    151. end
    152.  
    153. endmodule

    2.4 Switch_time 模块

    利用时间长度信息，计算具体的开关切换时刻。

    1.  
    2. // 计算逆变器信号改变的时间
    3. // Type    : synthesizable
    4. // Standard: SystemVerilog 2005 (IEEE1800-2005)
    5. // 功能： 利用时间长度信息，计算具体的开关切换时刻。
    6.  
    7. module Switch_time(
    8. 	input  wire                 clk,         //时钟信号
    9. 	input  wire                 rstn,        //复位信号
    10. 	input  wire                 in_en,       //输入使能信号
    11. 	input  wire        [3:0]    n,
    12. 	input  wire signed [16:0]   Tfirst,
    13. 	input  wire signed [16:0]   Tsecond,
    14. 	input  wire signed [16:0]   Tzero,
    15.  
    16. 	output reg  signed [16:0]   Tcm1,        //三个逆变器的切换时间
    17. 	output reg  signed [16:0]   Tcm2,
    18. 	output reg  signed [16:0]   Tcm3,
    19. 	output reg                  out_en,      //输出使能信号 
    20. 	output reg                  out_en2      //延迟一拍
    21. );
    22.  
    23. wire signed [16:0] Ta_wire;
    24. wire signed [16:0] Tb_wire;
    25. wire signed [16:0] Tc_wire;
    26.  
    27. assign Ta_wire = Tzero/2;
    28. assign Tb_wire = Ta_wire + Tfirst/2;
    29. assign Tc_wire = Tb_wire + Tsecond/2;
    30.  
    31. reg signed [16:0] Ta;
    32. reg signed [16:0] Tb;
    33. reg signed [16:0] Tc;
    34. reg               flag2;
    35.  
    36.  
    37.  
    38.  
    39. always @(*)
    40. begin
    41.   if(!rstn)
    42.   begin
    43.   	Ta      <= 17'd0;
    44.   	Tb      <= 17'd0;
    45.   	Tc      <= 17'd0;  	
    46.   end
    47.   else
    48.   begin
    49.   	Ta      <= Ta_wire;
    50.   	Tb      <= Tb_wire;
    51.   	Tc      <= Tc_wire;   	
    52.   end
    53.  
    54. 	if(out_en2)	
    55. 	begin
    56.   	Ta      <= 17'd0;
    57.   	Tb      <= 17'd0;
    58.   	Tc      <= 17'd0;
    59. 	end
    60.  
    61. end
    62.  
    63.  
    64.  
    65.  
    66.  
    67.  
    68.  
    69.  
    70.  
    71. always @(posedge clk) //
    72. begin
    73. 	if(in_en)
    74. 	begin
    75. 		flag2 <= 1'd1;
    76. 	end
    77.  
    78.   if(!rstn)
    79.   begin
    80.   	Tcm1    <= 17'd0;
    81.   	Tcm2    <= 17'd0;
    82.   	Tcm3    <= 17'd0;
    83.  
    84.   	flag2   <= 1'd0;
    85.   	out_en  <= 1'd0;
    86.   	out_en2 <= 1'd0;
    87.   end
    88.  
    89.   else
    90.   begin
    91.   	if(flag2)
    92.   	begin
    93.   		
    94. 	  	// Ta    <= Tzero/2;
    95. 	  	// Tb    <= Ta + Tfirst/2;
    96. 	  	// Tc    <= Tb + Tsecond/2;
    97.  
    98. 			case(n)
    99. 			4'd1:begin
    100. 				Tcm1   <= Tb;
    101. 				Tcm2   <= Ta;
    102. 				Tcm3   <= Tc;
    103. 				out_en <= 1'd1;
    104. 			end
    105.  
    106. 			4'd2:begin
    107. 				Tcm1   <= Ta;
    108. 				Tcm2   <= Tc;
    109. 				Tcm3   <= Tb;
    110. 				out_en <= 1'd1;
    111. 			end
    112. 			
    113. 			4'd3:begin
    114. 				Tcm1   <= Ta;
    115. 				Tcm2   <= Tb;
    116. 				Tcm3   <= Tc;
    117. 				out_en <= 1'd1;
    118. 			end
    119. 			
    120. 			4'd4:begin
    121. 				Tcm1   <= Tc;
    122. 				Tcm2   <= Tb;
    123. 				Tcm3   <= Ta;
    124. 				out_en <= 1'd1;
    125. 			end
    126. 			
    127. 			4'd5:begin
    128. 				Tcm1   <= Tc;
    129. 				Tcm2   <= Ta;
    130. 				Tcm3   <= Tb;
    131. 				out_en <= 1'd1;
    132. 			end
    133. 			
    134. 			4'd6:begin
    135. 				Tcm1   <= Tb;
    136. 				Tcm2   <= Tc;
    137. 				Tcm3   <= Ta;
    138. 				out_en <= 1'd1;
    139. 			end
    140.  
    141. 			default:
    142. 			begin
    143. 				Tcm1   <= Tb;
    144. 				Tcm2   <= Ta;
    145. 				Tcm3   <= Tc;
    146. 				out_en <= 1'd0;				
    147. 			end
    148.  
    149. 		endcase 
    150. 		end
    151.  
    152. 		if(out_en)
    153. 			begin
    154. 				out_en  <= 1'd0;
    155. 				flag2   <= 1'd0;
    156. 			end
    157.  
    158. 		if(out_en)	
    159. 		begin
    160. 			out_en2 <= 1'd1;
    161. 		end
    162.  
    163. 		if(out_en2)	
    164. 		begin
    165. 			out_en2 <= 1'd0;
    166. 	  	// Ta      <= 17'd0;
    167. 	  	// Tb      <= 17'd0;
    168. 	  	// Tc      <= 17'd0;
    169. 	  	flag2   <= 1'd0;
    170. 	  	out_en  <= 1'd0;
    171. 		end
    172.  
    173.   end
    174.  
    175. end
    176.  
    177. endmodule

    2.5 Tri_gener 模块

    产生三角波，便于确定当前所处的时刻。其中的变量CYCLE_NUM可以用来控制仿真的时候，SVPWM输出的具体循环数量。

    1.  
    2. // 三角波生成模块
    3. // Type    : synthesizable
    4. // Standard: SystemVerilog 2005 (IEEE1800-2005)
    5. // 功能： 产生三角波，便于确定当前所处的时刻。
    6.  
    7. module Tri_gener(
    8.       input   wire         clk,              //输入时钟
    9.       input   wire         rst,              //复位信号
    10.       input   wire         in_en,            //输入使能信号
    11.       // output  reg          Ts_cp,         //对PGFS输入时钟进行同步化后的时钟,提供给Ts累加的脉冲
    12.       output  reg   signed [11:0]  Ts_cnt,          //Ts的计数器,用来产生一个周期为Ts=2*Tp的三角波
    13.       output  reg          deta_clk          //每次输出一个时钟，就给一个高电平
    14. );
    15.  
    16.  
    17. ///三角波产生//
    18. reg [16:0]         adder;   //Ts有关的相位累加器
    19. reg                Ts_dir;  //Ts的计数器的计数方向
    20. reg                flag2;
    21. reg signed [5:0]   cycle_num; //计数完成了多少个周期
    22.  
    23. parameter   Tp = 1024,   //开关周期的一半
    24.             pfs= 10000;  //频率控制输入,5000:7K,10000:15K,20000:30K
    25.  
    26. parameter   CYCLE_NUM = 3;
    27.             
    28.  
    29. ///三角波产生//
    30.  
    31. // always @(posedge clk) //相位累加器，溢出信号提供给周期循环计数器
    32. // begin
    33. //   if(!rst)
    34. //   begin
    35. //     adder <= 17'b0;
    36. //     Ts_cp <= 1'b0;
    37. //   end
    38. //   else
    39. //   begin
    40. //     adder <= adder + pfs;
    41.  
    42. //     if(adder[16])
    43. //     begin
    44. //       Ts_cp <= 1'b1;
    45. //       adder[16] <= 1'b0;
    46. //     end
    47. //     else
    48. //       Ts_cp <= 1'b0;
    49. //   end
    50. // end
    51.  
    52. always @(posedge clk)
    53. begin
    54.     if(in_en)
    55.         begin
    56.             flag2 <= 1'd1;
    57.         end
    58.  
    59.   if(!rst)
    60.   begin
    61.     Ts_cnt   <= 12'd0;
    62.     Ts_dir   <= 1'b1;
    63.     deta_clk <= 1'b0;
    64.     flag2    <= 1'd0;
    65.     cycle_num<= 1'd0; 
    66.   end
    67.   else
    68.   begin
    69.     if(cycle_num == CYCLE_NUM)
    70.         flag2 <= 1'd0;
    71.  
    72.     if(flag2)
    73.         begin
    74.             if(Ts_dir)
    75.                 Ts_cnt <= Ts_cnt + 12'b1;
    76.             else
    77.                 Ts_cnt <= Ts_cnt - 12'b1;
    78.  
    79.             if( Ts_cnt == Tp-1 ) //注意是非阻塞赋值
    80.                 begin
    81.                     Ts_dir   <= 1'b0;
    82.                 end
    83.  
    84.             if( Ts_cnt == 1 )   //注意是非阻塞赋值
    85.                 begin
    86.                     Ts_dir   <= 1'b1;
    87.                 end
    88.  
    89.             if( Ts_cnt == 1 && ~Ts_dir)
    90.                 begin
    91.                    deta_clk  <= 1'b1;
    92.                    cycle_num <= cycle_num + 1'b1;
    93.                 end
    94.             else
    95.                 begin
    96.                    deta_clk <= 1'b0; 
    97.                 end
    98.         end
    99.  
    100.  
    101.   end
    102. end
    103.  
    104. endmodule

    2.6 测试模块

    这个是对整体模块的测试代码，可以在里面设置Vα与Vβ的值，在Quartus中进行仿真验证。

    1. // Copyright (C) 2018  Intel Corporation. All rights reserved.
    2. // Your use of Intel Corporation's design tools, logic functions 
    3. // and other software and tools, and its AMPP partner logic 
    4. // functions, and any output files from any of the foregoing 
    5. // (including device programming or simulation files), and any 
    6. // associated documentation or information are expressly subject 
    7. // to the terms and conditions of the Intel Program License 
    8. // Subscription Agreement, the Intel Quartus Prime License Agreement,
    9. // the Intel FPGA IP License Agreement, or other applicable license
    10. // agreement, including, without limitation, that your use is for
    11. // the sole purpose of programming logic devices manufactured by
    12. // Intel and sold by Intel or its authorized distributors.  Please
    13. // refer to the applicable agreement for further details.
    14.  
    15. // *****************************************************************************
    16. // This file contains a Verilog test bench template that is freely editable to  
    17. // suit user's needs .Comments are provided in each section to help the user    
    18. // fill out necessary details.                                                  
    19. // *****************************************************************************
    20. // Generated on "06/27/2022 19:37:37"
    21.                                                                                 
    22. // Verilog Test Bench template for design : my_SVPWM
    23. // 
    24. // Simulation tool : ModelSim (Verilog)
    25. // 
    26.  
    27. `timescale 1 ps/ 1 ps
    28. module my_SVPWM_vlg_tst();
    29. // constants                                           
    30. // general purpose registers
    31. reg eachvec;
    32. reg clk;
    33. reg rstn;
    34. reg in_en;
    35. // test vector input registers
    36. reg [15:0] Valpha;
    37. reg [15:0] Vbeta;
    38. // wires                                               
    39. wire Cal_time_out_en;
    40. wire Jug_sec_in_en;
    41. wire Jug_sec_out_en;
    42. wire Switch_time_out_en;
    43. wire [16:0]  Tcm1;
    44. wire [16:0]  Tcm2;
    45. wire [16:0]  Tcm3;
    46. wire [16:0]  Tfirst;
    47. wire Tri_gener_out_en;
    48. wire signed [11:0]  Ts_cnt;
    49. wire [16:0]  Tsecond;
    50. wire [16:0]  Tzero;
    51. wire [3:0]  n;
    52. wire pwm_a;
    53. wire pwm_b;
    54. wire pwm_c;
    55. wire [3:0]  sector;
    56. wire [16:0]  x;
    57. wire [16:0]  y;
    58. wire [16:0]  z;
    59.  
    60. parameter half_cycle = 10;
    61.  
    62. // assign statements (if any)                          
    63. my_SVPWM i1 (
    64. // port map - connection between master ports and signals/registers   
    65. 	.Cal_time_out_en(Cal_time_out_en),
    66. 	.Jug_sec_in_en(Jug_sec_in_en),
    67. 	.Jug_sec_out_en(Jug_sec_out_en),
    68. 	.Switch_time_out_en(Switch_time_out_en),
    69. 	.Tcm1(Tcm1),
    70. 	.Tcm2(Tcm2),
    71. 	.Tcm3(Tcm3),
    72. 	.Tfirst(Tfirst),
    73. 	.Tri_gener_out_en(Tri_gener_out_en),
    74. 	.Ts_cnt(Ts_cnt),
    75. 	.Tsecond(Tsecond),
    76. 	.Tzero(Tzero),
    77. 	.Valpha(Valpha),
    78. 	.Vbeta(Vbeta),
    79. 	.n(n),
    80. 	.pwm_a(pwm_a),
    81. 	.pwm_b(pwm_b),
    82. 	.pwm_c(pwm_c),
    83. 	.sector(sector),
    84. 	.x(x),
    85. 	.y(y),
    86. 	.z(z),
    87. 	.clk(clk),
    88. 	.rstn(rstn),
    89. 	.in_en(in_en)
    90. );
    91.  
    92. // my_SVPWM i1 (
    93. // 	.clk(clk),         //时钟信号
    94. // 	.rstn(rstn),        //复位信号
    95. // 	.in_en(in_en),       //系统的输入使能信号
    96. // 	.Valpha(Valpha),      //Park逆变换的结果Vα
    97. // 	.Vbeta(Vbeta),       //Park逆变换的结果Vβ
    98. // 	.pwm_a(pwm_a),       //SVPWM的输出1 PWM_a
    99. // 	.pwm_b(pwm_b),       //SVPWM的输出2 PWM_b
    100. // 	.pwm_c(pwm_c)        //SVPWM的输出3 PWM_c
    101. // );
    102.  
    103. initial                                                
    104. begin                                                  
    105. // code that executes only once                        
    106. // insert code here --> begin                          
    107. 	clk = 0;
    108.     forever begin
    109. 		#half_cycle clk = 1;
    110.         #half_cycle clk = 0;
    111. 	end                                                          
    112. // --> end                                             
    113. $display("Running testbench");                       
    114. end                               
    115.  
    116. initial
    117. begin
    118. 	rstn = 1;
    119. 	#5 rstn = 0;
    120. 	#10 rstn = 1;
    121. end
    122.  
    123. initial
    124. begin
    125. 	Valpha = 16'd10;
    126.     Vbeta  = 16'd10;
    127. end
    128.  
    129.  
    130. initial
    131. begin
    132. 	in_en = 0;
    133. 	#90 in_en = 1;
    134. 	#20 in_en = 0;
    135. end
    136.  
    137.  
    138.  
    139.  
    140. always                                                 
    141. // optional sensitivity list                           
    142. // @(event1 or event2 or .... eventn)                  
    143. begin                                                  
    144. // code executes for every event on sensitivity list   
    145. // insert code here --> begin                          
    146.                                                        
    147. @eachvec;                                              
    148. // --> end                                             
    149. end                                                    
    150. endmodule
    151.

    3 仿真结果

    已经通过Quartus进行了仿真验证，下面展示具体的仿真结果，并与MATLAB的结果进行对应，可以看到两者之间是完全吻合的，证明算法正确。

    这里测试的例子是U_alpha = 10，U_beta  = 10时的调制结果~

    3.1 MATLAB计算结果

    具体的数据结果：

    输出的波形结果：

    3.2 Quartus仿真结果

    来个放大的图：

    再来个细节图：

    可以看到是与MATLAB的输出结果相一致的。

    值得一提的是，可能有读者会问，为什么XYZ的值，MATLAB和Verilog的计算结果刚好相差了一倍呢？这是因为问题出在了Ts上，在MATLAB中，使用的是具体的时间周期长度（计数值除以了50MHz的系统时钟），而Verilog中，由于SVPWM只是需要根据要求在固定周期内按次序输出调制波形，因此具体的周期长短不构成影响（占空比比例更为重要），因此就单纯使用Ts计数值的大小代替了具体的周期长度。

    这就是本期的全部内容啦，如果你喜欢我的文章，不要忘了点赞收藏，分享给身边的朋友哇~

  • 相关阅读:
    对线性插值的理解
    Java刷题面试系列习题(十)
    百度地图——地图找房功能
    搭建 GPT-2 模型训练环境
    Opencv中的GrabCut图像分割
    Java文件操作
    k8s自定义Endpoint实现内部pod访问外部应用
    vue下载Excel文件
    主动获取用户的ColaKey接口
    亚马逊加湿器UL998测试报告，测试项目
  • 原文地址：https://blog.csdn.net/Alex497259/article/details/125502416