简单周期CPU的Verliog代码的实现、通过在proteus上进行C51仿真LED流水灯实验

已于 2024-01-05 20:13:37 修改
阅读量1.9k 收藏 31
点赞数 32
文章标签： proteus
于 2024-01-05 20:12:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76714049/article/details/135416836
版权

文章目录

一、 单周期CPU的设计原理

1.1 单周期CPU概述

中央处理器，即CPU，作为计算机系统的运算和控制核心，是信息处理、程序运行的最终执行单元。在CPU内部，电平从低到高变化的瞬间称为时钟上升沿，两个相邻时钟上升沿之间的时间间隔称为一个时钟周期。单周期CPU指的是一条指令的执行在一个时钟周期内完成，然后开始下一条指令的执行，即一条指令用一个时钟周期完成。

1.2 CPU工作原理

CPU在处理指令时，一般需要经过以下几个步骤：
(1) 取指令(IF)：根据程序计数器PC中的指令地址，从存储器中取出一条指令，同时，PC根据指令字长度自动递增产生下一条指令所需要的指令地址，但遇到“地址转移”指令时，则控制器把“转移地址”送入PC，当然得到的“地址”需要做些变换才送入PC。
(2) 指令译码(ID)：对取指令操作中得到的指令进行分析并译码，确定这条指令需要完成的操作，从而产生相应的操作控制信号，用于驱动执行状态中的各种操作。
(3) 指令执行(EXE)：根据指令译码得到的操作控制信号，具体地执行指令动作，然后转移到结果写回状态。
(4) 存储器访问(MEM)：所有需要访问存储器的操作都将在这个步骤中执行，该步骤给出存储器的数据地址，把数据写入到存储器中数据地址所指定的存储单元或者从存储器中得到数据地址单元中的数据。
(5) 结果写回(WB)：指令执行的结果或者访问存储器中得到的数据写回相应的目的寄存器中。
CPU的指令处理过程如下：
在这里插入图片描述

2.1 指令系统的设计

2.1.1 概述
本文所设计的单周期CPU的指令系统采用类似MIPS的设计风格，包括以下四类指令：

(1) 运算类指令；

(2) 传送类指令；

(3) 存储类指令；

(4) 控制类指令；

其中，所有指令的操作码部分用4位二进制表示，寄存器编号用3位二进制表示。在下述的具体设计表示中，以助记符表示的是汇编指令；以代码表示的则是二进制机器指令。

2.2 整体框架的设计

本文所设计的单周期CPU的整体框架主要包括七部分：程序计数器、指令寄存器、寄存器组、算术逻辑单元、数据存储器、控制单元和顶层模块。具体框架如下：
在这里插入图片描述

3.具体实现

程序计数器
代码如下：

module PC(    
    input clk,    
    input [15:0] PCin,    
    input PCWre,    
    input Reset,    
    output reg [15:0] PCout    
);    
      
    initial begin    
        PCout <= 0;   
    end  
        
    always@(posedge clk) begin    
        if(Reset == 0) begin    
            PCout <= 0;    
        end    
        else if(PCWre == 0) begin    
            PCout <= PCout;    
        end    
        else begin    
            PCout <= PCin;    
        end    
    end  
        
endmodule

指令存储器
代码如下：

module InsMemory(    
    input InsMemRW,    
    input [15:0] address,    
    output reg [15:0] DataOut    
);    
 
    reg [7:0] mem [0:127];   
 
    initial begin    
        DataOut = 16'b1111000000000000;  
        $readmemb("Instructions.txt", mem);      
    end   
      
    always@(*) begin   
        DataOut[15:8] <= mem[address];    
        DataOut[7:0] <= mem[address+1];  
    end   
       
endmodule

寄存器组
代码如下：

module RegFile(    
    input CLK,    
    input RST,    
    input RegWre,    
    input [2:0] ReadReg1,    
    input [2:0] ReadReg2,    
    input [2:0] WriteReg,    
    input [15:0] WriteData,    
    output [15:0] ReadData1,    
    output [15:0] ReadData2    
);    
  
    reg [15:0] regFile[0:7];  
       
    integer i;    
      
    assign ReadData1 = regFile[ReadReg1];   
    assign ReadData2 = regFile[ReadReg2];  
        
    always @ (negedge CLK) begin    
        if (RST == 0) begin    
            for(i=1;i<8;i=i+1)    
                regFile[i] <= 0;    
        end    
        else if(RegWre == 1 && WriteReg != 0) begin    
            regFile[WriteReg] <= WriteData;    
        end    
    end    
            
endmodule

算数逻辑单元
代码如下：

module ALU(    
    input [2:0] ALUopcode,    
    input [15:0] rega,    
    input [15:0] regb,    
    output reg [15:0] result,    
    output zero,    
    output sign    
);    
  
    assign zero = (result==0)?1:0;    
    assign sign = result[15];    
      
    always @( ALUopcode or rega or regb ) begin    
        case (ALUopcode)    
            3'b000 : result = rega + regb;    
            3'b001 : result = rega - regb;    
            3'b010 : result = regb << rega;    
            3'b011 : result = rega | regb;    
            3'b100 : result = rega & regb;    
            3'b101 : result = (rega < regb)?1:0;     
            3'b110 : begin    
                if (rega<regb &&(( rega[15] == 0 && regb[15]==0) ||    
                (rega[15] == 1 && regb[15]==1))) result = 1;    
                else if (rega[15] == 0 && regb[15]==1) result = 0;    
                else if ( rega[15] == 1 && regb[15]==0) result = 1;    
                else result = 0;    
            end    
            3'b111 : result = regb;    
        endcase    
    end   
       
endmodule

数据存储器
代码如下：

module DataMemory(    
    input clk,    
    input [15:0] address,    
    input RD,    
    input WR,    
    input [15:0] DataIn,    
    output [15:0] DataOut    
);    
    
    reg [7:0] ram[0:127];  
        
    integer i;    
      
    initial begin;    
        for(i=0;i<128;i=i+1)    
            ram[i]<=0;    
    end    
       
    assign DataOut[7:0] = (RD == 0)? ram[address+1]:8'bz;    
    assign DataOut[15:8] = (RD == 0)? ram[address]:8'bz;    
   
    always@(negedge clk) begin    
        if(WR == 0) begin    
            if(address>=0 && address<128) begin    
                ram[address] <= DataIn[15:8];    
                ram[address+1] <= DataIn[7:0];     
            end    
        end    
    end  
        
endmodule

控制单元
代码如下：

module ControlUnit(    
    input [3:0] opcode,    
    input zero,    
    input sign,    
    output reg PCWre,    
    output reg ALUSrcA,    
    output reg ALUSrcB,    
    output reg DBDataSrc,    
    output reg RegWre,    
    output reg InsMemRW,    
    output reg RD,    
    output reg WR,    
    output reg RegDst,    
    output reg ExtSel,    
    output reg [1:0] PCSrc,    
    output reg [2:0] ALUOp    
);    
  
    initial begin    
        RD = 1;    
        WR = 1;    
        RegWre = 0;   
        PCWre = 0;   
        InsMemRW = 1;    
    end   
       
    always@ (opcode) begin    
        case(opcode)     
            4'b0000:begin // add    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b000;    
            end    
            4'b0001:begin //addi    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 1;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 0;    
                ExtSel = 1;    
                ALUOp = 3'b000;    
            end    
            4'b0010:begin //sub    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b001;    
            end  
            4'b0011:begin // or    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b011;    
            end     
            4'b0100:begin // ori    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 1;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 0;    
                ExtSel = 0;    
                ALUOp = 3'b011;    
            end    
            4'b0101:begin //and    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b100;    
            end    
            4'b0110:begin //sll    
                PCWre = 1;    
                ALUSrcA = 1;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b010;    
            end    
            4'b0111:begin //slt    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ALUOp = 3'b110;    
            end  
            4'b1000:begin //mov    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 1;    
                ExtSel = 1;    
                ALUOp = 3'b111;    
            end  
            4'b1001:begin //movi    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 1;    
                DBDataSrc = 0;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                RegDst = 0;    
                ExtSel = 1;    
                ALUOp = 3'b111;    
            end      
            4'b1010:begin //sw    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 1;    
                RegWre = 0;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 0;    
                ExtSel =1;    
                ALUOp = 3'b000;    
            end    
            4'b1011:begin //lw    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 1;    
                DBDataSrc = 1;    
                RegWre = 1;    
                InsMemRW = 1;    
                RD = 0;    
                WR = 1;    
                RegDst = 0;    
                ExtSel = 1;    
                ALUOp = 3'b000;    
            end   
            4'b1100:begin //beq    
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                RegWre = 0;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                ExtSel = 1;    
                ALUOp = 3'b001;    
            end    
            4'b1101:begin  //bgtz  
                PCWre = 1;    
                ALUSrcA = 0;    
                ALUSrcB = 0;    
                RegWre = 0;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                ExtSel = 1;    
                ALUOp = 3'b001;    
            end    
            4'b1110:begin //j    
                PCWre = 1;    
                RegWre = 0;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
                ALUOp = 3'b010;    
            end    
            4'b1111:begin //halt    
                PCWre = 0;    
                RegWre = 0;    
                InsMemRW = 1;    
                RD = 1;    
                WR = 1;    
            end    
            default:begin    
                RD = 1;    
                WR = 1;    
                RegWre = 0;    
                InsMemRW = 0;    
            end    
        endcase    
    end   
       
    always@(opcode or zero or sign) begin    
        if(opcode == 4'b1110) // j    
            PCSrc = 2'b10;    
        else if(opcode == 4'b1100) begin  
            if(zero == 1)  
                PCSrc = 2'b01;  
            else  
                PCSrc = 2'b00;  
        end  
        else if(opcode == 4'b1101) begin  
            if(zero == 0 && sign == 0)    
                PCSrc = 2'b01;    
            else    
                PCSrc = 2'b00;  
        end    
        else begin    
            PCSrc = 2'b00;    
        end    
    end   
       
endmodule

顶层模块实现
在这里插入图片描述

二、通过在proteus上进行C51仿真LED流水灯实验

1、绘制原理图

1）添加元件
（1）点击绘制原理图按钮。

在这里插入图片描述
（2）左键单击元件，然后再点击P按钮，进入元件选择界面。

（3）在 Keywords 处输入 AT89C51 ，然后在中间的窗口内双击AT89C51芯片，即可添加到元件列表中，而后依次添加LED-YELLOW、RES

在这里插入图片描述

2）摆放元件

（1）左击元件列表窗内的 AT89C51 芯片，然后再原理图编辑窗口内左击摆放。
在这里插入图片描述
（2）左击元件列表内的 LED-YELLOW ，再点击 旋转按钮 ，可以在预览窗内看见元件顺时针旋转了下，再在原理图编辑框内一次摆放LED灯共8个。

在这里插入图片描述
（3）再按照（2）的步骤依次摆放8个电阻，然后左键双击“10K”，弹出修改值的对话框，将10K修改为300，以至于让LED更亮。
在这里插入图片描述
（4）拉一条主线。（左击一下起点，然后移动鼠标，然后双击一下终点，即可拉一条主线）
在这里插入图片描述
（5）连接管脚。（左击一下起点和左击一下终点即可连接）
在这里插入图片描述
（6）点击终端接口→选择POWER，放置电源，然后左键双击电源图标，修改为VCC，再点击OK。
在这里插入图片描述
（7）使用 LBL 为支线标记编号，连接到主线的支线，需要对支线进行编号才能正常连接，否则后面需要正常实验成功（使用方法：点击 LBL 后，在左键单击支线上，修改值）

在这里插入图片描述

2、编写51程序

1）创建一个工程
（1）打开 Keil 软件，点击 Project → New uVision Project …

（2）给工程命名。（这里我取名为 LED ）
在这里插入图片描述
（3）在搜索框内输入 AT89C51 ，再选中 AT89C51 芯片，然后点击 OK 。
在这里插入图片描述
2）编写main.c文件
（1）点击左上角新建文件，再在文本框内复制粘贴51程序代码。`

//51单片机编程常用的头文件
    #include <reg51.h>
    #include <intrins.h>
    //延迟函数
    void delay_ms(int a)
    {
        int i,j;
        for(i=0;i<a;i++)
        {
            for(j=0;j<1000;j++) _nop_();
    
        }
    }
    
    void main(void)
    {
        while(1)
        {
            P0=0xfe;
            delay_ms(50);
            P0=0xfd;
            delay_ms(50);
            P0=0xfb;
            delay_ms(50);
            P0=0xf7;
            delay_ms(50);
            P0=0xef;
            delay_ms(50);
            P0=0xdf;
            delay_ms(50);
            P0=0xbf;
            delay_ms(50);
            P0=0x7f;
            delay_ms(50);
        }
    }

在这里插入图片描述
（2）点击保存按钮，再命名为main.c文件（一定要加.c后缀，不然就不是C文件了），再点击保存。
在这里插入图片描述
（3）右键点击 Source Group 1 ，再点击 Add Existing Files to Group “Source Group 1”…
在这里插入图片描述
（4）选中刚刚创建的 main.c 文件，并点击 Add 。
在这里插入图片描述
（5）可以看见 main.c 文件已经在 Source Group 1 目录下面了。
在这里插入图片描述
3）生成 .hex 文件
（1）点击魔法棒，在弹出的窗口内选择 Output ，再勾选 Create HEX File ，然后点击 OK。
在这里插入图片描述
（2）点击编译按钮，进行编译，编译成功并生成了两个头文件（这一步不可忽略，否则无法生成 .hex 文件）
在这里插入图片描述

3、开始仿真

（1）回到Proteus软件的原理图内，双击 AT89C51 芯片后，在弹出的窗口的 Program File 一栏从刚才 keil 软件编译后的路径中添加 .hex 文件，再点击 OK 。在这里插入图片描述（2）点击调试按钮，开始仿真。

（3）仿真结果
在这里插入图片描述
在这里插入图片描述

小浣熊x
关注
  • 32
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
verilog流水灯代码
08-27
verilog流水灯代码
三级16选1数据选择器verilog实现
04-09
16选1数据选择器（MUX）分为三级实现的verilog代码，三个文件，可以直接调试仿真。
Proteus+FPGA项目设计联合仿真
Mr_Wuuuuuu的博客
05-31 1044
本项目包含proteus仿真arduino，fpga控制pwm，solidworks制图，web网站。项目简介：主要包含温度传感器，声光模块，lcd显示屏，直流电机，烟雾传感器，红外线传感器。这里先post一个arduino代码。（由于代码是自己写的，所以注释废话啥的比较多，见谅。由于自己在做项目的时候发现网上的有关资源少得可怜，特写此博客，希望能够帮到后来人。注：以上内容仅供参考，如有因为抄袭而引起的事件，本人概不负责！solidwork源文件。solidwork示例。
【计算机组成原理】单周期MIPS CPU的设计
最新发布
qq_59961910的博客
05-21 724
单周期处理器是指所有指令均在一个时钟周期内完成的处理器，尽管不同指令执行时间不同，但时钟周期必须设计成对所有指令都等长，根据木桶原理，单周期处理器的时钟周期取决于执行速度最慢的指令。指令执行过程中 ALU 的两个源操作数均来自于寄存器文件输出,其中 R1是寄存器 R1#的值，R2是寄存器 R2#的值，R1#来自于指令字中的Rs 字段，R2#来自于指令字中的Rt 字段，运算结果写人目的寄存器Rd 中。指令取出后即可进入执行周期，下面就能设计支持最为简单的R型指令的数据通路，使得执行一条指令的CPU得以运行。
Logisim平台上的单周期和多周期MIPSCPU设计（计组课设）
热门推荐
WJY2003IBDM的博客
06-18 2万+
实验一、单周期MIPS CPU的设计1.实验目的--掌握硬布线控制器设计的基本原理--在Logisim平台中设计实现MIPS单周期CPU2.主要任务--绘制单周期MIPS CPU数据通路：对应子电路图“单周期MIPS（硬布线）”--实现单周期硬布线控制器（纯组合电路）：对应子电路图“单周期硬布线控制器”--测试联调。
微机原理实验：流水灯实验
cccccczl0131的博客
12-20 4875
1、通过对并行接口8255编程、调试，掌握仿真工具软件Proteus的使用方法，掌握8255的基本编程及调试方法，掌握编写控制并行接口程序的方法。2、学生在实验前必须认真预习教材与资料中的相关内容，绘制流程图，编写源程序，为实验做好充分准备，实验后撰写实验报告。2、编写程序源代码，实现8255控制8个指示灯，循环点亮（瞬间只有一个灯亮）。11111110B 字模。实现8255控制8个指示灯，循环点亮（瞬间只有一个灯亮）。1、建立实验工程文件，绘制实验的原理图方案；
交通灯的proteus仿真和用VHDL实现的代码
12-21
用proteus仿真的交通灯仿真文件，还有用VHDL实现的代码
Proteus 仿真运算器实验
06-05
Proteus 仿真运算器，验证74LS181的功能，使用了总线结构，实现8位运算，打开直接可运行。
proteus 仿真(按键+计数器+七段码)
跑上岸晒太阳的鱼滴空间
09-19 1万+
74HC4024为计数器，4511为BCD-7段码锁存译码驱动器。  
用VerilogHDL设计一个与门逻辑，并进行前仿和后仿
weixin_34015336的博客
07-15 3813
执行菜单命令【File】-【New Project Wizard…】，创建工程向导。 在What is the working directory for this project?下选择项目存储地址工作目录，What is the name of this project?下填写工程名，最后一栏填写顶层文件名。 添加已存在文件（可选），在【File name】下...
ar编码matlab仿真_实时仿真之FPGA篇 | Speedgoat的可编程FPGA方案和可配置FPGA方案
weixin_39665507的博客
11-02 469
1. FPGA是什么？FPGA（现场可编程门阵列）：Field Programmable Gate Array， 可重复编程的芯片。集成逻辑模块和可编辑的布线资源， FPGA以特定的方式配置，实现特定硬件功能；而无需要设计新的PCB板。基于Verilog或VHDL硬件描述语言开发，以硬件电路方式运行“程序”。主要应用在通讯、信号处理及超高速仿真中。2. 实时仿真为什么需要FPGA板卡FPGA板卡提...
verilog之四位全加器的编译及仿真（用开源免费的软件——iverilog+GTKWave）
weixin_30617561的博客
04-18 714
四位全加器的verilog的代码比比皆是，这里上一个比较简单的： /* 4位全加器全加器需要有输入输出，需要有下级向上进位的输入， 需要有向上一位进位的输出。大家看一下，这个模块已经包含全部的输入输出信息。 大家都知道，N位加法器得出来的出来的和最多是N+1位 因此可以清晰从下面代码中看到相关信息。 然后assign用的是阻塞赋值。相加即满足相关的需求。 */ mod...
Proteus使用指南
#法外狂徒张三的博客
05-30 5044
【Proteus】—{使用指南}—{快捷键}一、快捷键二、proteus元件库对照表1.Analog Ics2.Capacitors:3 .CMOS 4000 series4.Connectors 接头5.Data Converters 数据转化器6.Debugging TOOls 调试工具7.Diodes 二极管8.Inductors 电感9.Laplace Primitives 拉普拉斯模型10.Memory ICs 存储器芯片（包括常用的I2C,SPI芯片）杂项(Miscellaneous)无子类无子
ProteusMCU仿真
武力戡乱的博客
03-12 929
proteus单片机仿真大全
verilog简单实现串口（精简版）
做减求空
10-09 6983
//uart 2017.10.9 发送接收到的数据 //波特率9600 8个数据位 一个停止位 无奇偶校验 module uart( clk, //50Mhz rst_n, //reset rx, //input tx //ouptut ); input clk,rst_n...
proteus简介(界面的讲解)
gududesiling的专栏
01-01 6113
    近期我看了一本书，是proteus教程（在电子线路设计，制版，与仿真）：是南阳理工和平顶山学院的老师合编的，也确实挺令我意外的，在我们看来这不是很好的学校，不过编的书确实挺不错的，在业界也是走在前面的，哈哈。    proteus中包括有两个重要的软件：isis（智能原理图输入系统，系统设计与仿真的基本平台，我们平常用的就是这个系统），ARES（高级PCB布线编辑软件）。    I
verilog实现led流水灯设计
11-06
Verilog是一种硬件描述语言，可用于实现数字逻辑电路。要实现LED流水灯设计，首先需要定义输入和输出端口。 在Verilog中，输入端口用`input`关键字定义，输出端口用`output`关键字定义。对于LED流水灯设计，我们需要一个输入端口来控制LED的流动速度，一个输出端口用来连接LED灯。 ```verilog module LED_Flash( input clk, // 输入端口，时钟信号 output reg [7:0] led // 输出端口，用来控制LED灯 ); // 定义内部变量 reg [2:0] counter; // 计数器，用来控制LED灯的流动速度 always @(posedge clk) begin if(counter == 3'd7) // 计数器达到最大值时，重置为0 counter <= 3'd0; else counter <= counter + 1; end always @(posedge clk) begin case(counter) // 根据计数器的值选择输出 3'd0: led <= 8'b00000001; 3'd1: led <= 8'b00000010; 3'd2: led <= 8'b00000100; 3'd3: led <= 8'b00001000; 3'd4: led <= 8'b00010000; 3'd5: led <= 8'b00100000; 3'd6: led <= 8'b01000000; 3'd7: led <= 8'b10000000; default: led <= 8'b00000000; endcase end endmodule ``` 在上面的代码中，我们使用一个3位宽的计数器来控制LED灯的流动速度。当计数器达到最大值时，重置为0，并通过`case`语句选择输出。 LED灯的流动速度可以通过改变时钟信号的频率来调节。在实际电路中，需要将`clk`端口连接到适当的外部时钟源上。 以上就是使用Verilog实现LED流水灯设计的代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值