状态机的练习：按键控制led灯

设计思路：

三个按键控制led输出。

三个按键经过滤波(消抖)，产生三个按键标志信号。

三个led数据的产生模块（流水，跑马，闪烁模块），分别产生led信号。

这六路信号（三路按键信号，三路led信号），接入state_led_ctrl模块，进行led_out的控制。

状态机：

 

模块框图：

代码：

/*
    1位按键消抖
*/ 
module key_filter (
    input       wire            sys_clk     ,
    input       wire            sys_rst_n   ,
    input       wire            key_in      ,

    output      reg             key_flag    
);
    // 参数定义
    parameter   MAX_CNT_10MS = 500_000   ;
    localparam  IDLE         = 4'b0001   ,
                FILTER_UP    = 4'b0010   ,
                SAMPLING     = 4'b0100   ,
                FILTER_BACK  = 4'b1000   ;
    // reg signal define 
    reg                 key_in_r1 ;  
    reg                 key_in_r2 ;
    reg     [18:0]      cnt_core  ;
    reg     [3:0]       state_c   ;
    reg     [3:0]       state_n   ;
    // wire signal define 
    wire                nege                  ;
    wire                pose                  ;
    wire                IDLEtoFILTER_UP       ;
    wire                FILTER_UPtoIDLE       ;
    wire                FILTER_UPtoSAMPLING   ;
    wire                SAMPLINGtoFILTER_BACK ;
    wire                FILTER_BACKtoIDLE     ;
    wire                filter_done           ; 
    /******************************************************************/
    // reg                 key_in_r1 ; 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            key_in_r1 <= 1'b1 ;
        else
            key_in_r1 <= key_in ;
    end 
    // reg                 key_in_r2 ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            key_in_r2 <= 1'b1 ;
        else
            key_in_r2 <= key_in_r1 ;
    end 
    // wire                nege      ;
    assign  nege = ~key_in_r1 &&  key_in_r2 ;
    // wire                pose      ;  
    assign  pose =  key_in_r1 && ~key_in_r2 ;
    // reg     [3:0]       state_c   ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            state_c <= IDLE ;
        else
            state_c <= state_n ;
    end
    // reg     [3:0]       state_n   ;
    always @(*) begin
        case(state_c)
        IDLE      : if(IDLEtoFILTER_UP)
                        state_n = FILTER_UP ;
                    else 
                        state_n = IDLE ;
        FILTER_UP : if(FILTER_UPtoIDLE)
                        state_n = IDLE ;
                    else if(FILTER_UPtoSAMPLING)
                        state_n = SAMPLING ;
                    else 
                        state_n = FILTER_UP ;
        SAMPLING  : if(SAMPLINGtoFILTER_BACK)
                        state_n = FILTER_BACK ;
                    else 
                        state_n = SAMPLING ;
        FILTER_BACK:if(FILTER_BACKtoIDLE)
                        state_n = IDLE ;
                    else
                        state_n = FILTER_BACK ;
        default   :     state_n = IDLE ;
        endcase
    end
    assign  IDLEtoFILTER_UP         = (state_c == IDLE)       && (nege) ;
    assign  FILTER_UPtoIDLE         = (state_c == FILTER_UP)  && (pose) ;
    assign  FILTER_UPtoSAMPLING     = (state_c == FILTER_UP)  && (filter_done) ;
    assign  SAMPLINGtoFILTER_BACK   = (state_c == SAMPLING)   && (pose) ;
    assign  FILTER_BACKtoIDLE       = (state_c == FILTER_BACK)&& (filter_done) ;
    // reg     [18:0]      cnt_core  ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_core <= 19'd0 ;
        else
        case (state_c)
        IDLE       :cnt_core <= 19'd0 ; 
        FILTER_UP  :if(filter_done)
                        cnt_core <= 19'd0 ;
                    else 
                        cnt_core <= cnt_core + 1'b1 ;
        SAMPLING   :cnt_core <= 19'd0 ; 
        FILTER_BACK:if(filter_done)
                        cnt_core <= 19'd0 ;
                    else 
                        cnt_core <= cnt_core + 1'b1 ;
        default    :    cnt_core <= 19'd0 ;
        endcase
    end
    // wire                filter_done
    assign  filter_done = (cnt_core == MAX_CNT_10MS - 1) ;
    // output reg key_flag
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            key_flag <= 1'b0 ;
        else if(FILTER_UPtoSAMPLING)
            key_flag <= ~key_in_r2 ;
        else 
            key_flag <= 1'b0 ;
    end

endmodule

 

module led_paoma (
    input		wire				sys_clk      ,
    input		wire				sys_rst_n    ,

    output		reg     [3:0]       led_out     
);

    parameter   MAX_CNT_500MS = 25_000_000 ;
    // reg signal define
    reg     [24:0]      cnt_500ms ;
    reg     [ 1:0]      cnt_state ;
    // wire signal define
    wire                add_cnt_500ms ;
    wire                end_cnt_500ms ;
    wire                add_cnt_state ;
    wire                end_cnt_state ;
/******************************************************************************************
********************************************main code**************************************
*******************************************************************************************/
    // reg     [24:0]      cnt_500ms ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_500ms <= 25'd0 ;
        else if(add_cnt_500ms) begin
            if(end_cnt_500ms)
                cnt_500ms <= 25'd0 ;
            else 
                cnt_500ms <= cnt_500ms + 1'b1 ;
        end
        else 
            cnt_500ms <= 25'd0 ;
    end
    // reg     [ 1:0]      cnt_state ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_state <= 2'd0 ;
        else if(add_cnt_state) begin
            if(end_cnt_state)
                cnt_state <= 2'd0 ;
            else 
                cnt_state <= cnt_state + 1'b1 ;
        end 
        else 
            cnt_state <= cnt_state ;
    end
    // // wire signal define
    // wire                add_cnt_500ms ;
    assign  add_cnt_500ms = 1'b1 ;
    // wire                end_cnt_500ms ;
    assign  end_cnt_500ms = add_cnt_500ms && (cnt_500ms == (MAX_CNT_500MS - 1)) ;
    // wire                add_cnt_state ;
    assign  add_cnt_state = end_cnt_500ms ;
    // wire                end_cnt_state ;
    assign  end_cnt_state = ((add_cnt_state && (cnt_state == 2'b11 )) ) ; 
    // output reg [3:0]     led_out 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            led_out <= 4'b0000 ;
        else 
        case (cnt_state)
        2'b00 :     led_out <= 4'b0001 ;
        2'b01 :     led_out <= 4'b0010 ;
        2'b10 :     led_out <= 4'b0100 ;
        2'b11 :     led_out <= 4'b1000 ;
        default:    led_out <= 4'b0000 ;
        endcase
    end
endmodule

 

module shanshuo (
    input		wire				sys_clk      ,
    input		wire				sys_rst_n    ,

    output		reg     [3:0]       led_out     
);

    parameter   MAX_CNT_500MS = 25_000_000 ;
    // reg signal define
    reg     [24:0]      cnt_500ms ;
    // wire signal define
    wire                add_cnt_500ms ;
    wire                end_cnt_500ms ;
/******************************************************************************************
********************************************main code**************************************
*******************************************************************************************/
    // reg     [24:0]      cnt_500ms ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_500ms <= 25'd0 ;
        else if(add_cnt_500ms) begin
            if(end_cnt_500ms)
                cnt_500ms <= 25'd0 ;
            else 
                cnt_500ms <= cnt_500ms + 1'b1 ;
        end
        else 
            cnt_500ms <= 25'd0 ;
    end

    // // wire signal define
    // wire                add_cnt_500ms ;
    assign  add_cnt_500ms = 1'b1 ;
    // wire                end_cnt_500ms ;
    assign  end_cnt_500ms = add_cnt_500ms && (cnt_500ms == (MAX_CNT_500MS - 1)) ;

    // output reg [3:0]     led_out 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            led_out <= 4'b0000 ;
        else if(end_cnt_500ms)
            led_out <= ~led_out ;
        else 
            led_out <=  led_out ;
    end
    
endmodule

 

module led_water (
    input		wire				sys_clk      ,
    input		wire				sys_rst_n    ,

    output		reg     [3:0]       led_out     
);

    parameter   MAX_CNT_500MS = 25_000_000 ;
    // reg signal define
    reg     [24:0]      cnt_500ms ;
    reg     [ 2:0]      cnt_state ; 
    // wire signal define
    wire                add_cnt_500ms ;
    wire                end_cnt_500ms ;
    wire                add_cnt_state ;
    wire                end_cnt_state ;
/******************************************************************************************
********************************************main code**************************************
*******************************************************************************************/
    // reg     [24:0]      cnt_500ms ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_500ms <= 25'd0 ;
        else if(add_cnt_500ms) begin
            if(end_cnt_500ms)
                cnt_500ms <= 25'd0 ;
            else 
                cnt_500ms <= cnt_500ms + 1'b1 ;
        end
        else 
            cnt_500ms <= 25'd0 ;
    end
    // reg     [ 1:0]      cnt_state ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_state <= 2'd0 ;
        else if(add_cnt_state) begin
            if(end_cnt_state)
                cnt_state <= 2'd0 ;
            else 
                cnt_state <= cnt_state + 1'b1 ;
        end 
        else 
            cnt_state <= cnt_state ;
    end
    // // wire signal define
    // wire                add_cnt_500ms ;
    assign  add_cnt_500ms = 1'b1 ;
    // wire                end_cnt_500ms ;
    assign  end_cnt_500ms = add_cnt_500ms && (cnt_500ms == (MAX_CNT_500MS - 1)) ;
    // wire                add_cnt_state ;
    assign  add_cnt_state = end_cnt_500ms ;// && led_flag
    // wire                end_cnt_state ;
    assign  end_cnt_state = ((add_cnt_state && (cnt_state == 3'b101 )) ) ; 
    // output reg [3:0]     led_out 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            led_out <= 4'b0000 ;
        else 
        case (cnt_state)
        3'b000 :     led_out <= 4'b0001 ;
        3'b001 :     led_out <= 4'b0010 ;
        3'b010 :     led_out <= 4'b0100 ;
        3'b011 :     led_out <= 4'b1000 ;
        3'b100 :     led_out <= 4'b0100 ;
        3'b101 :     led_out <= 4'b0010 ;
        default:     led_out <= 4'b0000 ;
        endcase
    end
endmodule

 

module state_led_ctrl (
    input		wire				sys_clk         ,
    input		wire				sys_rst_n       ,
    input       wire                water_flag      ,
    input       wire                paoma_flag      ,
    input       wire                shanshuo_flag   ,
    input       wire    [3:0]       led_water       ,
    input       wire    [3:0]       led_paoma       ,
    input       wire    [3:0]       led_shanshuo    ,

    output	    reg     [3:0]       led_out         
);

    localparam          IDLE        = 4'b0001 ,
                        WATER       = 4'b0010 ,
                        PAOMA       = 4'b0100 ,
                        SHANSHUO    = 4'b1000 ;

    // reg signal define
    reg     [3:0]       state_c ;
    reg     [3:0]       state_n ;
    // wire signal
    wire                IDLEtoWATER         ;
    wire                IDLEtoPAOMA         ;
    wire                IDLEtoSHANSHUO      ;
    wire                WATERtoPAOMA        ;
    wire                WATERtoSHANSHUO     ;
    wire                PAOMAtoWATER        ;
    wire                PAOMAtoSHANSHUO     ;
    wire                SHANSHUOtoPAOMA     ;
    wire                SHANSHUOtoWATER     ;
/******************************************************************************************
********************************************main code**************************************
*******************************************************************************************/
    // // reg signal define
    // reg         state_c ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            state_c <= IDLE ;
        else
            state_c <= state_n ;
    end
    // reg         state_n ;
    always @(*) begin
        case(state_c)
        IDLE     :  if(IDLEtoWATER)
                        state_n = WATER ;
                    else if(IDLEtoPAOMA)
                        state_n = PAOMA ;
                    else if(IDLEtoSHANSHUO)
                        state_n = SHANSHUO ;
                    else 
                        state_n = IDLE ;
        WATER    :  if(WATERtoPAOMA)
                        state_n = PAOMA ;
                    else if(WATERtoSHANSHUO)
                        state_n = SHANSHUO ;
                    else 
                        state_n = WATER ;
        PAOMA    :  if(PAOMAtoWATER)
                        state_n = WATER ;
                    else if(PAOMAtoSHANSHUO)
                        state_n = SHANSHUO ;
                    else 
                        state_n = PAOMA ;
        SHANSHUO :  if(SHANSHUOtoPAOMA)
                        state_n = PAOMA ;
                    else if(SHANSHUOtoWATER)
                        state_n = WATER ;
                    else 
                        state_n = SHANSHUO ;
        default  :  state_n = IDLE ;
        endcase
    end

    assign  IDLEtoWATER         = (state_c == IDLE      ) && (water_flag   ) ;
    assign  IDLEtoPAOMA         = (state_c == IDLE      ) && (paoma_flag   ) ;
    assign  IDLEtoSHANSHUO      = (state_c == IDLE      ) && (shanshuo_flag) ;
    assign  WATERtoPAOMA        = (state_c == WATER     ) && (paoma_flag   ) ;
    assign  WATERtoSHANSHUO     = (state_c == WATER     ) && (shanshuo_flag) ;
    assign  PAOMAtoWATER        = (state_c == PAOMA     ) && (water_flag   ) ;
    assign  PAOMAtoSHANSHUO     = (state_c == PAOMA     ) && (shanshuo_flag) ;
    assign  SHANSHUOtoPAOMA     = (state_c == SHANSHUO  ) && (paoma_flag   ) ;
    assign  SHANSHUOtoWATER     = (state_c == SHANSHUO  ) && (water_flag   ) ;

    // led_out
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            led_out <= 4'hf ;
        else 
        case (state_c)
        IDLE    :   led_out <= 4'hf ;
        WATER   :   led_out <= led_water    ;
        PAOMA   :   led_out <= led_paoma    ;
        SHANSHUO:   led_out <= led_shanshuo ;
        default:    led_out <= 4'hf ;
        endcase
    end

endmodule

 

module top (
    input		wire				sys_clk         ,
    input		wire				sys_rst_n       ,
    input       wire                key_water       ,
    input       wire                key_paoma       ,
    input       wire                key_shanshuo    ,

    output		wire    [3:0]       led_out         
);

    // inst wire
    wire                water_flag      ;
    wire                paoma_flag      ;
    wire                shanshuo_flag   ;
    wire    [3:0]       led_water       ;
    wire    [3:0]       led_paoma       ;
    wire    [3:0]       led_shanshuo    ;

    // inst
key_filter key_filter_inst_water(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,
    .key_in                 ( key_water     ) ,

    .key_flag               ( water_flag    )  
);

key_filter key_filter_inst_paoma(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,
    .key_in                 ( key_paoma     ) ,

    .key_flag               ( paoma_flag    )  
);

key_filter key_filter_inst_shanshuo(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,
    .key_in                 ( key_shanshuo  ) ,

    .key_flag               ( shanshuo_flag )  
);

led_water led_water_isnt (
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,

    .led_out                ( led_water     )  
);

led_paoma led_paoma_inst(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,

    .led_out                ( led_paoma     )  
);

shanshuo shanshuo_inst(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,

    .led_out                ( led_shanshuo  )  
);

state_led_ctrl state_led_ctrl_inst(
    .sys_clk                ( sys_clk       ) ,
    .sys_rst_n              ( sys_rst_n     ) ,
    .water_flag             ( water_flag    ) ,
    .paoma_flag             ( paoma_flag    ) ,
    .shanshuo_flag          ( shanshuo_flag ) ,
    .led_water              ( led_water     ) ,
    .led_paoma              ( led_paoma     ) ,
    .led_shanshuo           ( led_shanshuo  ) ,

    .led_out                ( led_out       )  
);

endmodule

 

仿真：

`timescale 1ns/1ns
module test_top ();
    reg 				sys_clk         ;
    reg 				sys_rst_n       ;
    reg                 key_water       ;
    reg                 key_paoma       ;
    reg                 key_shanshuo    ;

    wire    [3:0]       led_out         ;

top top_inst(
    .sys_clk            ( sys_clk       ) ,
    .sys_rst_n          ( sys_rst_n     ) ,
    .key_water          ( key_water     ) ,
    .key_paoma          ( key_paoma     ) ,
    .key_shanshuo       ( key_shanshuo  ) ,

    .led_out            ( led_out       )  
);

    defparam    top_inst.key_filter_inst_water.MAX_CNT_10MS     = 50 ;
    defparam    top_inst.key_filter_inst_paoma.MAX_CNT_10MS     = 50 ;
    defparam    top_inst.key_filter_inst_shanshuo.MAX_CNT_10MS  = 50 ;
    defparam    top_inst.led_water_isnt.MAX_CNT_500MS           = 50 ;
    defparam    top_inst.led_paoma_inst.MAX_CNT_500MS           = 50 ;
    defparam    top_inst.shanshuo_inst.MAX_CNT_500MS            = 50 ;
    parameter   CYCLE = 20 ;

    initial begin
        sys_clk      = 1'b1 ;
        sys_rst_n   <= 1'b1 ;
        key_water   <= 1'b1 ;
        key_paoma   <= 1'b1 ;
        key_shanshuo<= 1'b1 ;
        #( CYCLE * 10 )     ;
        sys_rst_n <= 1'b0   ;
        #( 200 )            ;
        sys_rst_n <= 1'b1   ;
        #( CYCLE * 10 )     ;

        key_water <= 1'b0   ;
        #( CYCLE * 100 )    ;
        key_water <= 1'b1   ;
        #( CYCLE * 1000 )   ;

        key_paoma <= 1'b0   ;
        #( CYCLE * 100 )    ;
        key_paoma <= 1'b1   ;
        #( CYCLE * 1000 )   ;

        key_shanshuo <= 1'b0;
        #( CYCLE * 100 )    ;
        key_shanshuo <= 1'b1;
        #( CYCLE * 1000 )   ;
        
        $stop               ;
    end

    always #( CYCLE / 2 ) sys_clk = ~sys_clk ;


endmodule

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/226235.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

4种常见的限流算法

4种常见的限流算法

限流算法 1、固定窗口 含义&#xff1a; 在一个固定长度的时间窗口内限制请求数量&#xff0c;每来一个请求&#xff0c;请求次数加一&#xff0c;如果请求数量超过最大限制&#xff0c;就拒绝该请求 优点&#xff1a; 实现简单&#xff0c;容易理解。 缺点&#xff1a; ①限流…
阅读更多...
Ngxin实现301重定向映射

Ngxin实现301重定向映射

要实现将abc.love域名映射到http://baidu.com网站&#xff0c;并进行重定向&#xff0c;你需要在Nginx的配置文件中添加一个新的server块&#xff0c;如下所示&#xff1a; server {listen 80;server_name abc.com; #替换成自己的域名&#xff0c;记得要映射到这台服务器&…
阅读更多...
element UI改写时间线组件为左右分布

element UI改写时间线组件为左右分布

2023.12.4今天我学习了如何使用element的时间线组件&#xff0c;效果如&#xff1a; 代码如下&#xff1a;&#xff08;关键代码 v-if"item.send_type"&#xff09;判断左右分布情况。因为如果没有这个判断的话&#xff0c;其实会两边都有显示。可以用一个判断表示0显…
阅读更多...
OpenEuler_22.03升级mongdb到7.0.4

OpenEuler_22.03升级mongdb到7.0.4

使用命令&#xff1a;lscpu&#xff0c;查看cpu架构为aarch64为arm架构的一种执行状态。 所以我们直接下载arm的包安装即可。无需自己编译源码。 下载地址&#xff1a;https://www.mongodb.com/try/download/community 下载解压 wget https://fastdl.mongodb.org/linux/mong…
阅读更多...
使用腾讯逆地理位置编码获取地理位置信息

使用腾讯逆地理位置编码获取地理位置信息

文章目录 前言一、代码二、开放平台操作步骤1.开发者认证2.创建应用 总结 前言 最近项目中一个发帖的功能需要获取当前用户的发帖位置&#xff0c;由于是在APP内部使用&#xff0c;而且APP是使用uniApp开发的&#xff0c;所以在使用开放平台的SDK选用上有些麻烦&#xff0c;有…
阅读更多...
echarts环形饼图

echarts环形饼图

效果示例 代码汇总 pieCharts() {let data [];const providerResult [{name: 智诺, value: 23},{name: 海康, value: 5},{name: 大华, value: 5}, {name: 云科, value: 23},{name: 四信, value: 22},{name: 九物, value: 22}]let charts echarts.init(document.getElemen…
阅读更多...
11K+ Star！图解计算机网络、操作系统、计算机组成、数据库！

11K+ Star！图解计算机网络、操作系统、计算机组成、数据库！

大家好&#xff0c;我是 Java陈序员。 俗话说得好&#xff0c;面试造火箭&#xff0c;入职拧螺丝。我们在工作中&#xff0c;其实很少用到一些计算机底层知识&#xff0c;往往只要编码完事。但是&#xff0c;知其然还要知其所以然&#xff0c;我们不仅要做一个合格的“CV 工程…
阅读更多...
Vector Quantized Diffusion Model for Text-to-Image Synthesis

Vector Quantized Diffusion Model for Text-to-Image Synthesis

Vector Quantized Diffusion Model for Text-to-Image Synthesis Shuyang Gu, University of Science and Technology of China, Microsoft, CVPR2022, Cited: 340, Code, Paper 1. 前言 我们提出了用于文本到图像生成的矢量量化扩散(Vector Quantized Diffusion Model&…
阅读更多...
JavaScript如何实现按键音效、视频播放，标签分类切换横向滚动

JavaScript如何实现按键音效、视频播放，标签分类切换横向滚动

1.使用HTML5的audio标签 &#xff08;音频播放&#xff09; <audio id"click-sound"><source src"audio/show.mp3" type"audio/mpeg"> </audio> <button id"button">按钮</button> var clickSound d…
阅读更多...
北京市经信局局长姜广智带队调研三六零 强调大模型应与行业结合

北京市经信局局长姜广智带队调研三六零 强调大模型应与行业结合

12月6日&#xff0c;北京市经济和信息化局局长姜广智、副局长王磊带队走访调研三六零集团&#xff0c;就共促城市级数字安全基础设施项目落地&#xff0c;打造引领行业发展标杆项目&#xff0c;推动大模型落地应用赋能产业、行业发展等话题进行交流。360集团创始人周鸿祎接待来…
阅读更多...
【FPGA】Quartus18.1打包封装网表文件（.qxp）详细教程

【FPGA】Quartus18.1打包封装网表文件（.qxp）详细教程

当我们在做项目的过程中&#xff0c;编写的底层Verilog代码不想交给甲方时怎么办呢&#xff1f;此时可以将源代码打包封装成网表文件&#xff08;.qxp&#xff09;进行加密&#xff0c;并且在工程中进行调用。 Quartus II的.qxp文件为QuartusII Exported Partition&#xff0c;…
阅读更多...
探索 Linux Namespace：Docker 隔离的神奇背后

探索 Linux Namespace：Docker 隔离的神奇背后

来自&#xff1a;探索云原生 https://www.lixueduan.com 原文&#xff1a;https://www.lixueduan.com/posts/docker/03-container-core/ 在 深入理解 Docker 核心原理&#xff1a;Namespace、Cgroups 和 Rootfs 一文中我们分析了 Docker 是由三大核心技术实现的。 今天就一起分…
阅读更多...
C++多态（详解）

C++多态（详解）

一、多态的概念 1.1、多态的概念 多态&#xff1a;多种形态&#xff0c;具体点就是去完成某个行为&#xff0c;当不同的对象去完成时会产生出不同的状态。 举个例子&#xff1a;比如买票这个行为&#xff0c;当普通人买票时&#xff0c;是全价买票&#xff1b;学生买票时&am…
阅读更多...
【离散数学】——期末刷题题库（等价关系与划分）

【离散数学】——期末刷题题库（等价关系与划分）

&#x1f383;个人专栏&#xff1a; &#x1f42c; 算法设计与分析&#xff1a;算法设计与分析_IT闫的博客-CSDN博客 &#x1f433;Java基础&#xff1a;Java基础_IT闫的博客-CSDN博客 &#x1f40b;c语言&#xff1a;c语言_IT闫的博客-CSDN博客 &#x1f41f;MySQL&#xff1a…
阅读更多...
漏洞复现-速达软件全系产品存在任意文件上传漏洞（附漏洞检测脚本）

漏洞复现-速达软件全系产品存在任意文件上传漏洞（附漏洞检测脚本）

免责声明 文章中涉及的漏洞均已修复&#xff0c;敏感信息均已做打码处理&#xff0c;文章仅做经验分享用途&#xff0c;切勿当真&#xff0c;未授权的攻击属于非法行为&#xff01;文章中敏感信息均已做多层打马处理。传播、利用本文章所提供的信息而造成的任何直接或者间接的…
阅读更多...
12/07

12/07

#include "widget.h"Widget::Widget(QWidget *parent): QWidget(parent) {//设置面板框this->resize(1000,580); //设置尺寸大小this->setFixedSize(1000,580); //固定尺寸大小this->setWindowFlag(Qt::Frameles…
阅读更多...
XC4060 40V降5V/3.3V 0.6A小电流高耐压芯片 适用于单片机供电输出、电池供电设备

XC4060 40V降5V/3.3V 0.6A小电流高耐压芯片 适用于单片机供电输出、电池供电设备

XC4060器件是高效率&#xff0c;同步降压DC/DC稳压器。具有较宽的输入范围&#xff0c;它们适用于广泛的应用&#xff0c;例如来自非稳压源的功率调节。他们的特点是一个长距离(500mQ/300mQ2型) 内部开关的效率最高 (92%)。Sum od (非A选项)和PWM模式(A选项)&#xff0c;工作频…
阅读更多...
IDEA maven无法下载源代码处理

IDEA maven无法下载源代码处理

1、使用idea内置maven 在idea中新增一个mvn运行项,截图如下: 输入命令: dependency:resolve -Dclassifiersources 2、如果外部maven&#xff0c;不使用idea内部maven 在工程目录下命令行执行命令: mvn dependency:resolve -Dclassifiersources
阅读更多...
simulink中 Data store memory、write和read模块及案例介绍

simulink中 Data store memory、write和read模块及案例介绍

目录 1.Data store memory模块 2.data store write模块 3.data store read模块 4.仿真分析 4.1简单使用三个模块 4.2 模块间的调用顺序剖析 1.Data store memory模块 向右拖拉得到Data store read模块&#xff0c;向左拉得到Data write模块 理解&#xff1a;可视为定义变量…
阅读更多...
C++ 函数详解

C++ 函数详解

目录 函数概述 函数的分类 函数的参数 函数的调用 函数的嵌套调用 函数的链式访问 函数声明和定义 函数递归 函数概述 函数——具有某种功能的代码块。 一个程序中我们经常会用到某种功能&#xff0c;如两数相加&#xff0c;如果每次都在需要用到时实现&#xff0c;那…
阅读更多...
最新文章

Copyright @ 2022~2023