FPGA

求助fpga用复位按键复位偶尔出现复位不成功，在仿真中复位没有任何问题

2019-07-15 21:10发布

站内问答 / FPGA
3142 4 955
  1. `timescale 1ns / 1ps
  2. //////////////////////////////////////////////////////////////////////////////////
  3. // Company:
  4. // Engineer:
  5. //
  6. // Create Date:    13:38:11 11/09/2017
  7. // Design Name:
  8. // Module Name:    auto_lock
  9. // Project Name:
  10. // Target Devices:
  11. // Tool versions:
  12. // Description:
  13. //
  14. // Dependencies:
  15. //
  16. // Revision:
  17. // Revision 0.01 - File Created
  18. // Additional Comments:
  19. //
  20. //////////////////////////////////////////////////////////////////////////////////
  21. module auto_lock(

  23.                         input clk,                                //系统时钟
  24.                         input rst_n,                        //系统复位
  25.                         input lock_signal,        //失锁锁定输入
  26.                                                
  27.                         output reg analog_switch_1,        //模拟开关1输出
  28.                         output reg analog_switch_2,        //模拟开关2输出
  29.                         output reg [13:0] dac_ch1,                //温度dac
  30.                        
  31. //                        input sawtooth_frequence,                //锯齿波频率
  32.                         output reg sawtooth_control,        //锯齿波控制
  33.        
  34.                         input signed [15:0]adc_ch1_data,        //adc ch1电压值

  36.                         //按键输入
  37.                         input key1_in,
  38.                         input key2_in,
  39.                         input key3_in,
  40.                         input key4_in,

  42.                         //系统状态指示
  43.                         output lock_status_led,        //led
  44.                        
  45.                         //DEBUG数据
  46.                         output [23:0]debug_state_value,
  47.                         output [23:0]debug_pdh_ok_count_value
  48.     );
  49.          
  50.         parameter ON = 1'b1,OFF = 1'b0;
  51.         parameter LOCK = 1'b1,UNLOCK = 1'b0;
  52.         parameter START = 1'b1,END = 1'b0;
  53.          
  54. //        parameter T100MS = 32'd49_999_99;
  55. //        parameter T1S = 32'd49_999_999;

  57.         parameter T100MS = 32'd49;
  58.         parameter T1S = 32'd49_9;
  59.         parameter T2S = 8'd2;
  60.         parameter T5S = 8'd5;       
  61.         parameter T10S = 8'd10;
  62.         parameter T20S = 8'd20;       
  63.        
  64.         //temperture search zero point
  65.         //parameter EXPERIENCE = 14'd8540;        //经验值
  66.        
  67.         assign debug_state_value = auto_lock_state;
  68.         assign debug_pdh_ok_count_value = pdh_ok_count;

  70.         /**********************按键模块*************************/
  71.         keys keys_model(
  72.        
  73.                         .clk        (clk),                                //系统时钟
  74.                         .rst_n        (rst_n),                        //系统复位

  76.                         //按键输入
  77.                         .key1_in  (key1_in),
  78.                         .key2_in  (key2_in),
  79.                         .key3_in  (key3_in),
  80.                         .key4_in  (key4_in),
  81.                        
  82.                         //按键输出
  83.                         .key1_scan  (key1_scan),
  84.                         .key2_scan  (key2_scan),
  85.                         .key3_scan  (key3_scan),
  86.                         .key4_scan  (key4_scan)               
  87.          );


  90.         /***********************锁定信号触发边沿检测*************************/
  91.         lock_signal_edge_check lock_signal_edge_check_model(

  93.                         .clk        (clk),                                //系统时钟
  94.                         .rst_n        (rst_n),                        //系统复位
  95.                
  96.                         .lock_signal(lock_signal),
  97.                         .locked        (locked),
  98.                         .pdh_ok        (pdh_ok),
  99.                         .lock_status_led        (lock_status_led)
  100.     );
  101.        
  102.         /***********************系统运行*************************/
  103.         reg[7:0] pdh_ok_count;
  104.         parameter pdh_ok_count_N_INIT = 8'd3;
  105.         reg[7:0] pdh_ok_count_N;
  106.         reg[31:0] pdh_time_count;
  107.         parameter pdh_time_INIT = 32'd999_999;
  108.         reg[31:0] pdh_time;        //在锯齿波为1Hz延时为20ms 频率越高锁定时间越短
  109.         reg pdh_ok_delay_flag;        //pdh延时标志
  110.        
  111.         reg [7:0]locked_fail_count;        //锁定失败计数
  112.        
  113.         reg [13:0]dac_to_temperature_i;
  114.         reg [13:0]dac_to_temperature_spare;//备份值
  115.        
  116.        
  117.         parameter init_N = 14'd8;        // N 的初始范围
  118.         reg [13:0]N;
  119.         parameter init_K = 14'd2;        //K 的初始值
  120.         reg [13:0]K;
  121.        
  122.         parameter init_DIR = 4'd1;        //扫描方向初始为正
  123.         reg [3:0]DIR;        //扫描方向
  124.        
  125.        
  126.        
  127.         reg [31:0]time_count;
  128.         reg [7:0]time_ones;       
  129.        
  130.         reg [7:0]auto_lock_state;
  131.         reg [7:0]system_run_task_state;
  132.        
  133.         reg key1buf,key2buf,key3buf,key4buf;

  135.        
  136.         always@(posedge clk)
  137.         begin
  138.                
  139.                 if(!rst_n)        //低电平复位
  140.                         begin
  141.                                 auto_lock_state<= 8'd0;
  142.                                
  143.                         end
  144.                 else
  145.                         begin
  146.                        
  147.                                   case (auto_lock_state)       
  148.                                                        
  149.                                                 8'd0:                        //初始化
  150.                                                         begin               
  151.        
  152.                                                                 dac_to_temperature_spare <= 14'd8192;        //0V
  153.                                                                 dac_to_temperature_i <= 14'd8192;        //0V
  154.                                                                 dac_ch1 <= dac_to_temperature_i;
  155.                                                                
  156.                                                                 analog_switch_1 <= OFF;
  157.                                                                 analog_switch_2 <= OFF;
  158.                                                                 sawtooth_control <= OFF;
  159.                                                                
  160.                                                                 time_count <= 0;
  161.                                                                 time_ones <= 0;
  162.                                                                
  163.                                                                 key1buf <= 2'd0;        
  164.                                                                 key2buf <= 2'd0;
  165.                                                                
  166.                                                                 auto_lock_state <= 8'd1;
  167.                                                         end
  168.                                   
  169.                                                 8'd1:                        //运行
  170.                                                         begin
  171.                                                                
  172.                                                                 dac_ch1 <= dac_to_temperature_i;       
  173.                
  174.                                                                 //系统预热20s
  175.                                                                 if(time_count == T1S)        //1s
  176.                                                                         begin
  177.                                                                                 time_ones <= time_ones + 1'b1;
  178.                                                                                
  179.                                                                                 if(time_ones == T20S)        //20s
  180.                                                                                         begin       
  181.                                                                                                 //进入正常运行模式
  182.                                                                                                 dac_to_temperature_spare <= dac_to_temperature_i;
  183.                                                                                                 time_ones <= 0;
  184.                                                                                                 time_count <= 0;
  185.                                                                                                 system_run_task_state <= 8'd0;
  186.                                                                                                 auto_lock_state <= 8'd3;
  187.                                                                                         end
  188.                                                                                 else
  189.                                                                                         time_count <= 0;
  190.                                                                         end
  191.                                                                 else
  192.                                                                         begin
  193.                                                                                 time_count <= time_count + 1'b1;
  194.                                                                                
  195.                                                                                 //按键按下进行快速搜索
  196.                                                                                 key3buf <= key3_scan;                               
  197.                                                                                 if({key3buf,key3_scan} == 2'b10)
  198.                                                                                         begin
  199.                                                                                                 time_ones <= 0;
  200.                                                                                                 time_count <= 0;
  201.                                                                                                 auto_lock_state <= 8'd2;
  202.                                                                                         end
  203.                                                                         end       
  204.                                                                                
  205.                                                         end
  206.                                                
  207.                                                 8'd2:                        //快速搜索
  208.                                                         begin
  209.                                                        
  210.                                                                 fast_search_task();

  212.                                                         end
  213.                                                        
  214.                                                 8'd3:
  215.                                                         begin                //模块运行
  216.                                                                        
  217.                                                                 system_run_task();
  218.                                                                        
  219.                                                         end
  220.                                                
  221.                                                 default:
  222.                                                                 auto_lock_state <= 8'd0;                                               
  223.                                        
  224.                                         endcase
  225.                                 end
  226.         end         
  227.        
  228.        
  229.                                
  230.         //快速搜索模块的任务
  231.         task fast_search_task();
  232.        
  233.                 begin
  234.                
  235.                         key1buf <= key1_scan;                               
  236.                         if({key1buf,key1_scan} == 2'b10 && dac_to_temperature_i < 14'd16373)        //下降沿
  237.                                 begin
  238.                                         dac_to_temperature_i <= dac_to_temperature_i + 10;       
  239.                                         dac_ch1 <= dac_to_temperature_i;       
  240.                                 end

  242.                         key2buf <= key2_scan;                               
  243.                         if({key2buf,key2_scan} == 2'b10 && dac_to_temperature_i > 14'd10)        //下降沿
  244.                                 begin
  245.                                         dac_to_temperature_i <= dac_to_temperature_i - 10;       
  246.                                         dac_ch1 <= dac_to_temperature_i;       
  247.                                 end
  248.                        
  249.                         //模块运行
  250.                         key4buf <= key4_scan;                               
  251.                         if({key4buf,key4_scan} == 2'b10)
  252.                                 begin
  253.                                         dac_to_temperature_spare <= dac_to_temperature_i;
  254.                                         system_run_task_state <= 8'd0;
  255.                                         auto_lock_state <= 8'd3;
  256.                                 end                       
  257.                        
  258.                 end
  259.                
  260.         endtask

  262.         //系统运行任务
  263.         task system_run_task();
  264.                 begin
  265.                                 case(system_run_task_state)
  266.                                
  267.                                         8'd0:                        //初始化
  268.                                                 begin

  270.                                                                 time_count <= 0;
  271.                                                                 time_ones <= 0;
  272.                                                                
  273.                                                                 pdh_ok_count <= 8'd0;
  274.                                                                 pdh_ok_count_N <= 8'd3;
  275.                                                                
  276.                                                                 pdh_time <= pdh_time_INIT;

  278.                                                                 pdh_ok_delay_flag <= END;
  279.                                                                
  280.                                                                 locked_fail_count <= 8'd0;        //锁定失败计数
  281.                                                                
  282.                                                                 analog_switch_1 <= OFF;
  283.                                                                 analog_switch_2 <= OFF;
  284.                                                                 sawtooth_control <= OFF;       
  285.                                                                
  286.                                                                 system_run_task_state <= 8'd1;

  288.                                                 end
  289.        
  290.                                         8'd1:
  291.                                                 begin
  292.                                                         //init i = 0
  293.                                                         dac_to_temperature_i <= dac_to_temperature_spare;
  294.                                                         N <= init_N;
  295.                                                         K        <= init_K;               
  296.                                                         DIR <= init_DIR;        //init 扫描方向                                                       
  297.                                                        
  298.                                                         system_run_task_state <= 8'd2;
  299.                                                        
  300.                                                 end
  301.                                                
  302.                                         8'd2:
  303.                                                 begin
  304.                                                         //start pzt scanning
  305.                                                         analog_switch_1 <= OFF;
  306.                                                         analog_switch_2 <= ON;
  307.                                                        
  308.                                                         //开启锯齿波扫描
  309.                                                         sawtooth_control <= ON;       
  310.                                                        
  311.                                                         //T(i) = V * step * i;
  312.                                                         dac_ch1 <= dac_to_temperature_i;
  313.                                                         time_count <= 0;
  314.                                                         time_ones <= 0;
  315.                                                         system_run_task_state <= 8'd3;
  316.                                                 end
  317.                                        
  318.                                         8'd3:
  319.                                                 begin
  320.                                                         //wait 4 - 10s
  321.                                                         if(time_count == T1S)        //1s
  322.                                                                 begin
  323.                                                                         time_ones <= time_ones + 1'b1;
  324.                                                                        
  325.                                                                         if(time_ones == T2S)                //2s
  326.                                                                                 begin
  327.                                                                                         search_mode();        //扫描模式
  328.                                                                                         dac_ch1 <= dac_to_temperature_i;        //更新数据
  329.                                                                                         time_ones <= 0;
  330.                                                                                 end       
  331.                                                                                
  332.                                                                         time_count <= 0;
  333.                                                                 end
  334.                                                         else
  335.                                                                 begin
  336.                                                                         time_count <= time_count + 1'b1;
  337.                                                                        
  338.                                                                         //PDH OK?                        //判断是否找到信号
  339.                                                                         if(pdh_ok == LOCK)
  340.                                                                                         begin
  341.                                                                                                 pdh_ok_count <= pdh_ok_count + 1'b1;
  342.                                                                                                 pdh_ok_delay_flag <= START;        //开始延时
  343.                                                                                                 time_count <= 0;
  344.                                                                                                 time_ones <= 0;
  345.                                                                                                 pdh_time_count <= 0;
  346.                                                                                                 system_run_task_state <= 8'd4;
  347.                                                                                         end
  348.                                                                 end
  349.                                                 end
  350.                                                

  352.                                         8'd4:        //PDH OK Yes
  353.                                                 begin
  354.                                                
  355.                                                         //锯齿波扫描延长2S
  356.                                                         if(time_count == T1S)        //1s
  357.                                                                 begin
  358.                                                                         time_ones <= time_ones + 1'b1;
  359.                                                                        
  360.                                                                                 if(time_ones == T2S)        //2s
  361.                                                                                         begin
  362.                                                                                                
  363.                                                                                                 if(pdh_ok_count >= pdh_ok_count_N )        //真信号
  364.                                                                                                                 begin
  365.                                                                                                                         //pdh_ok_count <= 8'd0;
  366.                                                                                                                         pdh_time_count <= 0;
  367.                                                                                                                         system_run_task_state <= 8'd5;        //搜索到pdh
  368.                                                                                                                 end
  369.                                                                                                 else
  370.                                                                                                                 begin
  371.                                                                                                                         system_run_task_state <= 8
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
4条回答
whyil
2019-07-16 06:06
zhy_fpga 发表于 2017-12-24 17:45
你好，你所使用的复位类型是同步复位，同步复位信号RST必须至少长于一个时钟周期CLK，否则，这个复位信号引起的变化是不会被检测到的

不是这个问题，我rst保持了很长时间，我前仿真没有问题，但我后仿真出了很多问题，现在我不清楚该咋弄

一周热门 更多>