HDLbits---Circuits---Sequential Logic---Finite State Machines第三部分

最新推荐文章于 2024-07-29 15:23:54 发布
最新推荐文章于 2024-07-29 15:23:54 发布
阅读量1.5k 收藏
点赞数
分类专栏： HDLBits学习 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50965981/article/details/131699071
版权

1.Fsm onehot

module top_module(
    input         in,
    input  [9:0]  state,
    output [9:0]  next_state,
    output        out1,
    output        out2
);
 
assign next_state[0] = (state[0] & ~in) | (state[1] & ~in) | (state[2] & ~in) | (state[3] & ~in) | (state[4] & ~in) | (state[7] & ~in) | (state[8] & ~in) | (state[9] & ~in);
assign next_state[1] = (state[0] & in) | (state[8] & in) | (state[9] & in);
assign next_state[2] = (state[1] & in);
assign next_state[3] = (state[2] & in);
assign next_state[4] = (state[3] & in);
assign next_state[5] = (state[4] & in);
assign next_state[6] = (state[5] & in);
assign next_state[7] = (state[6] & in) | (state[7] & in);
assign next_state[8] = (state[5] & ~in);
assign next_state[9] = (state[6] & ~in);
 
assign out1 = (state[8] | state[9]);
assign out2 = (state[7] | state[9]);
 
endmodule

2.Fsm ps2

module top_module(
    input        clk,
    input [7:0]  in,
    input        reset,    // Synchronous reset
    output       done
);
 
parameter  IDLE  = 'd0;
parameter  BYTE1 = 'd1;
parameter  BYTE2 = 'd2;
parameter  BYTE3 = 'd3;
 
reg [1:0]   state;
reg [1:0]   next_state;
always @(posedge clk or posedge reset) begin
    if (reset) begin
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (in[3]) begin
                next_state = BYTE1;
            end
            else begin
                next_state = IDLE;
            end
        end
        BYTE1: begin
            next_state = BYTE2;
        end
        BYTE2: begin
            next_state = BYTE3;
        end
        BYTE3: begin
            if (in[3]) begin
                next_state <= BYTE1;
            end
            else begin
                next_state <= IDLE;
            end
        end
    endcase
end
 
assign done = (state == BYTE3);
 
endmodule

3.Fsm ps2data

module top_module(
    input          clk,
    input  [7:0]   in,
    input          reset,
    output [23:0]  out_bytes,
    output         done
);
 
parameter  IDLE  = 'd0;
parameter  BYTE1 = 'd1;
parameter  BYTE2 = 'd2;
parameter  BYTE3 = 'd3;
 
reg [1:0]   state;
reg [1:0]   next_state;
reg [23:0]  byte_rx;
always @(posedge clk) begin
    if (reset) begin
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (in[3]) begin
                next_state = BYTE1;
            end
            else begin
                next_state = IDLE;
            end
        end
        BYTE1: begin
            next_state = BYTE2;
        end
        BYTE2: begin
            next_state = BYTE3;
        end
        BYTE3: begin
            if (in[3]) begin
                next_state = BYTE1;
            end
            else begin
                next_state = IDLE;
            end
        end
    endcase
end
 
//
always @(posedge clk) begin
    if (next_state == BYTE1) begin
        byte_rx <= {byte_rx[15:0],in};
    end
    else if (next_state == BYTE2) begin
        byte_rx <= {byte_rx[15:0],in};
    end
    else if (next_state == BYTE3) begin
        byte_rx <= {byte_rx[15:0],in};;
    end
    else begin
        byte_rx <= 'd0;
    end
end
assign done = (state == BYTE3);
assign out_bytes = byte_rx;
endmodule

4.fsm_serial

module top_module(
    input     clk,
    input     in,
    input     reset,
    output    done
);
//状态机状态申明
parameter  IDLE       =  12'b000000000001; 
parameter  START      =  12'b000000000010; 
parameter  DATA_ONE   =  12'b000000000100; 
parameter  DATA_TWO   =  12'b000000001000; 
parameter  DATA_THREE =  12'b000000010000; 
parameter  DATA_FOUR  =  12'b000000100000; 
parameter  DATA_FIVE  =  12'b000001000000; 
parameter  DATA_SIX   =  12'b000010000000; 
parameter  DATA_SEVEN =  12'b000100000000; 
parameter  DATA_EIGHT =  12'b001000000000; 
parameter  STOP       =  12'b010000000000; 
parameter  WAIT       =  12'b100000000000;
 
reg  [11:0]   state;
reg  [11:0]   next_state;
always @(posedge clk) begin
      if (reset) begin
          state <= IDLE;
      end
      else begin
          state <= next_state;
      end
end 
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (~in) begin
                next_state = START;
            end
            else begin
                next_state = IDLE;
            end
        end
        START: begin
            next_state = DATA_ONE;
        end
        DATA_ONE: begin
            next_state = DATA_TWO;
        end
        DATA_TWO: begin
            next_state = DATA_THREE;
        end
        DATA_THREE:begin
            next_state = DATA_FOUR;
        end
        DATA_FOUR: begin
            next_state = DATA_FIVE;
        end
        DATA_FIVE: begin
            next_state = DATA_SIX;
        end
        DATA_SIX: begin
            next_state = DATA_SEVEN;
        end
        DATA_SEVEN: begin
            next_state = DATA_EIGHT;
        end
        DATA_EIGHT: begin
            if (in) begin
                next_state = STOP;
            end
            else begin
                next_state = WAIT;
            end
        end
        WAIT: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = WAIT;
            end
        end
        STOP: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = START;
            end    
        end
        default: begin
            next_state = IDLE;
        end
    endcase
end 
 
assign done = (state==STOP);
 
endmodule

5.fsm_serialdata

module top_module(
    input         clk,
    input         in,
    input         reset,    // Synchronous reset
    output [7:0]  out_byte,
    output        done
); 
parameter  IDLE       =  12'b000000000001; 
parameter  START      =  12'b000000000010; 
parameter  BIT_ONE    =  12'b000000000100; 
parameter  BIT_TWO    =  12'b000000001000; 
parameter  BIT_THREE  =  12'b000000010000; 
parameter  BIT_FOUR   =  12'b000000100000; 
parameter  BIT_FIVE   =  12'b000001000000; 
parameter  BIT_SIX    =  12'b000010000000; 
parameter  BIT_SEVEN  =  12'b000100000000; 
parameter  BIT_EIGHT  =  12'b001000000000; 
parameter  STOP       =  12'b010000000000; 
parameter  WAIT       =  12'b100000000000;
 
reg  [11:0]   state;
reg  [11:0]   next_state;
always @(posedge clk) begin
    if (reset) begin
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (~in) begin
                next_state = START;
            end
            else begin
                next_state = IDLE;
            end
        end
        START: begin
            next_state = BIT_ONE;
        end
        BIT_ONE: begin
            next_state = BIT_TWO;
        end
        BIT_TWO: begin
            next_state = BIT_THREE;
        end
        BIT_THREE:begin
            next_state = BIT_FOUR;
        end
        BIT_FOUR: begin
            next_state = BIT_FIVE;
        end
        BIT_FIVE: begin
            next_state = BIT_SIX;
        end
        BIT_SIX: begin
            next_state = BIT_SEVEN;
        end
        BIT_SEVEN: begin
            next_state = BIT_EIGHT;
        end
        BIT_EIGHT: begin
            if (in) begin
                next_state = STOP;
            end
            else begin
                next_state = WAIT;
            end
        end
        WAIT: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = WAIT;
            end
        end
        STOP: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = START;
            end    
        end
        default: begin
            next_state = IDLE;
        end
    endcase
end 
always @(posedge clk) begin
    if (reset) begin
        done     <= 'd0;
        out_byte <= 'd0;
    end
    else begin
        case(next_state)
            IDLE: begin
                done     <= 'd0;
                out_byte <= 'd0;                
            end
            START: begin
                done     <= 'd0;
                out_byte <= 'd0;
            end
            BIT_ONE: begin
                done        <= 'd0;
                out_byte[0] <= in; 
            end
            BIT_TWO: begin
                done        <= 'd0;
                out_byte[1] <= in; 
            end
            BIT_THREE: begin
                done        <= 'd0;
                out_byte[2] <= in; 
            end
            BIT_FOUR: begin
                done        <= 'd0;
                out_byte[3] <= in; 
            end
            BIT_FIVE: begin
                done        <= 'd0;
                out_byte[4] <= in; 
            end
            BIT_SIX: begin
                done        <= 'd0;
                out_byte[5] <= in; 
            end
            BIT_SEVEN: begin
                done        <= 'd0;
                out_byte[6] <= in; 
            end
            BIT_EIGHT: begin
                done        <= 'd0;
                out_byte[7] <= in; 
            end
            WAIT: begin
                done     <= in;
                out_byte <= out_byte;
            end
            STOP: begin
                done     <= 'd1;
                out_byte <= out_byte;
            end
            default: begin
                done     <= 'd0;
                out_byte <= 'd0;
            end
        endcase
    end
end
endmodule

6.Fsm serialdp

module top_module(
    input         clk,
    input         in,
    input         reset,    // Synchronous reset
    output [7:0]  out_byte,
    output        done
); 
parameter  IDLE       =  13'b0000000000001; 
parameter  START      =  13'b0000000000010; 
parameter  BIT_ONE    =  13'b0000000000100; 
parameter  BIT_TWO    =  13'b0000000001000; 
parameter  BIT_THREE  =  13'b0000000010000; 
parameter  BIT_FOUR   =  13'b0000000100000; 
parameter  BIT_FIVE   =  13'b0000001000000; 
parameter  BIT_SIX    =  13'b0000010000000; 
parameter  BIT_SEVEN  =  13'b0000100000000; 
parameter  BIT_EIGHT  =  13'b0001000000000;
parameter  PARITY_BIT =  13'b0010000000000;
parameter  STOP       =  13'b0100000000000; 
parameter  WAIT       =  13'b1000000000000;
reg  [12:0]   state;
reg  [12:0]   next_state;
reg           odd;
always @(posedge clk) begin
    if (reset) begin
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (~in) begin
                next_state = START;
            end
            else begin
                next_state = IDLE;
            end
        end
        START: begin
            next_state = BIT_ONE;
        end
        BIT_ONE: begin
            next_state = BIT_TWO;
        end
        BIT_TWO: begin
            next_state = BIT_THREE;
        end
        BIT_THREE:begin
            next_state = BIT_FOUR;
        end
        BIT_FOUR: begin
            next_state = BIT_FIVE;
        end
        BIT_FIVE: begin
            next_state = BIT_SIX;
        end
        BIT_SIX: begin
            next_state = BIT_SEVEN;
        end
        BIT_SEVEN: begin
            next_state = BIT_EIGHT;
        end
        BIT_EIGHT: begin
            next_state = PARITY_BIT;
        end
        PARITY_BIT: begin
            if (in) begin
                next_state = STOP;
            end
            else begin
                next_state = WAIT;
            end
        end
        WAIT: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = WAIT;
            end
        end
        STOP: begin
            if (in) begin
                next_state = IDLE;
            end
            else begin
                next_state = START;
            end    
        end
        default: begin
            next_state = IDLE;
        end
    endcase
end 
always @(posedge clk) begin
    if (reset) begin
        out_byte <= 'd0;
        done <= 'd0;
    end
    else begin
        case(next_state)
            IDLE: begin
                out_byte <= 'd0;
                done <= 'd0;
            end
            START: begin
                out_byte <= 'd0;
                done <= 'd0;
            end
            BIT_ONE: begin
                out_byte[0] <= in;
                done <= 'd0;
            end
            BIT_TWO: begin
                out_byte[1] <= in;
                done <= 'd0; 
            end
            BIT_THREE: begin
                out_byte[2] <= in;
                done <= 'd0;
            end
            BIT_FOUR: begin
                out_byte[3] <= in;
                done <= 'd0;
            end
            BIT_FIVE: begin
                out_byte[4] <= in;
                done <= 'd0;
            end
            BIT_SIX: begin
                out_byte[5] <= in;
                done <= 'd0; 
            end
            BIT_SEVEN: begin
                out_byte[6] <= in;
                done <= 'd0;
            end
            BIT_EIGHT: begin
                out_byte[7] <= in;
                done <= 'd0; 
            end
            PARITY_BIT: begin
                out_byte <= out_byte;
                done <= 'd0;
                
            end
            WAIT: begin
                out_byte <= out_byte;
                done <= 'd0;
            end
            STOP: begin
                out_byte <= out_byte;
                if (odd=='d1) begin
                    done <= 'd1;    
                end
                else begin
                    done <= 'd0;
                end
            end
            default: begin
                out_byte <= 'd0;
                done <= 'd0;
            end
        endcase
    end
end
wire   rst;  
assign rst = (reset == 1'b1 || next_state == IDLE || next_state == START);
parity u_parity(
    .clk        (clk        ),
    .reset      (rst         ),
    .in         (in            ),
    .odd        (odd        )
);
endmodule

7.fsm_hdlc

module top_module(
    input       clk,
    input       reset,    // Synchronous reset
    input       in,
    output      disc,
    output      flag,
    output      err
);
 
parameter  IDLE       =  10'b0000000001; 
parameter  BIT_ONE    =  10'b0000000010; 
parameter  BIT_TWO    =  10'b0000000100; 
parameter  BIT_THREE  =  10'b0000001000; 
parameter  BIT_FOUR   =  10'b0000010000; 
parameter  BIT_FIVE   =  10'b0000100000; 
parameter  BIT_SIX    =  10'b0001000000; 
parameter  STOP       =  10'b0010000000; 
parameter  DIS        =  10'b0100000000;
parameter  ERROR      =  10'b1000000000;
 
reg  [9:0]   state;
reg  [9:0]   next_state;
always @(posedge clk) begin
    if (reset) begin
        state <= IDLE;
    end
    else begin
        state <= next_state;
    end
end
always @(*) begin
    next_state = state;
    case(state)
        IDLE: begin
            if (in) begin
                next_state = BIT_ONE;
            end
            else begin
                next_state = IDLE;
            end
        end
        BIT_ONE: begin
            if (in) begin
                next_state = BIT_TWO;
            end
            else begin
                next_state = IDLE;
            end
        end
        BIT_TWO: begin
            if (in) begin
                next_state = BIT_THREE;
            end
            else begin
                next_state = IDLE;
            end
        end
        BIT_THREE: begin
            if (in) begin
                next_state = BIT_FOUR;
            end
            else begin
                next_state = IDLE;
            end
        end
        BIT_FOUR: begin
            if (in) begin
                next_state = BIT_FIVE;
            end
            else begin
                next_state = IDLE;
            end
        end
        BIT_FIVE: begin
            if (in) begin
                next_state = BIT_SIX;
            end
            else begin
                next_state = DIS;
            end
        end
        BIT_SIX: begin
            if (~in) begin
                next_state = STOP;
            end
            else begin
                next_state = ERROR;
            end
        end
        STOP: begin
            if (in) begin
                next_state = BIT_ONE;
            end
            else begin
                next_state = IDLE;
            end
        end
        DIS: begin
            if (in) begin
                next_state = BIT_ONE;
            end
            else begin
                next_state = IDLE;
            end
        end
        ERROR: begin
            if (in) begin
                next_state = ERROR;
            end
            else begin
                next_state = IDLE;
            end
        end
        default: begin
            next_state = IDLE;
        end
    endcase
end
always @(posedge clk) begin
    if (reset) begin
        disc <= 'd0;
        flag <= 'd0;
        err  <= 'd0;
    end
    else begin
        case(next_state)
            DIS: begin
                disc <= 'd1;
                flag <= 'd0;
                err  <= 'd0;
            end
            STOP: begin
                disc <= 'd0;
                flag <= 'd1;
                err  <= 'd0;                            
            end
            ERROR: begin
                disc <= 'd0;
                flag <= 'd0;
                err  <= 'd1;
            end
            default: begin
                disc <= 'd0;
                flag <= 'd0;
                err  <= 'd0;
            end
        endcase
    end
end
 
endmodule
ZxsLoves
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSSC Journal of Solid-State Circuits 2019年 2月.rar
09-07
《固体电路期刊》（Journal of Solid-State Circuits，简称JSSC）是电子工程领域的一份顶级学术期刊，专注于固态电路的研究与开发。2019年2月刊的内容涵盖了当年该领域的最新研究成果和技术进展，由五部分组成，分别...
Efficient Zero-Knowledge Arguments for Arithmetic Circuits
12-24
最后，文中提出的多项式承诺和验证方案，是构建高效零知识证明的关键组成部分，它允许在不暴露原始数据的情况下验证计算的正确性。这种技术的改进版本降低了Groth的证明的复杂性，进一步提升了零知识证明在实际应用...
CMOS Sigma-Delta Converters- Circuits and Errors.pdf
04-18
3. **电路构建块误差**：放大器的输出摆幅、直流增益、带宽限制（GB，SR）和瞬态响应，以及多比特ADC和DAC的增益误差、偏移误差和非线性，都是导致整体系统性能下降的关键因素。开关的有限导通电阻、热噪声、充电...
Exercises-handson-circuits.zip
04-02
《电子电路实践：Exercises-handson-circuits.zip探索》 在电子工程的学习过程中，动手实践是提升理解和技能的关键步骤。"Exercises-handson-circuits.zip" 是一个专门针对电子电路实践的资源包，旨在帮助学习者...
PK-40-F.pdf
06-20
根据提供的文件部分内容，我们可以梳理出一系列与电子元器件相关的知识点。这部分内容似乎涉及了一个复杂的电路设计文档或原理图，包含了电阻、电容、二极管、集成电路等多种元件及其型号、参数等信息。下面将对这些...
FPGA开发——D触发器的设计
weixin_63553972的博客
07-24 606
在FPGA开发中完成对于D触发器的实现。
FPGA开发——蜂鸣器的控制
weixin_63553972的博客
07-29 209
在项目开发的过程当中，我会通常会需要一个东西就行报警显示，有使用语音报警，信息报警等注入此类的方式，但最为简单使用的还是蜂鸣器的使用，蜂鸣器控制简单，成本低，是最为常用的模块之一。今天我们就来对蜂鸣器在FPGA中的使用进行一个简单实现。
FPGA开发——按键控制LED的实现
weixin_63553972的博客
07-29 279
在顶层文件中，使用一个中间变量key_out将按键中的输出赋值给LED模块中的按键标志位输入key_flag。通过我们前面编写的按键消抖的文件和LED文件将按键和LED两个模块进行交互，从而达到按键控制LED的目的。在上一篇文章中我们学习了按键的相关消抖及其使用，在这篇文章当中我们就针对通过按键实现LED的控制。通过波形图我们可以看见当按键按下一次，LED状态切换一次，实现了按键控制LED的功能实现。新建led_ctrl.v文件。2、LED相关设计文件编写。
FPGA开发——LED流水灯实现先从左往右流水，再从右往左流水
weixin_63553972的博客
07-26 420
我们在设计完一个方向的流水灯的设计时，总是会想实现让流水灯倒着流水回去的设计，这里我也是一样，实现这种设计的方法有很多种，其中就有直接使用case语句将所有可能包含进去编写，这种设计方法是最简单的，还有就是使用多个计数器的方式进行标志判断，实现方向流水的切换，以及我们最常用的状态机方法的实现。因为这里的设计不太难，所以我就讲解前面两种实现方式，至于最后一种方法感兴趣的可以去实现一下。
JNDIExploit使用
07-29
一款用于 JNDI注入利用的工具，大量参考/引用了 Rogue JNDI项目的代码，支持直接植入内存shell，并集成了常见的bypass 高版本JDK的方式，适用于与自动化工具配合使用。 使用说明 使用 java -jar JNDIExploit.jar -h查看参数说明，其中 --ip参数为必选参数 Usage: java -jar JNDIExploit.jar [options] Options: * -i, --ip Local ip address -l, --ldapPort Ldap bind port (default: 1389) -p, --httpPort Http bind port (default: 8080) -u, --usage Show usage (default: false) -h, --help Show this help Dockerfile git clone https://github.com/feihong-cs/JNDIExploit.git cd ./JN
基于MATLAB的人体行为识别.zip
最新发布
07-29
在MATLAB中，可以使用机器学习和计算机视觉技术来实现人体行为识别。下面是一个基本的人体行为识别过程的程序： 1. 数据收集和准备： - 收集包含不同人体行为的视频数据。 - 使用视频处理技术提取每个视频中的人体姿势和关键点信息。 2. 特征提取： - 使用计算机视觉技术，如OpenPose或者其他姿势估计算法，提取每个视频中的人体关键点位置。 - 根据关键点位置计算特征向量，例如关节角度、运动速度等。 3. 数据标记和标签： - 根据人体行为类型，对收集的数据进行标记和分类，例如步行、跑步、打球等。 - 为每个人体行为类型分配一个标签。 4. 训练模型： - 使用机器学习算法，如支持向量机（SVM）、决策树、深度神经网络等，对标记和分类的数据进行训练。 - 使用训练数据和标签训练模型，以学习不同行为类型之间的关系。 5. 测试和识别： - 使用训练好的模型对新的测试数据进行预测和识别。 - 输入测试数据的特征向量到训练好的模型中，根据模型的输出来确定人体行为类型。 6. 评估和改进： - 根据测试结果评估
【创新未发表】Matlab实现蝗虫优化算法GOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【SCI一区】Matlab实现向量加权平均算法INFO-CNN-LSTM-Attention的风电功率预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
5份个人单页简历素材-清新单页.zip
07-29
【简历模板】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
【创新未发表】Matlab实现星雀优化算法NOA-Kmean-Transformer-BiLSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
和语音活动检测相关的数据集
07-29
语音活动检测数据集 数据说明： 语音活动检测任务可以区分出现人类语音和其他类型声音(如沉默和声)的信号段。 它是许多语音/音频应用的起点，包括语音编码，语音识别和语音增强。 由于这类任务没有特定的公共数据集，所以该数据集是从三个不同的数据库收集的719个音频。包括： ·TIMIT:是一个读语音语资料库，旨在为声学和语音研究提供语音数据，并评估自动语音识别系统。 · PTDB-TUG:是一个用于音高跟踪的语音数据库，提供20个讲英语者的麦克风信号。 ·Noizeus:包含30个句子的语音数据。噪音信号被人为添加到语音信号中，特别是该数据库包含被胡言乱语(人群)、街道、火车、火车站、汽车和餐馆噪音破坏的音频，SNR为5分贝，以及原始噪音。
刚体不稳定自由旋转的简单MATLAB仿真-SpinSpin-四元数- v2-MATLAB
07-29
旋转物体运动学是基于“标量第一单位四元数”的。 项目“SpinSpin_Quaternion_v1”与此项目类似。 项目“SpinSpin_RotationVector”与此项目类似，但基于“RotationVector”。 标量第一单位四元数定义： 标量第一单位四元数是长度为4的一维行或列向量。 使用Matlab的“ode45”函数求解常微分方程（ODE），应用Dorman-Prince 4（5）显式嵌入式自适应时间步长龙格-库塔方法。 Matlab“ode45”函数中的误差限制设置为10-13。
AI绘画介绍及应用场景.pdf
07-29
AI绘画的应用场景非常广泛。在艺术创作领域，AI可以为艺术家提供灵感和创作素材，帮助他们探索新的艺术风格和表现手法。同时，AI绘画也可以用于游戏、动画、电影等娱乐产业的视觉制作中，提高制作效率和降低成本。此外，AI绘画还可以用于教育、医疗等领域，为学生提供更加直观、生动的学习材料，为医生提供更加准确的诊断依据。
html+css+js作业王者荣耀司空震1个页面.zip
07-29
预览地址：https://blog.csdn.net/qq_42431718/article/details/140774765 王者荣耀司空震1个页面（带js）有轮播图
适用于一些手游的Auto.js自动脚本 (楚留香,原神,天涯明月刀,光遇,逆水寒手游)(自动弹琴,演奏,喊话,发消息)
07-29
autojs
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值