找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 1767|回复: 0
收起左侧

pfm双通道驱动 verilog源码

[复制链接]
ID:884524 发表于 2021-2-17 14:36 | 显示全部楼层 |阅读模式
pfm双通道驱动源码,驱动双通道igbt,4路pwm相差90度
  1. module PFMc ( sclk, f_en1,f_en2,Tf_i,Ts_i,Fout1, Fout2 ,Fout3, Fout4
  2.          //   ,test1
  3.                                 //,t1,test2
  4.                                  );
  5.         
  6.                  input  sclk ;  //晶振50M   20ns      
  7.                  input  f_en1;   //波形输出封锁信号 0封锁输出
  8.                  input  f_en2;   //波形输出封锁信号 0封锁输出
  9.             input [18:1] Tf_i;      //1000000/f us 最大1000000,最小25
  10.                                          //PWM频率对应周期 f最小1HZ,最大40K
  11.                  input [6:1]Ts_i;     //PWM周期 us 最大31
  12.                  
  13.                  output  reg Fout1 ;  //通道1PWM输出
  14.                  output  reg Fout2 ;
  15.        output  reg Fout3 ;  //通道2PWM输出
  16.                  output  reg Fout4 ;
  17.                  
  18. //                 output wire [28:1] test1;       
  19.                 // output wire [28:1] test2;       
  20.                 // output wire [12:1] t1;       
  21.                 //
  22. //                 assign test1 = f_cnt;
  23.                 // assign test2 = f_cnt3;
  24.                 // assign t1 = f1;  
  25.        reg  f_cs1 = 1'd0;   //通道1波形使能
  26.                  reg  f_cs2 = 1'd0;   //通道2波形使能         
  27.                  reg  f_en1_buffer = 1'd0;   //通道1波形使能缓存
  28.                  reg  f_en2_buffer = 1'd0;   //通道2波形使能缓存         
  29.                  
  30.                  reg  rest_n=1'b0;   //两个通道同时关闭时,计数复位,高复位
  31.                  reg [27:1] f_cnt;             //计数值
  32.                  reg  [11:1] f_cnt1 = 11'd0 ; //Ts高电平计数个数
  33.        reg  [25:1] f_cnt2 = 25'd250 ; //Ts 低电平计数个数
  34.                  reg  [27:1] f_cnt3 ;          //总计数值
  35.                  reg  f0 = 1'd0;               
  36.                  reg  [11:1] f1=11'd0;
  37.                  reg  [26:1] f2=26'd0,f3=26'd0;
  38.                  reg  [25:1] f4=25'd0,f5=25'd0;
  39.                  reg  [27:1] f6=27'd0,f7=27'd0;
  40.                  reg  [11:1] f8=11'd0;
  41.          
  42.                  reg [18:1] Tf_buffer=18'd0;
  43.                  reg [6:1]Ts_buffer=6'd0;                  
  44.        reg [18:1] Tf=18'd10000;
  45.                  reg [6:1]Ts=6'd0;
  46.                  
  47.                
  48.                 always @( Ts or Tf ) begin       //参数设置改变后,对参数初始化               
  49.                             f_cnt1 = Ts*50 ; //(Ts*1000)/20; //Ts高电平计数个数
  50.                        f_cnt2 = Tf*25; //对应1/2  f个周期计数个数
  51.                                  f_cnt3 = Tf*25<<2 ;   //4个驱动方波输出周期       
  52.                   f0 = 1'd0;                  //4个电平翻转状态   PFM1上升沿
  53.                        f1 = Ts*50;                 //PFM1 下降沿
  54.                        f2 = Tf*25<<1 ;            //PFM2上升沿
  55.                        f3= (Tf*25<<1)+Ts*50;    //PFM2 下降沿       
  56.                                  f4 =Tf*25;                  //PFM3上升沿
  57.                        f5 =Tf*25+Ts*50;                 //PFM3 下降沿
  58.                        f6 = (Tf*25<<1)+Tf*25;  //PFM4上升沿                                                                                  
  59.                        f7 = (Tf*25<<1)+Tf*25+Ts*50;   //PFM4 下降沿       
  60.                   f8 = Ts*50-Tf*25;
  61.                 end
  62.                
  63.             always @( f_cs1 or f_cs2 ) begin  //两个通道都关闭时,计数复位
  64.                       rest_n = !(f_cs1 || f_cs2);
  65.                  end
  66.                  
  67.                  //pwm 低电平状态下 使能信号生效
  68.                  always@(  posedge sclk or negedge Fout1 or negedge Fout2 or negedge Fout3 or negedge Fout4 ) begin
  69.            if( Fout1==1'b0 || Fout2==1'b0 )
  70.                          f_cs1 <= f_en1_buffer ;       
  71.                           else f_cs1 <= 1'b1;
  72.                 if( Fout3==1'b0 || Fout4==1'b0 )                               
  73.                                    f_cs2 <= f_en2_buffer ;
  74.                           else f_cs2 <= 1'b1;
  75.                                
  76.                  end       
  77.                  
  78.                  always@( posedge sclk  or posedge  rest_n ) begin         //通道1 2循环
  79.                                  f_en1_buffer <= f_en1;
  80.                       f_en2_buffer <= f_en2;
  81.                       if( rest_n==1'b1 ) begin                   //封闭后计数复位
  82.                                    f_cnt <= 27'd0;
  83.                                              Tf_buffer <= Tf_i;                                        //f,Ts数据缓存2个时钟周期
  84.                                    Ts_buffer <= Ts_i;
  85.                                end
  86.                                else  begin                                                            
  87.                              if( f_cnt>=(f_cnt3+1'b1) ) begin    //循环计数复位
  88.                                                f_cnt <= 27'd0;
  89.                                                      Tf_buffer <= Tf_i;                               
  90.                                           Ts_buffer <= Ts_i;
  91.                                             end
  92.                                             else begin
  93.                                                    f_cnt <= f_cnt+1'b1;       
  94.                                                                   if( f_cnt==27'd10) begin
  95.                                                                       Tf<=Tf_buffer;
  96.                                                      Ts<=Ts_buffer;
  97.                                                                   end
  98.                                           end
  99.                                end
  100.                                
  101.        end       
  102.                  
  103.                  always@( posedge sclk  ) begin           //PWM输出控制
  104.                 if(f_cs1==1'b0) begin                //通道1,
  105.                              Fout1 <= 1'b0;
  106.                                   Fout2 <= 1'b0;
  107.                           end
  108.                           else begin
  109.                                 if( f_cs1 ) begin                     
  110.                                      case ( f_cnt )
  111.                                        f0:  Fout1 <= 1'b1;
  112.                                              f1:  Fout2 <= 1'b1;
  113.                                              f2:  Fout1 <= 1'b0;
  114.                                              f3:  Fout2 <= 1'b0;
  115.                                      endcase                                       
  116.                               end       
  117.                               else begin
  118.                                       Fout1 <= 1'b0;
  119.                                             Fout2 <= 1'b0;
  120.                                    end       
  121.                                end                  
  122.            if        ( f_cs2 ==1'b0) begin             //通道2
  123.                    Fout3 <= 1'b0;
  124.                                   Fout4 <= 1'b0;
  125.                           end                   
  126.                           else begin
  127.                              if( f_cs2 ) begin                  
  128.                                    case(f_cnt)
  129.                                       f4:  Fout3 <= 1'b1;
  130.                                             f5:  Fout4 <= 1'b1;
  131.                                             f6:  Fout3 <= 1'b0;
  132.                                             f7:  Fout4 <= 1'b0;
  133.                                     endcase                                                                                                                             
  134.                                     if(f_cnt1>=f_cnt2)        begin       
  135.                                          if(f_cnt==f8)begin                                        
  136.                                                              Fout4 <= 1'b0;
  137.                                                      end       
  138.                                     end       
  139.                              end
  140.                         else begin
  141.                                     Fout3 <= 1'b0;
  142.                                               Fout4 <= 1'b0;
  143.                              end
  144.                        
  145.                     end                
  146.           end       
  147.                

  148.                  
  149. endmodule
  150. /*
  151. module PFMc ( sclk, f_en1,f_en2,f_i,Ts_i,Fout1, Fout2 ,Fout3, Fout4
  152.             // ,test1,t1,test2
  153.                                  );
  154.         
  155.                  input  sclk ;  //晶振50M   20ns      
  156.                  input  f_en1;   //波形输出封锁信号 0封锁输出
  157.                  input  f_en2;   //波形输出封锁信号 0封锁输出
  158.             input [16:1] f_i;      //PWM频率 Hz 最小1HZ,最大40K
  159.                  input [6:1]Ts_i;     //PWM周期 us 最大31
  160.                  
  161.                  output  reg Fout1 ;  //通道1PWM输出
  162.                  output  reg Fout2 ;
  163.        output  reg Fout3 ;  //通道2PWM输出
  164.                  output  reg Fout4 ;
  165.                  
  166.                 // output wire [28:1] test1;       
  167.                 // output wire [28:1] test2;       
  168.                 // output wire [12:1] t1;       
  169.                 //
  170.                 // assign test1 = f_cnt;
  171.                 // assign test2 = f_cnt3;
  172.                 // assign t1 = f1;  
  173.        reg  f_cs1 = 1'd0;   //通道1波形使能
  174.                  reg  f_cs2 = 1'd0;   //通道2波形使能         
  175.                  reg  f_en1_buffer = 1'd0;   //通道1波形使能缓存
  176.                  reg  f_en2_buffer = 1'd0;   //通道2波形使能缓存         
  177.                  
  178.                  reg  rest_n=1'b0;   //两个通道同时关闭时,计数复位,高复位
  179.                  reg [27:1] f_cnt;             //计数值
  180.                  reg  [11:1] f_cnt1 = 11'd0 ; //Ts高电平计数个数
  181.        reg  [25:1] f_cnt2 = 25'd250 ; //Ts 低电平计数个数
  182.                  reg  [27:1] f_cnt3 ;          //总计数值
  183.                  reg  f0 = 1'd0;               
  184.                  reg  [11:1] f1=11'd0;
  185.                  reg  [26:1] f2=26'd0,f3=26'd0;
  186.                  reg  [25:1] f4=25'd0,f5=25'd0;
  187.                  reg  [27:1] f6=27'd0,f7=27'd0;
  188.                  reg  [11:1] f8=11'd0;
  189.          
  190.                  reg [17:1] f_buffer=17'd0;
  191.                  reg [6:1]Ts_buffer=6'd0;                  
  192.        reg [17:1] f=17'd40000;
  193.                  reg [6:1]Ts=6'd0;
  194.                  
  195.                
  196.                 always @( Ts or f ) begin       //参数设置改变后,对参数初始化               
  197.                             f_cnt1 = Ts*50 ; //(Ts*1000)/20; //Ts高电平计数个数
  198.                        f_cnt2 = (1000000/f)*25; //对应1/2  f个周期计数个数
  199.                                  f_cnt3 = (1000000/f)*25<<2 ;   //4个驱动方波输出周期       
  200.                   f0 = 1'd0;                  //4个电平翻转状态   PFM1上升沿
  201.                        f1 = Ts*50;                 //PFM1 下降沿
  202.                        f2 = (1000000/f)*25<<1 ;            //PFM2上升沿
  203.                        f3= {(1000000/f)*25<<1}+Ts*50;    //PFM2 下降沿       
  204.                                  f4 =(1000000/f)*25;                  //PFM3上升沿
  205.                        f5 =(1000000/f)*25+Ts*50;                 //PFM3 下降沿
  206.                        f6 = {(1000000/f)*25<<1}+(1000000/f)*25;  //PFM4上升沿                                                                                  
  207.                        f7 = {(1000000/f)*25<<1}+{(1000000/f)*25}+Ts*50;   //PFM4 下降沿       
  208.                   f8 = Ts*50-(1000000/f)*25;
  209.                 end
  210.                
  211.             always @( f_cs1 or f_cs2 ) begin  //两个通道都关闭时,计数复位
  212.                       rest_n = !(f_cs1 || f_cs2);
  213.                  end
  214.                  
  215.                  always@(  posedge sclk or negedge Fout1 or negedge Fout2 or negedge Fout3 or negedge Fout4 ) begin
  216.            if( Fout1==1'b0 || Fout2==1'b0 )
  217.                          f_cs1 <= f_en1_buffer ;       
  218.                           else f_cs1 <= 1'b1;
  219.                 if( Fout3==1'b0 || Fout4==1'b0 )                               
  220.                                    f_cs2 <= f_en2_buffer ;
  221.                           else f_cs2 <= 1'b1;
  222.                                
  223.                  end       
  224.                  
  225.                  always@( posedge sclk  or posedge  rest_n ) begin         //通道1 2循环
  226.                                  f_en1_buffer <= f_en1;
  227.                       f_en2_buffer <= f_en2;
  228.                       if( rest_n==1'b1 ) begin                   //封闭后计数复位
  229.                                    f_cnt <= 27'd0;
  230.                                              f_buffer <= f_i;                                        //f,Ts数据缓存2个时钟周期
  231.                                    Ts_buffer <= Ts_i;
  232.                                end
  233.                                else  begin                                                            
  234.                              if( f_cnt>=(f_cnt3+1'b1) ) begin    //循环计数复位
  235.                                                f_cnt <= 27'd0;
  236.                                                      f_buffer <= f_i;                               
  237.                                           Ts_buffer <= Ts_i;
  238.                                             end
  239.                                             else begin
  240.                                                    f_cnt <= f_cnt+1'b1;       
  241.                                                                   if( f_cnt==27'd10) begin
  242.                                                                       f<=f_buffer;
  243.                                                      Ts<=Ts_buffer;
  244.                                                                   end
  245.                                           end
  246.                                end
  247.                                
  248.        end       
  249.                  
  250.                  always@( posedge sclk  ) begin           //PWM输出控制
  251.                 if(f_cs1==1'b0) begin                //通道1,
  252.                              Fout1 <= 1'b0;
  253.                                   Fout2 <= 1'b0;
  254.                           end
  255.                           else begin
  256.                                 if( f_cs1 ) begin                     
  257.                                      case ( f_cnt )
  258.                                        f0:  Fout1 <= 1'b1;
  259.                                              f1:  Fout2 <= 1'b1;
  260.                                              f2:  Fout1 <= 1'b0;
  261.                                              f3:  Fout2 <= 1'b0;
  262.                                      endcase                                       
  263.                               end       
  264.                               else begin
  265.                                       Fout1 <= 1'b0;
  266.                                             Fout2 <= 1'b0;
  267.                                    end       
  268.                                end                  
  269.            if        ( f_cs2 ==1'b0) begin             //通道2
  270.                    Fout3 <= 1'b0;
  271.                                   Fout4 <= 1'b0;
  272.                           end                   
  273.                           else begin
  274.                              if( f_cs2 ) begin                  
  275.                                    case(f_cnt)
  276.                                       f4:  Fout3 <= 1'b1;
  277.                                             f5:  Fout4 <= 1'b1;
  278.                                             f6:  Fout3 <= 1'b0;
  279.                                             f7:  Fout4 <= 1'b0;
  280.                                     endcase                                                                                                                             
  281.                                     if(f_cnt1>=f_cnt2)        begin       
  282.                                          if(f_cnt==f8)begin                                        
  283.                                                              Fout4 <= 1'b0;
  284.                                                      end       
  285.                                     end       
  286.                              end
  287.                         else begin
  288.                                     Fout3 <= 1'b0;
  289.                                               Fout4 <= 1'b0;
  290.                              end
  291.                        
  292.                     end                
  293.           end       
  294.                

  295.                  
  296. endmodule
  297. */
  298. /*
  299. //IGBT 波形发生  2个通道
  300. module PFMc ( sclk, f_en1,f_en2,f_i,Ts_i,Fout1, Fout2 ,Fout3, Fout4,test);
  301.         
  302.                  input  sclk ;  //晶振50M   20ns      
  303.                  input  f_en1;   //波形输出封锁信号 0封锁输出
  304.                  input  f_en2;   //波形输出封锁信号 0封锁输出
  305.                  input [17:1] f_i;      //PWM频率 Hz 最小1HZ,最大40K
  306.                  input [6:1]Ts_i;     //PWM周期 us 最大25
  307.                  
  308.                  output  reg Fout1 ;  //通道1PWM输出
  309.                  output  reg Fout2 ;
  310.        output  reg Fout3 ;  //通道2PWM输出
  311.                  output  reg Fout4 ;
  312.        output  reg test ;

  313.        reg  f_cs1 = 1'd0;   //通道1波形使能
  314.                  reg  f_cs2 = 1'd0;   //通道2波形使能
  315.                  reg  [28:1]  f_cnt = 28'd0 ;
  316.                  reg  [12:1] f_cnt1 = 12'd0 ; //Ts高电平计数个数
  317.                  reg  [26:1] f_cnt2 = 26'd250 ; //Ts 低电平计数个数
  318.                  reg  [28:1] f_cnt3 ;
  319.                  reg  f0 = 1'd0;
  320.                  reg  [12:1] f1=12'd0;
  321.                  reg  [27:1] f2=27'd0,f3=27'd0;
  322.                  reg  [28:1] f4=28'd0,f5=28'd0;
  323.                  reg  [28:1] f6=28'd0,f7=28'd0;
  324.                  reg  [12:1] f8=12'd0;
  325.          
  326.                  reg [17:1] f_buffer=17'd0;
  327.                  reg [6:1]Ts_buffer=6'd0;                  
  328.        reg [17:1] f=17'd40000;
  329.                  reg [6:1]Ts=6'd0;
  330.                  
  331.        always@(posedge sclk or negedge f_en1) begin //测试
  332.              if(!f_en1) begin
  333.                 test <= 1'b1;
  334.                        end
  335.              else if(f_cnt == 28'd1)
  336.                      test <= ~test;                                              
  337.                 end
  338.                
  339.       always @( posedge sclk ) begin     //TS f参数缓存1个周期,在1个周期完后生效
  340.          if( f_cnt == 28'd0 ) begin
  341.                       f_buffer <= f_i;
  342.                            Ts_buffer <= Ts_i;
  343.                    end
  344.                        
  345.                         if( f_cnt1 < f_cnt2 )        begin
  346.                       if(f_cnt == f_cnt3) begin
  347.                               f<=f_buffer;
  348.                                    Ts<=Ts_buffer;
  349.             end
  350.                         end
  351.                        
  352.                         if( f_cnt1 >= f_cnt2 )        begin
  353.                            if(f_cnt == f8) begin
  354.                               f<=f_buffer;
  355.                                    Ts<=Ts_buffer;
  356.             end
  357.                         end
  358.          
  359.            end


  360.            always @( Ts or f ) begin       //参数设置改变后,对参数初始化
  361.                
  362.                             f_cnt1 = Ts*50 ; //(Ts*1000)/20; //Ts高电平计数个数
  363.                        f_cnt2 = (1000000/f)*25; //对应1/2  f个周期计数个数
  364.                                  f_cnt3 = (1000000/f)*25<<2 ;   //4个驱动方波输出周期       
  365.                   f0 = 1 'd0;                  //4个电平翻转状态   PFM1上升沿
  366.                        f1 = Ts*50;                 //PFM1 下降沿
  367.                        f2 = (1000000/f)*25<<1 ;            //PFM2上升沿
  368.                        f3= {(1000000/f)*25<<1}+Ts*50;    //PFM2 下降沿       
  369.                                  f4 =(1000000/f)*25;                  //PFM3上升沿
  370.                        f5 =(1000000/f)*25+Ts*50;                 //PFM3 下降沿
  371.                        f6 = {(1000000/f)*25<<1}+(1000000/f)*25;  //PFM4上升沿                                                                                  
  372.                        f7 = {(1000000/f)*25<<1}+{(1000000/f)*25}+Ts*50;   //PFM4 下降沿       
  373.                   f8 = Ts*50-(1000000/f)*25;
  374.                 end
  375.                
  376.                  always@(  posedge sclk  or posedge f_en1 or posedge f_en2) begin                                 //波形输出期间,禁止关断
  377.            if(f_en1)                                   
  378.                                  if( Fout1 || Fout2 )
  379.                                       f_cs1 <= 1'd1 ;
  380.                                   else f_cs1 <=f_en1 ;
  381.                           else f_cs1 <= 1'b0;
  382.                           if(f_en2)                             
  383.                                   if( Fout3 || Fout4 )
  384.                                       f_cs2 <= 1'd1 ;
  385.                                   else f_cs2 <=f_en2 ;       
  386.                           else f_cs2 <= 1'b0;  
  387.                  end

  388.        always@( posedge sclk or posedge f_cs1 or posedge f_cs2 ) begin         //通道1 2循环
  389.            if( f_cs1 || f_cs2 )  begin           //使能
  390.                              f_cnt <= f_cnt+1'b1;                             
  391.                    if( f_cnt>=f_cnt3 )     //循环复位
  392.                                      f_cnt <= 28'd0;
  393.                                 end
  394.                                 else f_cnt <= 28'd0;
  395.        end                                                  

  396.                  
  397.                 always@( posedge sclk or posedge f_cs1 or posedge f_cs2 ) begin       
  398.                  
  399.                      if        ( f_cs1 ) begin                
  400.                                 case ( f_cnt )
  401.                                     f0:  Fout1 <= 1'b1;
  402.                                          f1:  Fout2 <= 1'b1;
  403.                                          f2:  Fout1 <= 1'b0;
  404.                                          f3:  Fout2 <= 1'b0;
  405.                                 endcase                                       
  406.                         end
  407.                    else begin
  408.                               Fout1 <= 1'b0;
  409.                                         Fout2 <= 1'b0;
  410.                         end        

  411.          if        ( f_cs2 ) begin
  412.                        
  413.                             case(f_cnt)
  414.                                     f4:  Fout3 <= 1'b1;
  415.                                          f5:  Fout4 <= 1'b1;
  416.                                          f6:  Fout3 <= 1'b0;
  417.                                          f7:  Fout4 <= 1'b0;
  418.                                  endcase                                               
  419.                                                                        
  420.                                  if(f_cnt1>=f_cnt2)        begin       
  421.                                  if(f_cnt==f8)begin                                        
  422.                                                           Fout4 <= 1'b0;
  423.                                                 end       
  424.                                   end       
  425.                         end
  426.                    else begin
  427.                               Fout3 <= 1'b0;
  428.                                         Fout4 <= 1'b0;
  429.                     end
  430.                        

  431.            end
  432.          
  433.                        
  434. endmodule
  435. */
  436. /*
  437. //IGBT 波形发生  2个通道
  438. module PFMc ( sclk, f_en1,f_en2,f_i,Ts_i,Fout1, Fout2 ,Fout3, Fout4);
  439.         
  440.                  input  sclk ;  //晶振50M   20ns      
  441.                  input  f_en1;   //波形输出封锁信号 0封锁输出
  442.                  input  f_en2;   //波形输出封锁信号 0封锁输出
  443.                  input [17:1] f_i;      //PWM频率 Hz 最小1HZ,最大40K
  444.                  input [6:1]Ts_i;     //PWM周期 us 最大25
  445.                  
  446.                  output  reg Fout1 ;  //通道1PWM输出
  447.                  output  reg Fout2 ;
  448.        output  reg Fout3 ;  //通道2PWM输出
  449.                  output  reg Fout4 ;


  450.        reg  f_cs1 = 1'd0;   //通道1波形使能
  451.                  reg  f_cs2 = 1'd0;   //通道2波形使能
  452.                  reg  [28:1]  f_cnt = 0 ;
  453.                  reg  [12:1] f_cnt1 = 0 ; //Ts高电平计数个数
  454.                  reg  [26:1] f_cnt2 = 250 ; //Ts 低电平计数个数
  455.                  reg  [28:1] f_cnt3 ;
  456.                  reg  f0 = 1'd0;
  457.                  reg  [12:1] f1=0;
  458.                  reg  [27:1] f2=0,f3=0;
  459.                  reg  [28:1] f4=0,f5=0;
  460.                  reg  [28:1] f6=0,f7=0;
  461.                  reg  [12:1] f8=0;
  462.                  
  463.                  
  464.                  reg [17:1] f_buffer=0;
  465.                  reg [6:1]Ts_buffer=0;                  
  466.        reg [17:1] f=40000;
  467.                  reg [6:1]Ts=0;
  468.   
  469.       always @( posedge sclk ) begin     //TS f参数缓存1个周期,在1个周期完后生效
  470.          if( f_cnt == 0 ) begin
  471.                       f_buffer <= f_i;
  472.                            Ts_buffer <= Ts_i;
  473.                    end
  474.                        
  475.                         if( f_cnt1 < f_cnt2 )        begin
  476.                       if(f_cnt == f_cnt3) begin
  477.                               f<=f_buffer;
  478.                                    Ts<=Ts_buffer;
  479.             end
  480.                         end
  481.                        
  482.                         if( f_cnt1 >= f_cnt2 )        begin
  483.                            if(f_cnt == f8) begin
  484.                               f<=f_buffer;
  485.                                    Ts<=Ts_buffer;
  486.             end
  487.                         end
  488.          
  489.            end


  490.            always @( Ts or f ) begin       //参数设置改变后,对参数初始化
  491.                
  492.                             f_cnt1 = Ts*50 ; //(Ts*1000)/20; //Ts高电平计数个数
  493.                        f_cnt2 = (1000000/f)*25; //对应1/2  f个周期计数个数
  494.                                  f_cnt3 = (1000000/f)*25<<2 ;   //4个驱动方波输出周期       
  495.                   f0 = 1 'd0;                  //4个电平翻转状态   PFM1上升沿
  496.                        f1 = Ts*50;                 //PFM1 下降沿
  497.                        f2 = (1000000/f)*25<<1 ;            //PFM2上升沿
  498.                        f3= {(1000000/f)*25<<1}+Ts*50;    //PFM2 下降沿       
  499.                                  f4 =(1000000/f)*25;                  //PFM3上升沿
  500.                        f5 =(1000000/f)*25+Ts*50;                 //PFM3 下降沿
  501.                        f6 = {(1000000/f)*25<<1}+(1000000/f)*25;  //PFM4上升沿                                                                                  
  502.                        f7 = {(1000000/f)*25<<1}+{(1000000/f)*25}+Ts*50;   //PFM4 下降沿       
  503.                   f8 = Ts*50-(1000000/f)*25;
  504.                 end
  505.                
  506.                  always@(  posedge sclk ) begin                                 //波形输出期间,禁止关断
  507.               if( Fout1 || Fout2 )
  508.                                       f_cs1 <= 1'd1 ;
  509.                                   else f_cs1 <=f_en1 ;       
  510.                                   if( Fout3 || Fout4 )
  511.                                       f_cs2 <= 1'd1 ;
  512.                                   else f_cs2 <=f_en2 ;       
  513.                                  
  514.                  end

  515.        always@( posedge sclk or posedge f_cs1 or posedge f_cs2 ) begin         //通道1 2循环
  516.            if( f_cs1 || f_cs2 )  begin           //使能
  517.                              f_cnt <= f_cnt+1;                             
  518.                    if( f_cnt>=f_cnt3 )     //循环复位
  519.                                      f_cnt <= 0;
  520.                                 end
  521.                                 else f_cnt <= 0;
  522.        end                                                  

  523.                  
  524.                  always@( posedge sclk or posedge f_cs1 or posedge f_cs2) begin                 
  525.                      if        ( f_cs1 ) begin                
  526.                                 if(f_cnt==f0)begin
  527.                                               Fout1 <= 1'b1;
  528.                                                         //     Fout2 <= 1'b0;                                                                                          
  529.                                                                   
  530.                                                 end
  531.                                 if(f_cnt==f1)begin
  532.                                               Fout1 <= 1'b0;
  533.                                                          //    Fout2 <= 1'b0;
  534.                                                 end
  535.                                 if(f_cnt==f2)begin
  536.                                           //    Fout1 <= 1'b0;
  537.                                                              Fout2 <= 1'b1;                
  538.                                                 end
  539.                                 if(f_cnt==f3)begin
  540.                                           //    Fout1 <= 1'b0;
  541.                                                              Fout2 <= 1'b0;
  542.                                                 end       
  543.                         end
  544.                    else begin
  545.                               Fout1 <= 1'b0;
  546.                                         Fout2 <= 1'b0;
  547.                    end        
  548.                        
  549.          if        ( f_cs2 ) begin
  550.                        
  551.                                 if(f_cnt==f4)begin
  552.                                               Fout3 <= 1'b1;
  553.                                                                                                                                                  
  554.                                                                   
  555.                                                 end
  556.                                 if(f_cnt==f5)begin
  557.                                               Fout3 <= 1'b0;
  558.                                                          
  559.                                                 end
  560.                                 if(f_cnt==f6)begin
  561.                                           
  562.                                                              Fout4 <= 1'b1;                
  563.                                                 end
  564.                                 if(f_cnt==f7)begin
  565.                                           
  566.                                                              Fout4 <= 1'b0;
  567.                                                 end       
  568.                                                
  569.                                 if(f_cnt1>=f_cnt2)        begin       
  570.                                  if(f_cnt==f8)begin
  571.                                         
  572.                                                              Fout4 <= 1'b0;
  573.                                                 end       
  574.                                 end       
  575.                         end
  576.                    else begin
  577.                               Fout3 <= 1'b0;
  578.                                         Fout4 <= 1'b0;
  579.                    end
  580.                        

  581.           end
  582.          
  583.                        
  584. endmodule、

  585. */
  586. /*
  587. module PFMc ( sclk, f_en1,f_en2,f_i,Ts_i,Fout1, Fout2 ,Fout3, Fout4);
  588.         
  589.                  input  sclk ;  //晶振50M   20ns      
  590.                  input  f_en1;   //波形输出封锁信号 0封锁输出
  591.                  input  f_en2;   //波形输出封锁信号 0封锁输出
  592.                  input [18:1] f_i;     //PWM频率 Hz 最小1HZ,最大40K
  593.                  input [6:1]Ts_i;     //PWM周期 us 最大25
  594.                  
  595.                  output  reg Fout1 = 1'b0 ;  //通道1PWM输出
  596.                  output  reg Fout2 = 1'b0 ;
  597.        output  reg Fout3 = 1'b0 ;  //通道2PWM输出
  598.                  output  reg Fout4 = 1'b0 ;

  599.        reg  f_cs1 = 1'd0;   //通道1波形使能
  600.                  reg  f_cs2 = 1'd0;   //通道2波形使能
  601.                  reg  [28:1] f_cnt = 0 ;
  602.                  reg  [12:1] f_cnt1 = 0 ; //Ts高电平计数个数
  603.                  reg  [26:1] f_cnt2 = 250 ; //Ts 低电平计数个数
  604.                  reg  [26:1] f_cnt3 ;
  605.                  reg  f0 = 1'd0;
  606.                  reg  [12:1] f1=0;
  607.                  reg  [27:1] f2=0,f3=0;
  608.                  reg  [28:1] f4=0,f5=0;
  609.                  reg  [28:1] f6=0,f7=0;
  610.                  reg  [12:1] f8=0;   
  611.                  reg  [4:1]  state;    //状态指示
  612.                  reg  spr=1'b0; //参数计算完成指示
  613.                  reg [18:1] f_ib;     //PWM频率 Hz 最小1HZ,最大40K 缓存
  614.                  reg [6:1]Ts_ib;     //PWM周期 us 最大25  缓存
  615.                  reg [18:1] f=40000;     //PWM频率 Hz 最小1HZ,最大40K 缓存
  616.                  reg [6:1]Ts=0;     //PWM周期 us 最大25  缓存
  617.                  
  618.                  parameter
  619.                     Fout1_start = 4'd0,
  620.                          Fout2_start = 4'd1,
  621.                          Fout1_end   = 4'd2,
  622.                          Fout2_end   = 4'd3,
  623.                          Fout3_start = 4'd4,
  624.                          Fout4_start = 4'd5,
  625.                          Fout3_end   = 4'd6,
  626.                          Fout4_end   = 4'd7,
  627.                          Fout_clear = 4'd8;

  628.            always @( Ts or f ) begin       //参数设置改变后,对参数初始化
  629.                
  630.                             f_cnt1 = Ts*50 ; //(Ts*1000)/20; //Ts高电平计数个数
  631.                        f_cnt2 = (1000000/f)*25; //对应1/2  f个周期计数个数
  632.                                  f_cnt3 = (1000000/f)*25<<2 ;   //4个驱动方波输出周期       
  633.                   f0 = 1 'd0;                  //4个电平翻转状态   PFM1上升沿
  634.                        f1 = Ts*50;                 //PFM1 下降沿
  635.                        f2 = (1000000/f)*25<<1 ;            //PFM2上升沿
  636.                        f3= {(1000000/f)*25<<1}+Ts*50;    //PFM2 下降沿       
  637.                                  f4 =(1000000/f)*25;                  //PFM3上升沿
  638.                        f5 =(1000000/f)*25+Ts*50;                 //PFM3 下降沿
  639.                        f6 = {(1000000/f)*25<<1}+(1000000/f)*25;  //PFM4上升沿                                                                                  
  640.                        f7 = {(1000000/f)*25<<1}+{(1000000/f)*25}+Ts*50;   //PFM4 下降沿       
  641.                   f8 = Ts*50-(1000000/f)*25;
  642.                 end
  643.                                  
  644.                  
  645.                  
  646.                  always@(  f_en1 or f_en2) begin           //波形输出期间,禁止关断
  647.               if( Fout1 || Fout2 )
  648.                                       f_cs1 <= 1'd1 ;
  649.                                   else f_cs1 <=f_en1 ;       
  650.                                   if( Fout3 || Fout4 )
  651.                                       f_cs2 <= 1'd1 ;
  652.                                   else f_cs2 <=f_en2 ;       
  653.             end

  654.            always@( f_cnt  ) begin         
  655.            if( f_cnt )  begin           
  656.                              f_ib  =  f_i;
  657.                                   Ts_ib =  Ts_i;
  658.                           end
  659.                           if( (f_cnt+1)== f_cnt3)  begin           
  660.                              f  =  f_ib;
  661.                                   Ts =  Ts_ib;
  662.                           end
  663.                          
  664.                 end
  665.                
  666.                 always@( posedge sclk  ) begin         //通道1 2循环
  667.            if( f_cs1 || f_cs2 )  begin           //使能
  668.                              f_cnt <= f_cnt+1;
  669.               spr <= ~spr;                             
  670.                    if( f_cnt>=f_cnt3 )     //循环复位
  671.                                      f_cnt <= 0;
  672.                                 end
  673.                                 else f_cnt <= 0;
  674.                 end
  675.                
  676.                 always@( posedge sclk  ) begin                                          
  677.                         if        ( f_cs1 ) begin                
  678.                                 if(f_cnt==f0)begin
  679.                                           state <= Fout1_start;
  680.                                                 end
  681.                                 if(f_cnt==f1)begin
  682.                                           state <= Fout2_start;
  683.                                                          //    Fout2 <= 1'b0;
  684.                                                 end
  685.                                 if(f_cnt==f2)begin
  686.                                           //    Fout1 <= 1'b0;
  687.                                                           state <= Fout1_end;                
  688.                                                 end
  689.                                 if(f_cnt==f3)begin
  690.                                           //    Fout1 <= 1'b0;
  691.                                                           state <= Fout2_end;
  692.                                                 end       
  693.                         end
  694.                    else  state <= Fout_clear;
  695.                        
  696.          if        ( f_cs2 ) begin
  697.                        
  698.                                 if(f_cnt==f4)begin
  699.                                            state <= Fout3_start;;
  700.                                                                                                                                                  
  701.                                                                   
  702.                                                 end
  703.                                 if(f_cnt==f5)begin
  704.                                           state <= Fout4_start;;
  705.                                                          
  706.                                                 end
  707.                                 if(f_cnt==f6)begin
  708.                                           
  709.                                                           state <= Fout3_end;                
  710.                                                 end
  711.                                 if(f_cnt==f7)begin
  712.                                           
  713.                                                           state <= Fout4_end;
  714.                                                 end       
  715.                                                
  716.                                 if(f_cnt1>=f_cnt2)        begin       
  717.                                  if(f_cnt==f8)begin
  718.                                         
  719.                                                           state <= Fout4_end;
  720.                                                 end       
  721.                                 end       
  722.                         end
  723.                    else state <= Fout_clear;
  724.            end
  725.          
  726.          always@(  state  ) begin
  727.               case (state)
  728.                            Fout1_start: begin
  729.                                                 Fout1 = 1'b1;
  730.                                                                          Fout2 = 1'b0;
  731.                                                                  end
  732.                                 Fout2_start: begin
  733.                                                 Fout2 = 1'b1;
  734.                                                                          Fout1 = 1'b1;
  735.                                                                  end
  736.                            Fout3_start: begin
  737.                                                 Fout3 = 1'b1;
  738.                                                                          Fout4 = 1'b0;
  739.                                                                  end
  740.                                 Fout4_start: begin
  741.                                                 Fout4 = 1'b1;
  742.                                                                          Fout3 = 1'b0;
  743.                                                                  end
  744.                                 Fout1_end  : begin
  745.                                                 Fout1 = 1'b0;
  746.                                                                          Fout2 = 1'b1;
  747.                                                                  end
  748.                                 Fout2_end  : begin
  749.                                                 Fout2 = 1'b0;
  750.                                                                          Fout1 = 1'b0;
  751.                                                                  end
  752.                                 Fout3_end  : begin
  753.                                                 Fout3 = 1'b0;
  754.                                                                          Fout4 = 1'b1;
  755.                                                                  end
  756.                                 Fout4_end  : begin
  757.                                                 Fout3 = 1'b0;
  758.                                                                          Fout4 = 1'b0;
  759.                                                                  end
  760.                                 Fout_clear : begin
  761.                                                  Fout1 = 1'b0;
  762.                                                  Fout2 = 1'b0;
  763.                                                  Fout1 = 1'b0;
  764.                                                  Fout1 = 1'b0;
  765.                                                                  end
  766.                                 default begin
  767.                                             Fout1 = 1'b0;
  768.                                             Fout2 = 1'b0;
  769.                                             Fout1 = 1'b0;
  770.                                             Fout1 = 1'b0;
  771.                                                   end
  772.                   endcase
  773.          end
  774. endmodule
  775. */
复制代码


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表