FPGA:有限状态机

news2024/9/22 9:39:59

从以下6个实验理解状态机的概念
在这里插入图片描述
开发板频率为 50 M H z 50MHz 50MHz，一个时钟周期是 20 n s 20ns 20ns。

1、实验一:LED灯亮0.25秒、灭0.75秒的状态循环

通过之前的分析，我们实现频闪灯时，是让led灯在0.5秒实现一次翻转，而这里虽然总时长都是一秒，但是要求亮的时间和不亮的时间缺不是相等的。 1 s ÷ 20 n s = 5 × 1 0 7 T 1s÷20ns=5\times10^7T 1s÷20ns=5×107T，即一秒钟有 50000000 50000000 50000000个时钟周期，而 ⌈ l o g 2 50000000 ⌉ = 26 ⌈log_250000000⌉=26 ⌈log2​50000000⌉=26，所以计数器需要26位。我们可以在前0.75秒保持灯灭，在0.75秒-1秒保持灯亮，即可实现对应的要求。
对应的verilog代码如下：

module led_flash1(
	clk,Reset_n,led
);
input clk;
input Reset_n;
output reg led;
reg [25:0] counter;
parameter MCNT=50000000;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter<=0;
	else if(counter==MCNT-1)
		counter<=0;
	else
		counter<=counter+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=0;
	else if(counter==(3*MCNT)/4-1)  //0.75秒时1秒的3/4
		led<=1;
	else if(counter==MCNT-1)
		led<=0;
endmodule

对应的测试文件如下：

`timescale 1ns/1ps
module led_flash_tb();
reg clk;
reg Reset_n;
wire led;
led_flash1 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led)
);
defparam led_flash_inst.MCNT=50000;
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	#201;
	Reset_n=1;
	#2000000;
	$stop;
	end
endmodule

进行仿真，对应的波形图如下所示：
在这里插入图片描述

和我们分析的结果一致，前面还有对应的零头使我们复位的用时。但是通过add_maker可以发现和预想结果一致。

2、实验二:LED灯亮0.25秒，灭0.5秒，亮0.75秒，灭1秒顺序循环

此时总时间周期为 0.25 + 0.5 + 0.75 + 1 = 2.5 s 0.25+0.5+0.75+1=2.5s 0.25+0.5+0.75+1=2.5s。
2.5 s ÷ 20 n s = 125000000 T 2.5s \div 20ns=125000000T 2.5s÷20ns=125000000T，而 ⌈ l o g 2 125000000 ⌉ = 27 ⌈log_2125000000⌉=27 ⌈log2​125000000⌉=27，所以计数器需要27位，其余实现思路类似。
比如从开始分析，复位时令led为1，然后亮0.25秒，即十分之一个周期，然后灭0.5秒，即在0.25秒到0.75秒为灭，0.75秒为十分之三个周期，0.75秒到1.5秒为亮，1.5秒为五分之三个总周期，1.5秒-2.5秒为灭。这就是一个周期。对应的verilog代码如下：

module led_flash2(
	clk,Reset_n,led
);
input clk;
input Reset_n;
output reg led;
reg [26:0] counter;
parameter MCNT=125000000;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter<=0;
	else if(counter==MCNT-1)
		counter<=0;
	else
		counter<=counter+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=1;
	else if(counter==MCNT/10-1)
		led<=0;
	else if(counter==(MCNT)*3/10-1)
		led<=1;
	else if(counter==(MCNT)*3/5-1)
		led<=0;
	else if(counter==MCNT-1)
		led<=1;
endmodule

测试文件如下

`timescale 1ns/1ps
module led_flash_tb();
reg clk;
reg Reset_n;
wire led;
led_flash2 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led)
);
defparam led_flash_inst.MCNT=125000;
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	#201;
	Reset_n=1;
	#20000000;
	$stop;
	end
endmodule

打开仿真如下所示：
在这里插入图片描述

3、实验三：LED灯按照指定的亮灭模式亮灭，亮灭模式未知，由用户随机制定，以0.25秒为一个变化周期，8个变化状态为一个循环。

这个实验的思路就是加上一个端口[7:0]ctrl，用来记录状态，每过0.25秒的时候，转换到下一个状态，计算可得，单个总时长为 0.25 × 8 = 2 s 0.25×8=2s 0.25×8=2s,单个周期内的时钟周期数： 2 × 1 0 9 ÷ 20 = 100000000 T 2×10^9÷20=100000000T 2×109÷20=100000000T，需要27位计数器，所以可以定义一个变量让其等于 1000000000 1000000000 1000000000，每经过八分之一个周期切换一次状态即可。具体实现的verilog代码如下：

module led_flash3(
	clk,Reset_n,led,ctrl
);
input clk;
input Reset_n;
output reg led;
input [7:0] ctrl;
reg [26:0] counter;
parameter MCNT=100000000;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter<=0;
	else if(counter==MCNT-1)
		counter<=0;
	else
		counter<=counter+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=0;
	else if(counter==MCNT/8-1)
		led<=ctrl[0];
	else if(counter==(MCNT)*2/8-1)
		led<=ctrl[1];
	else if(counter==(MCNT)*3/8-1)
		led<=ctrl[2];
	else if(counter==(MCNT)*4/8-1)
		led<=ctrl[3];
	else if(counter==(MCNT)*5/8-1)
		led<=ctrl[4];
	else if(counter==(MCNT)*6/8-1)
		led<=ctrl[5];
	else if(counter==(MCNT)*7/8-1)
		led<=ctrl[6];
	else if(counter==MCNT-1)
		led<=ctrl[7];
endmodule

测试文件代码如下：

`timescale 1ns/1ps
module led_flash3_tb();
reg clk;
reg Reset_n;
reg[7:0] ctrl;
wire led;
led_flash3 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led),
	.ctrl(ctrl)
);
defparam led_flash_inst.MCNT=100000;
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	#201;
	Reset_n=1;
	ctrl = 8'b0101_0110;    //初始的ctrl状态
	#20000000;
	$stop;
	end
endmodule

仿真波形如下：
注意高低位的判断，ctrl[0]=0,ctrl[1]=1,ctrl[2]=1,ctrl[3]=0,ctrl[4]=1,ctrl[5]=0,ctrl[6]=1,ctrl[7]=0,所以显示应该为01101010，测试文件里面我们定义MCNT为100000， 100000 × 20 ÷ 8 = 250 μ s 100000×20÷8=250μs 100000×20÷8=250μs，所以仿真内一个变化周期为 250 μ s 250μs 250μs，观察可知相符。
在这里插入图片描述

4、实验四:让LED灯按照指定的亮灭模式亮灭，亮灭模式未知，由用户随机制定，8个变化状态为一个循环，每个变化状态的时间值可以根据不同的应用场景选择。

实验思路：加入一个时间端口Time，计数器1专门用来计数，计数器2专门用来计状态，当计数器1满一个Time则计数器2加1。此处设Time位宽为32位，即[31:0]。所以计数器1要和它一样长，否则会出现溢出，只有8种状态，需要3位二进制表示。具体verilog代码如下：

module led_flash3(
	clk,Reset_n,led,ctrl,Time
);
input clk;
input Reset_n;
output reg led;
input [7:0] ctrl;
input [31:0] Time;
reg [31:0] counter;
reg [2:0] counter2;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter<=0;
	else if(counter==Time-1)
		counter<=0;
	else
		counter<=counter+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter2<=0;
	else if (counter==Time-1)
		counter2<=counter2+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=0;
	else
		case(counter2)
			0:led<=ctrl[0];
			1:led<=ctrl[1];
			2:led<=ctrl[2];
			3:led<=ctrl[3];
			4:led<=ctrl[4];
			5:led<=ctrl[5];
			6:led<=ctrl[6];
			7:led<=ctrl[7];
			default:led<=led;
		endcase
endmodule

测试文件如下:

`timescale 1ns/1ps
module led_flash4_tb();
reg clk;
reg Reset_n;
reg[7:0] ctrl;
reg [31:0] Time;
wire led;
led_flash4 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led),
	.ctrl(ctrl),
	.Time(Time)
);
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	ctrl=0;
	Time=0;
	#201;
	Reset_n=1;
	Time = 2500;
	ctrl = 8'b1110_1101;
	#20000000;
	$stop;
	end
endmodule

这里Time定义为2500，即一个小周期2500个时钟周期，即 2500 × 20 n s = 50 μ s 2500×20ns=50μs 2500×20ns=50μs，仿真波形如下
在这里插入图片描述

5、实验五：让多个LED灯按照设置的模式各自在一个变化循环内独立亮灭变换

实验思路：和之前一样，这里在输入端口上加上8位的LED控制对应的LED灯即可。(为了简化输入输出，在这里time和ctrl都设置为定值),对应verilog代码如下：

module led_flash5(
	clk,Reset_n,led,ctrl
);
input clk;
input Reset_n;
input [7:0] ctrl;
output reg[7:0] led;
parameter Time=24999999;
reg [31:0] counter;
reg [2:0] counter2;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter<=0;
	else if(counter==Time-1)
		counter<=0;
	else
		counter<=counter+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		counter2<=0;
	else if (counter==Time-1)
		counter2<=counter2+1'b1;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=0;
	else
		case(counter2)
			0:begin
			led[0]<=ctrl[0];
			led[1]<=ctrl[0];
			led[2]<=ctrl[0];
			led[3]<=ctrl[0];
			led[4]<=ctrl[0];
			led[5]<=ctrl[0];
			led[6]<=ctrl[0];
			led[7]<=ctrl[0];
			end
			1:begin
			led[0]<=ctrl[1];
			led[1]<=ctrl[1];
			led[2]<=ctrl[1];
			led[3]<=ctrl[1];
			led[4]<=ctrl[1];
			led[5]<=ctrl[1];
			led[6]<=ctrl[1];
			led[7]<=ctrl[1];
			end
			2:begin
			led[0]<=ctrl[2];
			led[1]<=ctrl[2];
			led[2]<=ctrl[2];
			led[3]<=ctrl[2];
			led[4]<=ctrl[2];
			led[5]<=ctrl[2];
			led[6]<=ctrl[2];
			led[7]<=ctrl[2];
			end
			3:begin
			led[0]<=ctrl[3];
			led[1]<=ctrl[3];
			led[2]<=ctrl[3];
			led[3]<=ctrl[3];
			led[4]<=ctrl[3];
			led[5]<=ctrl[3];
			led[6]<=ctrl[3];
			led[7]<=ctrl[3];
			end
			4:begin
			led[0]<=ctrl[4];
			led[1]<=ctrl[4];
			led[2]<=ctrl[4];
			led[3]<=ctrl[4];
			led[4]<=ctrl[4];
			led[5]<=ctrl[4];
			led[6]<=ctrl[4];
			led[7]<=ctrl[4];
			end
			5:begin
			led[0]<=ctrl[5];
			led[1]<=ctrl[5];
			led[2]<=ctrl[5];
			led[3]<=ctrl[5];
			led[4]<=ctrl[5];
			led[5]<=ctrl[5];
			led[6]<=ctrl[5];
			led[7]<=ctrl[5];
			end
			6:begin
			led[0]<=ctrl[6];
			led[1]<=ctrl[6];
			led[2]<=ctrl[6];
			led[3]<=ctrl[6];
			led[4]<=ctrl[6];
			led[5]<=ctrl[6];
			led[6]<=ctrl[6];
			led[7]<=ctrl[6];
			end
			7:begin
			led[0]<=ctrl[7];
			led[1]<=ctrl[7];
			led[2]<=ctrl[7];
			led[3]<=ctrl[7];
			led[4]<=ctrl[7];
			led[5]<=ctrl[7];
			led[6]<=ctrl[7];
			led[7]<=ctrl[7];
			end
			default:begin
			led[0]<=led[0];
			led[1]<=led[1];
			led[2]<=led[2];
			led[3]<=led[3];
			led[4]<=led[4];
			led[5]<=led[5];
			led[6]<=led[6];
			led[7]<=led[7];
			end
		endcase
endmodule

测试文件如下：

`timescale 1ns/1ps
module led_flash5_tb();
reg clk;
reg Reset_n;
reg [7:0] ctrl;
wire [7:0]led;
led_flash5 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led),
	.ctrl(ctrl)
);
defparam led_flash_inst.Time=2500;
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	ctrl=0;
	#201;
	Reset_n=1;
	ctrl=8'b1101_1010;
	#20000000;
	$stop;
	end
endmodule

Time依旧采用2500，即 50 μ s 50μs 50μs，在测试文件中，令ctrl=1101_1010，注意这是ctrl[7]-ctrl[0]顺序，仿真波形如下：
在这里插入图片描述
这里我们进行引脚分配并进行班级调试，将ctrl分配给八个开关，led分配给对应的led灯，Reset_n分配给按键S0，clk分配给时钟单元。
引脚分配
生成比特流，烧到开发板进行调试，分析一下：当我们按键上推表示在对应小周期就是亮的，如果SW7-SW0是按照10101010，那就是之前所说的频闪灯，只不过这里是0.5s，前0.25秒亮，后0.25秒灭，如果是0000_1111，那就是后一秒亮，前1秒不亮，频闪周期2秒。全0则全不亮，全1则全亮。接下来验证一下上面的分析：

在这里插入图片描述
在这里插入图片描述

6、实验六：每隔10ms，让LED灯的一个8状态循环执行一次(每10ms执行一次)

10 m s ÷ 20 n s = 500000 T 10ms÷20ns=500000T 10ms÷20ns=500000T，8个状态最多在10ms内运行完成 500000 ÷ 8 = 62500 T 500000÷8=62500T 500000÷8=62500T,即每个小周期最多有62500个时钟周期。 ⌈ l o g 2 62500 ⌉ = 16 ⌈log_262500⌉=16 ⌈log2​62500⌉=16，即Time最多16位，接下来我们定义一个计时器为10ms， ⌈ l o g 2 500000 ⌉ = 19 ⌈log_2500000⌉=19 ⌈log2​500000⌉=19，即最多需要19位。再增加一共标志位，当计数状态慢8状态时，标志位为0，即阻塞不再执行，当计数器3(计时10毫秒)满时，标志位重新恢复为1.对应verilog代码如下:

module led_flash6(
	clk,Reset_n,led,ctrl,Time
);
input clk;
input Reset_n;
output reg led;
input [7:0] ctrl;
input [15:0] Time;
reg [15:0] counter;
reg [2:0] counter2;
reg [18:0]counter3;
reg logo; //标志位
always @(posedge clk or negedge Reset_n)   //单个小周期计数器
	if(!Reset_n)
		counter<=0;
	else if(logo)
		begin
		if(counter==Time-1)
			counter<=0;
		else
			counter<=counter+1'b1;
		end
	else
		counter<=0;
always @(posedge clk or negedge Reset_n)   // 状态计数器
	if(!Reset_n)
		counter2<=0;
	else if (logo)begin
		if(counter==Time-1)
			counter2<=counter2+1'b1;
		end
	else
		counter2<=0;
always @(posedge clk or negedge Reset_n)   //计数10毫秒
	if(!Reset_n)
		counter3<=0; //复位
	else if(counter2 == 500000-1)   //
		counter3<=0;
	else
		counter<=counter+1;
always @(posedge clk or negedge Reset_n)  //标志位
	if(!Reset_n)
		logo<=0;
	else if(counter3==0)
		logo<=1;
	else if((counter2==7)&&(counter==Time-1))
		logo<=0;
always @(posedge clk or negedge Reset_n)
	if(!Reset_n)
		led<=0;
	else case(counter2)
			0:led<=ctrl[0];
			1:led<=ctrl[1];
			2:led<=ctrl[2];
			3:led<=ctrl[3];
			4:led<=ctrl[4];
			5:led<=ctrl[5];
			6:led<=ctrl[6];
			7:led<=ctrl[7];
			default:led<=led;
		endcase
endmodule

测试文件代码如下：

`timescale 1ns/1ps
module led_flash6_tb();
reg clk;
reg Reset_n;
reg[7:0] ctrl;
reg [15:0] Time;
wire led;
led_flash6 led_flash_inst(
	.clk(clk),
	.Reset_n(Reset_n),
	.led(led),
	.ctrl(ctrl),
	.Time(Time)
);
initial clk=1;
always #10 clk=!clk;
initial begin
	Reset_n=0;
	ctrl=0;
	Time=0;
	#201;
	Reset_n=1;
	Time = 2500;
	ctrl = 8'b1110_1101;
	#20000000;
	$stop;
	end
endmodule

执行仿真，波形图如下所示。
在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》

《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》

Multi-modal系列论文研读目录 文章目录 Multi-modal系列论文研读目录1.ABSTRACT2.INDEX TERMS3.INTRODUCTION4.RELATED WORKSA. MULTIMODAL EMOTION RECOGNITION 多模态情感识别1) CONVENTIONAL FUSION METHODS 常规融合方法2) TRANSFORMER-BASED FUSION METHODS 基于变压器的融…
阅读更多...
Redis (常用数据结构和命令)

Redis (常用数据结构和命令)

目录 简介 概述 特点 数据结构 常用命令 通用命令 keys del exists expire 与 ttl String 命令 SET 和GET: MSET和MGET INCR和INCRBY和DECY SETNX SETEX Redis 命令 Key 的层级结构 key层级关系 &#xff1a; Hash命令 HSET和HGET HMSET和HMGET HGETALL H…
阅读更多...
MySQL练手 --- 1141. 查询近30天活跃用户数

MySQL练手 --- 1141. 查询近30天活跃用户数

题目链接&#xff1a;1141. 查询近30天活跃用户数 思路&#xff1a; 题目要求&#xff1a;统计截至 2019-07-27&#xff08;包含2019-07-27&#xff09;&#xff0c;近 30 天的每日活跃用户数&#xff08;当天只要有一条活动记录&#xff0c;即为活跃用户&#xff09; 要计算…
阅读更多...
前端模块化CommonJS、AMD、CMD、ES6

前端模块化CommonJS、AMD、CMD、ES6

在前端开发中&#xff0c;模块化是一种重要的代码组织方式&#xff0c;它有助于将复杂的代码拆分成可管理的小块&#xff0c;提高代码的可维护性和可重用性。CommonJS、AMD&#xff08;异步模块定义&#xff09;和CMD&#xff08;通用模块定义&#xff09;是三种不同的模块规范…
阅读更多...
H3CNE（OSPF动态路由）

H3CNE（OSPF动态路由）

目录 7.1 静态路由的缺点与动态路由分类 7.1.1 静态路由的缺点 7.1.2 动态路由的分类 7.2 OSPF基础 7.2.1 OSPF的区域 ​编辑 7.2.2 Router-id 7.2.3 开销-Cost or Metric 7.2.4 路由转发 7.3 OSPF邻居表建立过程 7.3.1 五种包 7.3.2 建立邻居表的第一步 7.3.3 邻居建立…
阅读更多...
数据结构与算法--顺序表(Java)

数据结构与算法--顺序表(Java)

&#x1f4dd;个人主页&#x1f339;&#xff1a;誓则盟约 ⏩收录专栏⏪&#xff1a;Java SE &#x1f921;往期回顾&#x1f921;&#xff1a;Java SE--基本数据类型&#xff08;详细讲解&#xff09; &#x1f339;&#x1f339;期待您的关注 &#x1f339;&#x1f339; 什么…
阅读更多...
前端养成记-实现一个低配版简单版本的vue3表单自定义设计组件

前端养成记-实现一个低配版简单版本的vue3表单自定义设计组件

简介&#xff1a; 通过使用了最新的vue3,vite2,TypeScript等主流技术开发&#xff0c;并配合使用vuedraggable 插件以及antd design vue 组件库实现低配版本的自定义表单设计组件&#xff1b; 项目地址&#xff1a;https://gitee.com/hejunqing/vue3-antdv-generator
阅读更多...
GLSL教程 第8章：几何着色器

GLSL教程 第8章：几何着色器

目录 8.1 几何着色器的介绍 几何着色器的主要功能&#xff1a; 几何着色器的工作流程&#xff1a; 8.2 实现基本的几何变换 示例&#xff1a;将三角形扩展成多个三角形 8.3 几何着色器的高级应用 1. 粒子系统 2. 光晕效果 3. 线框模型 小结 几何着色器是图形管线中的一…
阅读更多...
Linux——管理本地用户和组（详细介绍了Linux中用户和组的概念及用法）

Linux——管理本地用户和组（详细介绍了Linux中用户和组的概念及用法）

目录 一、用户和组概念 &#xff08;一&#xff09;、用户的概念 &#xff08;二&#xff09;、组的概念 补充组 主要组 二、获取超级用户访问权限 &#xff08;一&#xff09;、su 命令和su -命令 &#xff08; 二&#xff09;、sudo命令 三、管理本地用户账户 &…
阅读更多...
Java面试八股之什么是声明式事务管理，spring怎么实现声明式事务管理？

Java面试八股之什么是声明式事务管理，spring怎么实现声明式事务管理？

什么是声明式事务管理&#xff0c;spring怎么实现声明式事务管理&#xff1f; 声明式事务管理是一种编程范式&#xff0c;它允许开发人员通过声明性的配置或注解&#xff0c;而不是硬编码事务处理逻辑&#xff0c;来指定哪些方法或类应该在其上下文中执行事务。这种方法将事务…
阅读更多...
Kadane 算法 | 53. 最大子数组和 + 918. 环形子数组的最大和

Kadane 算法 | 53. 最大子数组和 + 918. 环形子数组的最大和

目录 1 维基百科2 53. 最大子数组和2.1 代码思路2.2 完整代码 3 918. 环形子数组的最大和3.1 代码思路3.2 完整代码 1 维基百科 最大子数组问题 在计算机科学中&#xff0c;最大子数组问题的目标是在数组的一维方向找到一个连续的子数组&#xff0c;使该子数组的和最…
阅读更多...
Axious的请求与响应

Axious的请求与响应

Axious的请求与响应 1.什么是Axious Axious是一个开源的可以用在浏览器和Node.js的异步通信框架&#xff0c;它的主要作用就是实现AJAX异步通信&#xff0c;其功能特点如下&#xff1a; 从浏览器中创建XMLHttpRequests ~从node.js创建Http请求 支持PromiseAPI 拦截请求和…
阅读更多...
[UVM源代码研究] 聊聊UVM中的callback机制

[UVM源代码研究] 聊聊UVM中的callback机制

1. callback机制是什么&#xff1f; 以最高效的方式完成芯片验证&#xff0c;一直以来都是验证人员的首要目标&#xff0c;那么最直接的方式就是环境的移植和重用&#xff0c;一个优秀的验证工程师&#xff0c;在开发环境的过程中&#xff0c;一定会考虑环境的继承和重用。 继…
阅读更多...
c++ 智能指针shared_ptr与make_shared

c++ 智能指针shared_ptr与make_shared

shared_ptr是C11引入的一种智能指针&#xff0c;‌它允许多个shared_ptr实例共享同一个对象&#xff0c;‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时&#xff0c;‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题&…
阅读更多...
简单小案例分析

简单小案例分析

一、容器和实例关系 <div class"app"><h1>Hello,{{name}}</h1> </div> <div class"app"><h1>Hello,{{name}}</h1> </div><script>//创建Vue实例new Vue({el:".app", //el用于指定当前V…
阅读更多...
北大延毕硕士×INFJ | 我解脱了

北大延毕硕士×INFJ | 我解脱了

前言 拿了双证&#xff0c;我终于能静下心来复盘一下我延毕一年的经历了。 给后面也许有相同困境的朋友们做个参考或者心理疏导作用。 延毕的原因 我延毕的主要原因是论文研三的时候论文没有完成&#xff0c;我们专业的论文一般是6个月全身心投入可以完成。我这个人是典型的…
阅读更多...
7月24日JavaSE学习笔记

7月24日JavaSE学习笔记

序列化版本控制 序列化&#xff1a;将内存对象转换成序列&#xff08;流&#xff09;的过程 反序列化&#xff1a;将对象序列读入程序&#xff0c;转换成对象的方式&#xff1b;反序列化的对象是一个新的对象。 serialVersionUID 是一个类的序列化版本号 private static fin…
阅读更多...
77.WEB渗透测试-信息收集-框架组件识别利用（1）

77.WEB渗透测试-信息收集-框架组件识别利用（1）

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 内容参考于&#xff1a; 易锦网校会员专享课 上一个内容&#xff1a;76.WEB渗透测试-信息收集- WAF、框架组件识别&#xff08;16&#xff09; java&#xff…
阅读更多...
The Llama 3 Herd of Models.Llama 3 模型论文全文

The Llama 3 Herd of Models.Llama 3 模型论文全文

现代人工智能(AI)系统是由基础模型驱动的。本文提出了一套新的基础模型，称为Llama 3。它是一组语言模型，支持多语言、编码、推理和工具使用。我们最大的模型是一个密集的Transformer，具有405B个参数和多达128K个tokens的上下文窗口。本文对Llama 3进行了广泛的实证评价。我们…
阅读更多...
【Django】前端技术HTML常用标签(开发环境vscode)

【Django】前端技术HTML常用标签(开发环境vscode)

文章目录 安装两个常用插件HTML常用标签定义文档类型DOCTYPE网页的结构html/head//title/body/div标题h1/h2/h3/h4/h5分割线hr段落 p列表ul/li&#xff0c;ol/li超链接a文本span图片img按钮button表格table&#xff08;table、tr、th、td&#xff09;表单form 安装两个常用插件…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023