FPGA:有限状态机

于 2024-07-26 22:27:21 发布
阅读量295 收藏 9
点赞数 6
分类专栏： FPGA学习日记 文章标签： fpga开发 verilog vivado 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50164178/article/details/140593203
版权

从以下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

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

张起灵ovo
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FPGA状态机verilog代码
04-13
标题中的"FPGA状态机verilog代码"指的是使用Verilog语言编写的状态机实现，通常用于FPGA项目中。状态机设计的核心在于定义不同的状态，以及状态之间的转换条件和行为。在Verilog中，这可以通过结构化的方式实现，...
如何在FPGA中实现状态机
08-31
状态机通过在有限数量的状态之间进行转换来处理任务，每个时刻只能处于一个状态。FPGA，即Field-Programmable Gate Array，因其可编程性，非常适合实现状态机，特别是在执行诸如通信协议等需要序列控制的任务时。 ...
FPGA——状态机
Morzart的博客
01-07 2026
首先，FPGA是Field Programmable Gate Array的简写，翻译过来就是“现场可编程门阵列”。它是一个集成电路，可以对其反复配置以执行无限多的功能。具体而言，FPGA就是由可编程逻辑功能块和可编程I/O模块排成阵列组成，并由可编程的内部连线连接这些逻辑功能块和I/O模块来实现不同的设计，而一般来说，现在都是用的Verilog来进行这些方面的编程。
FPGA状态机设计
FPGA小学生的博客
01-11 7119
状态机： 状态机是逻辑设计里面重要的内容，许多公司的硬件和逻辑工程师面试中，状态机设计几乎是必选题目。所以本次以状态机为话题进行重点讨论，以及如何写好状态机。 状态机全称是有限状态机（Finite State Machine、FSM），是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 本篇博客对相关概念以及使用状态机实现特定字符串的检测，并通过程序具体理解一段式、两段式以及三段式状态机的区别以及优缺点。 ~~ ~~ ~~ ~~ 1. 状态机基础概念： 状态机分摩尔（Moore
【FPGA/IC】状态机FSM的各种写法（一段式、二段式、三段式、摩尔型Moore、米勒型Mealy）
热门推荐
孤独的单刀
08-05 5万+
FPGA状态机（一段式、二段式、三段式）、摩尔型（Moore）和米勒型（Mealy）
FPGA学习之状态机
qq_30093417的博客
10-18 4169
新手玩家对于状态机的学习和巩固使用
FPGA：什么是状态机？状态机的结构？状态机怎么用？
m0_46830519的博客
06-27 2171
状态机怎么玩
FPGA Verilog编写状态机学习
小pp的博客
03-06 1649
三段式状态机（Three-phase state machine）是一种更加模块化和可维护的状态机实现方式。它将状态机的执行过程分为三个阶段：在这个阶段，当前状态被寄存，以便在下一个时钟周期中使用。在这个阶段，基于当前状态和输入条件，计算出下一个状态和输出。在这个阶段，将计算出的输出赋值给输出信号。
FPGA状态机设计详解
weixin_66634995的博客
05-21 1158
• IDLE：初始状态，对输入的码流进行检测，若为1则跳转到状态A，则为0保留在该状态• A: 对输入的码流进行检测，若为0则跳转到状态B（10），则为1保留在该状态• B: 对输入的码流进行检测，若为0则跳转到状态C（100），则为1则跳转到状态A（101）• C: 对输入的码流进行检测，若为1则跳转到状态D（1001），则为0则跳转到状态IDLE（1000）• D: 对输入的码流进行检测，若为0则跳转到状态E（10010），则为1则跳转到状态A（10011）
FPGA-状态机
qq_43409587的博客
02-22 1560
状态机简介
FPGA IIC的状态机实现
qq_52245062的博客
12-19 1519
FPGA IIC状态机
谈 verilog 有限状态机设计——FPGA的灵魂
qq_42196515的博客
04-29 703
总结来自 《搭建你的数字积木 数字电路与逻辑设计 》 一书 有空大家可以去看看原书 简介 有限状态机（FSM）是fpga的灵魂，能够使得FPGA并行处理的基础上实现和CPU一样的串行处理效果，一样的灵活。同时相比CPU有一下的特性： （1）高效的顺序控制模型 （2）容易利用现成的EDA工具进行优化设计 （3）性能稳定，解决大规模集成电路的竞争和冒险，可以消除电路毛刺，强化系统功能 （4）高速性能，结合和FPGA的高速优势 （5）高可靠性，和CPU相比不需要繁杂的取指、译码、执行等过程 理论基础 FSM中有两
FPGA-有限状态机相关材料汇总
08-31
有限状态机（Finite State Machine, FSM）是FPGA设计中的一个重要组成部分，尤其在处理时序控制和逻辑流程方面。本资料汇总将深入探讨FPGA中的有限状态机及其相关知识。 首先，我们要理解什么是有限状态机。有限...
跟着我从零开始入门FPGA之（有限状态机)
08-21
有限状态机（Finite State Machine，FSM）是数字电路设计中的一种基本概念，广泛应用于 FPGA、单片机等领域。有限状态机是一种数学模型，用于描述系统的行为和状态转换。 在本文中，我们将从零开始入门 FPGA 之有限...
fpga 状态机 写法
12-21
现在大家比较统一的观点是，状态机的写法应该是用三段式写法，即第一部分说明初始状态，current_state，第二部分是状态机的状态转化的描述，第三部分是每一步状态的组合逻辑的描述。这样写调理更加清晰，也更加利于...
实验三 FPGA使用Verilog HDL设计加法器
m0_74102824的博客
07-22 359
无。
实验二 FPGA使用Verilog HDL设计分频器
m0_74102824的博客
07-22 386
本次实验中，将always块中的敏感事件写错了，经过仿真结果找出问题；在秒表计数的if-else语句中将计数的变量搞错，导致不能正确的实现秒表过一秒加一的操作，通过本次实验，我不仅掌握了使用Vivado软件进行综合、仿真、布线、下载和测试的方法，也加强了对Verilog HDL语言的掌握和应用能力。
PWM再理解（1）
weixin_45547259的博客
07-18 827
昨天过于劳累，十点睡觉，本来想梳理一下PWM，今天补上。
FPGA与ASIC：深入解析芯片设计的双子星
最新发布
weixin_65793170的博客
07-23 740
在半导体世界里，FPGA（Field-Programmable Gate Array，现场可编程门阵列）与ASIC（Application-Specific Integrated Circuit，专用集成电路）是两种截然不同的芯片设计策略，各自在不同的应用领域发光发热。这里将深入了解一下，这两种技术的核心差异，探讨它们的设计流程，分析各自的优缺点，以及展望未来的发展趋势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值