• ZYNQ_project:key_beep

    通过按键控制蜂鸣器工作。

    模块框图：

    时序图：

     

    代码：

    1. /*
    2.     1位按键消抖
    3. */ 
    4. module key_filter (
    5.     input       wire            sys_clk     ,
    6.     input       wire            sys_rst_n   ,
    7.     input       wire            key_in      ,
    8.  
    9.     output      reg             key_flag    
    10. );
    11.     // 参数定义
    12.     parameter   MAX_CNT_10MS = 500_000  ;
    13.     localparam  IDLE        = 4'b0001   ,
    14.                 FILTER_UP   = 4'b0010   ,
    15.                 SAMPLING    = 4'b0100   ,
    16.                 FILTER_BACK = 4'b1000   ;
    17.     // reg signal define 
    18.     reg                 key_in_r1 ;  
    19.     reg                 key_in_r2 ;
    20.     reg     [18:0]      cnt_core  ;
    21.     reg     [3:0]       state_c   ;
    22.     reg     [3:0]       state_n   ;
    23.     // wire signal define 
    24.     wire                nege      ;
    25.     wire                pose      ;
    26.     wire                IDLEtoFILTER_UP       ;
    27.     wire                FILTER_UPtoIDLE       ;
    28.     wire                FILTER_UPtoSAMPLING   ;
    29.     wire                SAMPLINGtoFILTER_BACK ;
    30.     wire                FILTER_BACKtoIDLE     ;
    31.     wire                filter_done           ; 
    32.     /******************************************************************/
    33.     // reg                 key_in_r1 ; 
    34.     always @(posedge sys_clk or negedge sys_rst_n) begin
    35.         if(~sys_rst_n) 
    36.             key_in_r1 <= 1'b1 ;
    37.         else
    38.             key_in_r1 <= key_in ;
    39.     end 
    40.     // reg                 key_in_r2 ;
    41.     always @(posedge sys_clk or negedge sys_rst_n) begin
    42.         if(~sys_rst_n) 
    43.             key_in_r2 <= 1'b1 ;
    44.         else
    45.             key_in_r2 <= key_in_r1 ;
    46.     end 
    47.     // wire                nege      ;
    48.     assign  nege = ~key_in_r1 &&  key_in_r2 ;
    49.     // wire                pose      ;  
    50.     assign  pose =  key_in_r1 && ~key_in_r2 ;
    51.     // reg     [3:0]       state_c   ;
    52.     always @(posedge sys_clk or negedge sys_rst_n) begin
    53.         if(~sys_rst_n) 
    54.             state_c <= IDLE ;
    55.         else
    56.             state_c <= state_n ;
    57.     end
    58.     // reg     [3:0]       state_n   ;
    59.     always @(*) begin
    60.         case(state_c)
    61.         IDLE      : if(IDLEtoFILTER_UP)
    62.                         state_n = FILTER_UP ;
    63.                     else 
    64.                         state_n = IDLE ;
    65.         FILTER_UP : if(FILTER_UPtoIDLE)
    66.                         state_n = IDLE ;
    67.                     else if(FILTER_UPtoSAMPLING)
    68.                         state_n = SAMPLING ;
    69.                     else 
    70.                         state_n = FILTER_UP ;
    71.         SAMPLING  : if(SAMPLINGtoFILTER_BACK)
    72.                         state_n = FILTER_BACK ;
    73.                     else 
    74.                         state_n = SAMPLING ;
    75.         FILTER_BACK:if(FILTER_BACKtoIDLE)
    76.                         state_n = IDLE ;
    77.                     else
    78.                         state_n = FILTER_BACK ;
    79.         default   :     state_n = IDLE ;
    80.         endcase
    81.     end
    82.     assign  IDLEtoFILTER_UP         = (state_c == IDLE)       && (nege) ;
    83.     assign  FILTER_UPtoIDLE         = (state_c == FILTER_UP)  && (pose) ;
    84.     assign  FILTER_UPtoSAMPLING     = (state_c == FILTER_UP)  && (filter_done) ;
    85.     assign  SAMPLINGtoFILTER_BACK   = (state_c == SAMPLING)   && (pose) ;
    86.     assign  FILTER_BACKtoIDLE       = (state_c == FILTER_BACK)&& (filter_done) ;
    87.     // reg     [18:0]      cnt_core  ;
    88.     always @(posedge sys_clk or negedge sys_rst_n) begin
    89.         if(~sys_rst_n) 
    90.             cnt_core <= 19'd0 ;
    91.         else
    92.         case (state_c)
    93.         IDLE       :cnt_core <= 19'd0 ; 
    94.         FILTER_UP  :if(filter_done)
    95.                         cnt_core <= 19'd0 ;
    96.                     else 
    97.                         cnt_core <= cnt_core + 1'b1 ;
    98.         SAMPLING   :cnt_core <= 19'd0 ; 
    99.         FILTER_BACK:if(filter_done)
    100.                         cnt_core <= 19'd0 ;
    101.                     else 
    102.                         cnt_core <= cnt_core + 1'b1 ;
    103.         default    :    cnt_core <= 19'd0 ;
    104.         endcase
    105.     end
    106.     // wire                filter_done
    107.     assign  filter_done = (cnt_core == MAX_CNT_10MS - 1) ;
    108.     // output reg key_flag
    109.     always @(posedge sys_clk or negedge sys_rst_n) begin
    110.         if(~sys_rst_n) 
    111.             key_flag <= 1'b0 ;
    112.         else if(FILTER_UPtoSAMPLING)
    113.             key_flag <= ~key_in_r2 ;
    114.         else 
    115.             key_flag <= 1'b0 ;
    116.     end
    117.  
    118. endmodule

    1. /*
    2.     蜂鸣器驱动模块，NPN三极管，beep_en == 1 鸣叫。有源电磁式。
    3.     1， 初始状态鸣叫，按键每按下一次，蜂鸣器状态翻转。
    4.     2.  初始状态蜂鸣器工作，响100ms , 不响100ms, 响100ms, 不响300ms.按键每按下一次，蜂鸣器工作状态翻转。
    5. */ 
    6. module beep (
    7.     input       wire            sys_clk     ,
    8.     input       wire            sys_rst_n   ,
    9.     input       wire            key_flag    ,
    10.  
    11.     output      reg             beep_en     
    12. );
    13.     // // output reg beep_en
    14.     // always @(posedge sys_clk or negedge sys_rst_n) begin
    15.     //     if(~sys_rst_n) 
    16.     //         beep_en <= 1'b1 ;
    17.     //     else if(key_flag)
    18.     //         beep_en <= ~beep_en ;
    19.     // end
    21.     // parameter
    22.     parameter   MAX_CNT_100MS = 5_000_000  ,
    23.                 MAX_CNT_300MS = 15_000_000 ;
    24.     localparam  RING          = 3'b001     ,
    25.                 NO_RING_MOD1  = 3'b010     ,
    26.                 NO_RING_MOD2  = 3'b100     ;
    27.     // reg signal define
    28.     reg                 beep_work ;
    29.     reg     [23:0]      cnt_core  ;
    30.     reg     [2:0]       state_c   ;
    31.     reg     [2:0]       state_n   ;
    32.     reg                 mod1_flag ;
    33.     // wire signal define
    34.     wire                RINGtoNO_RING_MOD1 ;
    35.     wire                RINGtoNO_RING_MOD2 ;
    36.     wire                NO_RING_MOD1toRING ;
    37.     wire                NO_RING_MOD2toRING ;
    38.     wire                no_ring_done       ;
    39.     /*****************************************************/
    40.     // reg                 beep_work ;
    41.     always @(posedge sys_clk or negedge sys_rst_n) begin
    42.         if(~sys_rst_n) 
    43.             beep_work <= 1'b1 ;
    44.         else if(key_flag)
    45.             beep_work <= ~beep_work ;
    46.         else 
    47.             beep_work <= beep_work ;
    48.     end
    49.     // reg     [2:0]       state_c   ;
    50.     always @(posedge sys_clk or negedge sys_rst_n) begin
    51.         if(~sys_rst_n) 
    52.             state_c <= RING ;
    53.         else 
    54.             state_c <= state_n ;
    55.     end
    56.     // reg     [2:0]       state_n   ;
    57.     always @(*) begin
    58.         if(beep_work) begin
    59.             case(state_c)
    60.             RING        :   if(RINGtoNO_RING_MOD1)
    61.                                 state_n = NO_RING_MOD1 ;
    62.                             else if(RINGtoNO_RING_MOD2)
    63.                                 state_n = NO_RING_MOD2 ;
    64.                             else
    65.                                 state_n = RING ;
    66.             NO_RING_MOD1:   if(NO_RING_MOD1toRING)
    67.                                 state_n = RING ;
    68.                             else 
    69.                                 state_n = NO_RING_MOD1 ;
    70.             NO_RING_MOD2:   if(NO_RING_MOD2toRING)
    71.                                 state_n = RING ;
    72.                             else 
    73.                                 state_n = NO_RING_MOD2 ;
    74.             default     :       state_n = RING ;
    75.             endcase
    76.             end
    77.         else
    78.             state_n = RING ;
    79.     end
    80.     assign  RINGtoNO_RING_MOD1 = (state_c == RING)         && (no_ring_done && (mod1_flag))    ;
    81.     assign  RINGtoNO_RING_MOD2 = (state_c == RING)         && (no_ring_done && (!mod1_flag))   ;
    82.     assign  NO_RING_MOD1toRING = (state_c == NO_RING_MOD1) && (no_ring_done) ;
    83.     assign  NO_RING_MOD2toRING = (state_c == NO_RING_MOD2) && (no_ring_done) ;
    84.     // reg     [23:0]      cnt_core  ;
    85.     always @(posedge sys_clk or negedge sys_rst_n) begin
    86.         if(~sys_rst_n) 
    87.             cnt_core <= 24'd0 ;
    88.         else
    89.         if(beep_work) begin
    90.             case (state_c)
    91.             RING        :   if(no_ring_done)
    92.                                 cnt_core <= 24'd0 ;
    93.                             else 
    94.                                 cnt_core <= cnt_core + 1'b1 ; 
    95.             NO_RING_MOD1:   if(no_ring_done)
    96.                                 cnt_core <= 24'd0 ;
    97.                             else 
    98.                                 cnt_core <= cnt_core + 1'b1 ; 
    99.             NO_RING_MOD2:   if(no_ring_done)
    100.                                 cnt_core <= 24'd0 ;
    101.                             else 
    102.                                 cnt_core <= cnt_core + 1'b1 ;  
    103.             default     :   cnt_core <= 24'd0 ;
    104.             endcase
    105.         end
    106.         else 
    107.             cnt_core <= 24'd0 ;
    108.     end
    109.     // reg                 mod1_flag ;
    110.     always @(posedge sys_clk or negedge sys_rst_n) begin
    111.         if(~sys_rst_n) 
    112.             mod1_flag <= 1'b1 ;
    113.         else if(beep_work) begin
    114.             if((state_c != RING) && (no_ring_done))
    115.                 mod1_flag <= ~mod1_flag ;
    116.             else 
    117.                 mod1_flag <= mod1_flag ;
    118.             end
    119.         else 
    120.             mod1_flag <= 1'b1 ;
    121.     end
    122.     // wire                no_ring_done;
    123.     assign  no_ring_done = (((state_c != NO_RING_MOD2)&&(cnt_core == MAX_CNT_100MS - 1))||((state_c == NO_RING_MOD2)&&(cnt_core == MAX_CNT_300MS - 1))) ? 1'b1 : 1'b0 ;
    124.     // output reg beep_en
    125.     always @(posedge sys_clk or negedge sys_rst_n) begin
    126.         if(~sys_rst_n) 
    127.             beep_en <= 1'b1 ;
    128.         else if(beep_work) begin
    129.             if(state_c == RING)
    130.                 beep_en <= 1'b1 ;
    131.             else 
    132.                 beep_en <= 1'b0 ;
    133.         end
    134.         else 
    135.             beep_en <= 1'b0 ; 
    136.     end
    137.  
    138. endmodule

    1. module top(
    2.     input       wire            sys_clk     ,
    3.     input       wire            sys_rst_n   ,
    4.     input       wire            key_in      ,
    5.  
    6.     output      wire            beep        
    7. );
    8.     // 例化间连线
    9.     wire        key_flag ;
    10. key_filter key_filter_inst(
    11.     .sys_clk                ( sys_clk   ) ,
    12.     .sys_rst_n              ( sys_rst_n ) ,
    13.     .key_in                 ( key_in    ) ,
    14.  
    15.     .key_flag               ( key_flag  )  
    16. );
    17.  
    18. beep beep_inst(
    19.     .sys_clk                ( sys_clk   ) ,
    20.     .sys_rst_n              ( sys_rst_n ) ,
    21.     .key_flag               ( key_flag  ) ,
    22.  
    23.     .beep_en                ( beep      )  
    24. );
    25.  
    26. endmodule

    1. `timescale 1ns/1ns
    2. module test_top();
    3.     reg            sys_clk     ;
    4.     reg            sys_rst_n   ;
    5.     reg            key_in      ;
    6.  
    7.     wire           beep        ;
    8.  
    9. top top_inst(
    10.     .sys_clk        ( sys_clk   ) ,
    11.     .sys_rst_n      ( sys_rst_n ) ,
    12.     .key_in         ( key_in    ) ,
    13.  
    14.     .beep           ( beep      )  
    15. );
    16.  
    17.     parameter   CYCLE = 20 ;
    18.     defparam    top_inst.key_filter_inst.MAX_CNT_10MS = 50 ;
    19.     defparam    top_inst.beep_inst.MAX_CNT_100MS = 500  ;
    20.     defparam    top_inst.beep_inst.MAX_CNT_300MS = 1500 ;
    21.  
    22.     initial begin
    23.         sys_clk    = 1'b1 ;
    24.         sys_rst_n <= 1'b0 ;
    25.         key_in    <= 1'b1 ;
    26.         #( CYCLE * 10 )   ;
    27.         sys_rst_n <= 1'b1 ;
    28.         #( CYCLE * 10 )   ;
    29.  
    30.         #( CYCLE * 3000 ) ;
    31.         #( CYCLE * 500  ) ; // 检测蜂鸣器状态机是否正常工作。
    32.         
    33.         key_in    <= 1'b0 ;
    34.         #( CYCLE * 50 * 3 ); // 按下足够长的时间，第一次按键按下。
    35.         key_in    <= 1'b1 ;
    36.         #( CYCLE * 3000 ) ;
    37.         #( CYCLE * 500  ) ; // 检测蜂鸣器状态机是否正常工作。
    38.  
    39.         key_in    <= 1'b0 ;
    40.         #( CYCLE * 50 * 3 ); // 按下足够长的时间，第二次按键按下。
    41.         key_in    <= 1'b1 ;
    42.         #( CYCLE * 3000 ) ;
    43.         #( CYCLE * 500  ) ; // 检测蜂鸣器状态机是否正常工作。
    44.  
    45.         $stop             ;
    46.     end
    47.  
    48.     always #( CYCLE / 2 ) sys_clk = ~sys_clk ;
    49.  
    50.  
    51. endmodule

    仿真：

  • 相关阅读:
    互联网摸鱼日报(2023-09-22)
    你不应该依赖CSS 100vh，这就是原因
    安利几个堪称黑科技的电脑软件
    FreeSWITCH入门到精通系列（三）：FreeSWITCH基础概念与架构
    NLP模型（二）——GloVe介绍
    Bootstrap框架
    PCIe设备的枚举过程
    晶振的等效电路模型
    吐槽 B 站收费，是怪它没钱么？
    导航集成测试
  • 原文地址：https://blog.csdn.net/Meng_long2022/article/details/134296220