devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于FPGA的交通灯设计（加强版，涵盖倒计时）_12mhz分频成1hz

作者：Gausst松鼠会 | 2024-06-11 06:48:35

赞

踩

12mhz分频成1hz

##一、实验任务要求

adaf8de744ca489e930a646331da4efb.png

 

1)实现一交通十字路口处红绿灯的基本定时控制功能，要求东西方向灯色循环为绿灯45秒，黄灯5秒，左拐灯15秒，黄灯5秒，红灯40秒，黄灯5秒；南北方向灯色循环为红灯65秒，黄灯5秒，绿灯20秒，黄灯5秒，左拐灯15秒，黄灯5秒。

2)实现东西方向和南北方向各种灯的倒计时数码显示功能。

 

##二、LED分模块设计（用于调用使用）

  1. module LED (seg_data_1,seg_data_2,seg_led_1,seg_led_2);
  2.  
  3. 	input [3:0] seg_data_1;						//数码管需要显示0~9十个数字，所以最少需要4位输入做译码
  4. 	input [3:0] seg_data_2;						//小脚丫上第二个数码管
  5. 	output [8:0] seg_led_1;						//在小脚丫上控制一个数码管需要9个信号 MSB~LSB=DIG、DP、G、F、E、D、C、B、A
  6. 	output [8:0] seg_led_2;						//在小脚丫上第二个数码管的控制信号  MSB~LSB=DIG、DP、G、F、E、D、C、B、A
  7.  
  8.         reg [8:0] seg [9:0];                                            //定义了一个reg型的数组变量，相当于一个10*9的存储器，存储器一共有10个数，每个数有9位宽
  9.  
  10.         initial                                                         //在过程块中只能给reg型变量赋值，Verilog中有两种过程块always和initial
  11.                                                                         //initial和always不同，其中语句只执行一次
  12. 	    begin
  13.               seg[0] = 9'h3f;                                           //对存储器中第一个数赋值9'b00_0011_1111,相当于共阴极接地，DP点变低不亮，7段显示数字  0
  14. 	      seg[1] = 9'h06;                                           //7段显示数字  1
  15. 	      seg[2] = 9'h5b;                                           //7段显示数字  2
  16. 	      seg[3] = 9'h4f;                                           //7段显示数字  3
  17. 	      seg[4] = 9'h66;                                           //7段显示数字  4
  18. 	      seg[5] = 9'h6d;                                           //7段显示数字  5
  19. 	      seg[6] = 9'h7d;                                           //7段显示数字  6
  20. 	      seg[7] = 9'h07;                                           //7段显示数字  7
  21. 	      seg[8] = 9'h7f;                                           //7段显示数字  8
  22. 	      seg[9] = 9'h6f;                                           //7段显示数字  9
  23.             end
  24.  
  25.         assign seg_led_1 = seg[seg_data_1];                         //连续赋值，这样输入不同四位数，就能输出对于译码的9位输出
  26.         assign seg_led_2 = seg[seg_data_2];
  27.  
  28. endmodule

##三、主程序代码

  1. module traffic1(Clk_12M,Rst,LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2,Seg7_VH,Seg7_VL,led15,led16,led17,ledCntDis);
  2.   parameter S0 = 0;   //主路绿灯，支路红灯
  3.   parameter S1 = 1;   //主路黄灯，支路红灯
  4.   parameter S2 = 2;   //主路蓝灯，支路红灯
  5.   parameter S3 = 3;   //主路黄灯，支路黄灯
  6.   parameter S4 = 4;   //主路红灯，支路绿灯
  7.   parameter S5 = 5;   //主路红灯，支路黄灯
  8.   parameter S6 = 6;   //主路红灯，支路蓝灯
  9.   parameter S7 = 7;   //主路黄灯，支路黄灯
  10.   input Clk_12M,Rst;
  11.   output LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2;
  12.   output [8:0]Seg7_VH,Seg7_VL;
  13.   output led15,led16,led17;
  14.   reg LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2;
  15.   reg Clk_1Hz;//分频器
  16.   reg [31:0]Cnt_1Hz;//计数器
  17.     output reg[3:0] ledCntDis;

该模块是一个交通信号灯的Verilog描述，通过控制LED灯和数码管来显示不同的交通信号状态。以下是对该模块的解释：

输入：
- Clk_12M：12MHz的时钟信号
- Rst：复位信号

输出：
- LedR_1, LedG_1, LedB_1：控制第一个交通信号灯的红、绿、蓝LED灯
- LedR_2, LedG_2, LedB_2：控制第二个交通信号灯的红、绿、蓝LED灯
- Seg7_VH, Seg7_VL：控制数码管显示的高位和低位数码
- led15, led16, led17：辅助LED灯输出
- ledCntDis：控制数码管显示的计数器输出

内部变量：
- Clk_1Hz：1Hz的时钟信号，通过分频器实现
- Cnt_1Hz：1Hz的计数器，用于控制信号灯状态的切换

参数：
- S0-S7：交通信号灯的不同状态，例如S0表示主路绿灯，支路红灯

该模块通过时钟信号进行节拍控制，通过状态机的方式实现交通信号灯的循环切换。通过适时改变LED灯和数码管的输出，实现不同状态下的交通信号显示。具体的状态与信号灯显示对应关系是根据参数定义的。

在每个时钟周期，计数器Cnt_1Hz会自增，并根据计数器的值切换交通信号灯的状态和LED灯的输出。同时，数码管和辅助LED灯也会根据需要进行相应的显示。

需要注意的是，该模块中的LedR_1, LedG_1等输出信号使用reg声明，表示它们是可寄存器的输出信号。

 

 

  1. /*分频器模块*/
  2.   always@(posedge Clk_12M or negedge Rst)
  3.   begin
  4.     if(!Rst)
  5.       begin
  6.         Cnt_1Hz<=1;
  7.         Clk_1Hz<=1;  //分频器和计数器全部设置为初值1
  8.       end
  9.     else
  10.       begin
  11.         if(Cnt_1Hz>=6000000)//当计数器大于等于25的10的六次方
  12.           begin
  13.             Cnt_1Hz<=1;//计数器置一
  14.             Clk_1Hz<=~Clk_1Hz;//分频器取反
  15.           end
  16.         else
  17.           Cnt_1Hz<=Cnt_1Hz+1;
  18.         end
  19.       end

这部分代码描述了一个分频器模块，用于将输入的12MHz时钟信号分频为1Hz的信号。以下是对代码的解释：

在`always @(posedge Clk_12M or negedge Rst)`的敏感列表中，当输入的时钟信号Clk_12M上升沿或复位信号Rst的下降沿发生时，会执行下面的代码块。

根据复位信号Rst的状态，通过if-else语句进行条件判断和处理：
- 如果复位信号Rst为低电平（即复位有效），则在分频器和计数器的初值都设置为1，表示初始状态。
- 如果复位信号Rst为高电平（即复位无效），则执行下面的逻辑。

在非复位状态下，判断计数器Cnt_1Hz是否大于等于6000000（即25 * 10^6），如果是，则表示达到了1Hz的分频要求：
- 将计数器Cnt_1Hz重新置为1。
- 将分频器Clk_1Hz取反，实现1Hz的方波输出。

如果计数器Cnt_1Hz未达到指定值，则将计数器的值加1。

通过这段代码，实现了将12MHz时钟信号分频为1Hz的功能，并且保持了分频器和计数器的状态在复位前后的一致性。分频器的输出Clk_1Hz可以作为其他模块中需要1Hz时钟信号的输入。
 

  1.  /*计数器模块*/
  2.       reg[7:0]Cnt70;//用于控制灯的变换
  3.       always@(posedge Clk_1Hz or negedge Rst)
  4.       begin
  5.         if(!Rst)
  6.           begin
  7.             Cnt70<=0;
  8.           end
  9.         else
  10.           begin
  11.             if(Cnt70>=115)
  12.               begin
  13.                 Cnt70<=0;//复位
  14.               end
  15.             else
  16.               Cnt70<=Cnt70+1;
  17.             end
  18.           end
  19. 			 
  20. 			 
  21. 			 /*计数器模块*/
  22.       reg[7:0]Cnt10;//用于控制数码管的变换
  23.       always@(posedge Clk_1Hz or negedge Rst)
  24.       begin
  25.         if(!Rst)
  26.           begin
  27.             Cnt10<=115;
  28.           end
  29.         else
  30.           begin
  31.             if(Cnt10<=0)
  32.               begin
  33.                 Cnt10<=115;//复位
  34.               end
  35.             else
  36.               Cnt10<=Cnt10-1;
  37.             end
  38.           end

这部分代码描述了两个计数器模块，分别用于计数到特定的值并进行复位操作。以下是对这两个代码块的解释：

第一个计数器模块：
- 声明了一个8位的寄存器变量Cnt70用于计数。
- 在`always @(posedge Clk_1Hz or negedge Rst)`的敏感列表中，当输入的时钟信号Clk_1Hz上升沿或复位信号Rst的下降沿发生时，会执行下面的代码块。
- 如果复位信号Rst为低电平（即复位有效），则将计数器Cnt70置为0。
- 如果复位信号Rst为高电平（即复位无效），则判断计数器Cnt70是否大于等于115。如果是，表示计数器已经达到了指定的值，将计数器Cnt70复位为0。
- 如果计数器Cnt70未达到指定值，则将计数器的值加1。

第二个计数器模块：
- 同样，声明了一个8位的寄存器变量Cnt10用于计数。
- 在`always @(posedge Clk_1Hz or negedge Rst)`的敏感列表中，当输入的时钟信号Clk_1Hz上升沿或复位信号Rst的下降沿发生时，会执行下面的代码块。
- 如果复位信号Rst为低电平（即复位有效），则将计数器Cnt10置为115。
- 如果复位信号Rst为高电平（即复位无效），则判断计数器Cnt10是否小于等于0。如果是，表示计数器已经减到了指定的值，将计数器Cnt10复位为115。
- 如果计数器Cnt10未减到指定值，则将计数器的值减1。

通过这两个计数器模块，可以实现对计数值的控制和复位操作。这些计数器可用于控制特定时间、时序或事件需要的计数和复位功能。

 

  1.     /*数码管模块*/
  2.           reg[7:0]CntDis;
  3. 			reg[7:0]Cnt71;
  4. 			 reg [7:0] Cnt61;
  5.           always@(posedge Clk_12M)//BCD码转换
  6.           begin
  7.             if(Cnt10>70)
  8.               begin
  9. 				  Cnt71[7:0]<=(Cnt10-70)/10;
  10.                 CntDis[7:4]<=Cnt71[3:0];
  11.                 Cnt61[7:0]<=Cnt10-((Cnt10-70)/10)*10-70;
  12. 					 CntDis[3:0]<=Cnt61[3:0];
  13.               end
  14.             else if (Cnt10>65)
  15.               begin
  16. 					Cnt71[7:0]<=(Cnt10-65)/10;
  17.                 CntDis[7:4]<=Cnt71[3:0];
  18.                 Cnt61[7:0]<=Cnt10-((Cnt10-65)/10)*10-65;
  19. 					 CntDis[3:0]<=Cnt61[3:0];
  20.               end
  21.             else if (Cnt10>50)
  22.               begin
  23.                 Cnt71[7:0]<=(Cnt10-50)/10;
  24.                 CntDis[7:4]<=Cnt71[3:0];
  25.                 Cnt61[7:0]<=Cnt10-((Cnt10-50)/10)*10-50;
  26. 					 CntDis[3:0]<=Cnt61[3:0];
  27.               end
  28.             else if (Cnt10>45)
  29.               begin
  30.                 Cnt71[7:0]<=(Cnt10-45)/10;
  31.                 CntDis[7:4]<=Cnt71[3:0];
  32.                 Cnt61[7:0]<=Cnt10-((Cnt10-45)/10)*10-45;
  33. 					 CntDis[3:0]<=Cnt61[3:0];
  34.               end
  35.             else if (Cnt10>25)
  36.               begin
  37.                 Cnt71[7:0]<=(Cnt10-25)/10;
  38.                 CntDis[7:4]<=Cnt71[3:0];
  39.                 Cnt61[7:0]<=Cnt10-((Cnt10-25)/10)*10-25;
  40. 					 CntDis[3:0]<=Cnt61[3:0];
  41.               end
  42.                else if (Cnt10>20)
  43.               begin
  44.                 Cnt71[7:0]<=(Cnt10-20)/10;
  45.                 CntDis[7:4]<=Cnt71[3:0];
  46.                 Cnt61[7:0]<=Cnt10-((Cnt10-20)/10)*10-20;
  47. 					 CntDis[3:0]<=Cnt61[3:0];
  48.               end
  49.               else if (Cnt10>5)
  50.               begin
  51.                 Cnt71[7:0]<=(Cnt10-5)/10;
  52.                 CntDis[7:4]<=Cnt71[3:0];
  53.                 Cnt61[7:0]<=Cnt10-((Cnt10-5)/10)*10-5;
  54. 					 CntDis[3:0]<=Cnt61[3:0];
  55. 					 end
  56. 					 else if (Cnt10>0)
  57.               begin
  58.                 Cnt71[7:0]<=Cnt10/10;
  59.                 CntDis[7:4]<=Cnt71[3:0];
  60.                 Cnt61[7:0]<=Cnt10;
  61. 					 CntDis[3:0]<=Cnt61[3:0];
  62. 					 end
  63.               
  64. 				  
  65.               end
  66.               
  67.  always@(posedge Clk_12M)
  68.  begin
  69.  ledCntDis<=CntDis[3:0];
  70.  end             
  71.               //数码管调用实例           
  72. 				LED hex(CntDis[3:0],CntDis[7:4],Seg7_VL,Seg7_VH);

这部分代码描述了一个数码管模块，它用于将计数器的值转换为BCD码，并将BCD码通过数码管进行显示。以下是对代码的解释：

在第一个always块中，通过对12MHz时钟信号Clk_12M的上升沿进行敏感监听，实现对计数器Cnt10值的转换和BCD码的生成。
- 根据不同的计数范围，将Cnt10的值减去一个基准并除以10，得到一个高位数。
- 通过减法、除法和取余运算，计算得到一个低位数。
- 通过赋值操作，将高位数和低位数分别存储到CntDis的7:4位和3:0位。

在第二个always块中，对12MHz时钟信号Clk_12M的上升沿进行敏感监听，将CntDis的低4位赋值给ledCntDis。这样，ledCntDis可以作为控制数码管显示的信号，通过连接到相应的LED显示模块。

最后，通过实例化一个名为hex的LED模块，将CntDis的3:0位和7:4位分别连接到Seg7_VL和Seg7_VH输入，从而实现数码管的显示。

通过这段代码，可以将计数器的值转换为BCD码，并通过数码管进行显示，实现实时的数值显示功能。

 

  1.  //状态转换
  2.               reg [2:0] state;
  3.               always@(posedge Clk_12M or negedge Rst)
  4.               begin
  5.                 if(!Rst)
  6.                   begin
  7.                     LedR_1<=0;
  8.                     LedG_1<=0;
  9.                     LedB_1<=0;
  10.                     LedR_2<=0;
  11.                     LedG_2<=0;
  12.                     LedB_2<=0;
  13.                   end
  14.                 else
  15.                   begin
  16.                 case(state)
  17.                   S0://主路绿灯45s
  18.                   begin
  19.                     if(Cnt70<=45)
  20.                       begin
  21.                         LedR_1<=1;
  22.                         LedG_1<=0;
  23.                         LedB_1<=1;
  24.                         LedR_2<=0;
  25.                         LedG_2<=1;
  26.                         LedB_2<=1;
  27.                       end
  28.                     else
  29.                       state<=S1;
  30.                     end
  31.                   S1://主路黄灯5s
  32.                   begin
  33.                     if(Cnt70<=50)
  34.                       begin
  35.                         LedR_1<=0;
  36.                         LedG_1<=0;
  37.                         LedB_1<=1;
  38.                         LedR_2<=0;
  39.                         LedG_2<=1;
  40.                         LedB_2<=1;
  41.                       end
  42.                     else
  43.                       state<=S2;
  44.                     end
  45.                     
  46.                     
  47.                     S2://主路蓝灯15s
  48.                     begin
  49.                       if(Cnt70<=65)
  50.                         begin
  51.                           LedR_1<=1;
  52.                           LedG_1<=1;
  53.                           LedB_1<=0;
  54.                           LedR_2<=0;
  55.                           LedG_2<=1;
  56.                           LedB_2<=1;
  57.                         end
  58.                       else
  59.                         state<=S3;
  60.                       end
  61.                       
  62.                       
  63.                     S3://主辅均5s黄
  64.                       begin
  65.                         if(Cnt70<=70)
  66.                           begin
  67.                           LedR_1<=0;
  68.                           LedG_1<=0;
  69.                           LedB_1<=1;
  70.                           LedR_2<=0;
  71.                           LedG_2<=0;
  72.                           LedB_2<=1;
  73.                         end
  74.                       else
  75.                         state<=S4;
  76.                       end
  77.                       
  78.                       
  79.                       S4://辅路绿20s
  80.                     begin
  81.                         if(Cnt70<=90)
  82.                           begin
  83.                           LedR_1<=0;
  84.                           LedG_1<=1;
  85.                           LedB_1<=1;
  86.                           LedR_2<=1;
  87.                           LedG_2<=0;
  88.                           LedB_2<=1;
  89.                         end
  90.                       else
  91.                         state<=S5;
  92.                       end
  93.                       
  94.                       S5://辅路黄灯5s
  95.                       begin
  96.                         if(Cnt70<=95)
  97.                           begin
  98.                           LedR_1<=0;
  99.                           LedG_1<=1;
  100.                           LedB_1<=1;
  101.                           LedR_2<=0;
  102.                           LedG_2<=0;
  103.                           LedB_2<=1;
  104.                         end
  105.                       else
  106.                         state<=S6;
  107.                       end
  108.                       
  109.                       
  110.                       S6://辅路蓝灯15s
  111.                       begin
  112.                         if(Cnt70<=110)
  113.                           begin
  114.                           LedR_1<=0;
  115.                           LedG_1<=1;
  116.                           LedB_1<=1;
  117.                           LedR_2<=1;
  118.                           LedG_2<=1;
  119.                           LedB_2<=0;
  120.                         end
  121.                       else
  122.                         state<=S7;
  123.                       end
  124.                       
  125.                       
  126.                       
  127.                       S7://主辅路均黄灯5s
  128.                       begin
  129.                         if(Cnt70>=111)
  130.                           begin
  131.                           LedR_1<=0;
  132.                           LedG_1<=0;
  133.                           LedB_1<=1;
  134.                           LedR_2<=0;
  135.                           LedG_2<=0;
  136.                           LedB_2<=1;
  137.                         end
  138.                       else
  139.                         state<=S0;
  140.                       end
  141.                       
  142.                   default 
  143.                  begin
  144.                     LedR_1<=0;
  145.                     LedG_1<=0;
  146.                     LedB_1<=0;
  147.                     LedR_2<=0;
  148.                     LedG_2<=0;
  149.                     LedB_2<=0;
  150.                   end
  151.                 endcase
  152.               end
  153.             end
  154.               
  155.               
  156.               
  157.              
  158.             assign {led17,led16,led15}=state;
  159.           endmodule

这段代码是一个用Verilog描述的状态转换逻辑。它根据时钟信号和复位信号来控制LED灯的状态。具体逻辑如下：

1. 如果复位信号（Rst）为低电平，则将所有LED灯的状态置为0。
2. 如果复位信号为高电平，则根据当前的状态（state）执行相应的操作。
3. 当前有三种状态（S0、S1、S2），对应不同的灯光控制逻辑。
   - S0状态：主路绿灯亮，持续45s。
   - S1状态：主路黄灯亮，持续5s。
   - S2状态：其他状态，可以在代码中后续定义。
        如此下去直到进行循环。

具体的操作是根据一个计数器（Cnt70）来控制。当计数器的值小于等于给定的时间时，对应的LED灯亮起；否则，切换到下一个状态。

这段代码中只给出了S0和S1两个状态的逻辑，你可以继续补充其他状态的实现。另外，根据你的具体需求，你可能还需要定义和使用一些其他变量和逻辑来实现完整的状态转换控制。

 

  1. module traffic1(Clk_12M,Rst,LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2,Seg7_VH,Seg7_VL,led15,led16,led17,ledCntDis);
  2.   parameter S0 = 0;   //主路绿灯，支路红灯
  3.   parameter S1 = 1;   //主路黄灯，支路红灯
  4.   parameter S2 = 2;   //主路蓝灯，支路红灯
  5.   parameter S3 = 3;   //主路黄灯，支路黄灯
  6.   parameter S4 = 4;   //主路红灯，支路绿灯
  7.   parameter S5 = 5;   //主路红灯，支路黄灯
  8.   parameter S6 = 6;   //主路红灯，支路蓝灯
  9.   parameter S7 = 7;   //主路黄灯，支路黄灯
  10.   input Clk_12M,Rst;
  11.   output LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2;
  12.   output [8:0]Seg7_VH,Seg7_VL;
  13.   output led15,led16,led17;
  14.   reg LedR_1,LedG_1,LedB_1,LedR_2,LedG_2,LedB_2;
  15.   reg Clk_1Hz;//分频器
  16.   reg [31:0]Cnt_1Hz;//计数器
  17.     output reg[3:0] ledCntDis;
  18.   /*分频器模块*/
  19.   always@(posedge Clk_12M or negedge Rst)
  20.   begin
  21.     if(!Rst)
  22.       begin
  23.         Cnt_1Hz<=1;
  24.         Clk_1Hz<=1;  //分频器和计数器全部设置为初值1
  25.       end
  26.     else
  27.       begin
  28.         if(Cnt_1Hz>=6000000)//当计数器大于等于25的10的六次方
  29.           begin
  30.             Cnt_1Hz<=1;//计数器置一
  31.             Clk_1Hz<=~Clk_1Hz;//分频器取反
  32.           end
  33.         else
  34.           Cnt_1Hz<=Cnt_1Hz+1;
  35.         end
  36.       end
  37.       
  38.       /*计数器模块*/
  39.       reg[7:0]Cnt70;
  40.       always@(posedge Clk_1Hz or negedge Rst)
  41.       begin
  42.         if(!Rst)
  43.           begin
  44.             Cnt70<=0;
  45.           end
  46.         else
  47.           begin
  48.             if(Cnt70>=115)
  49.               begin
  50.                 Cnt70<=0;//复位
  51.               end
  52.             else
  53.               Cnt70<=Cnt70+1;
  54.             end
  55.           end
  56. 			 
  57. 			 
  58. 			 /*计数器模块*/
  59.       reg[7:0]Cnt10;
  60.       always@(posedge Clk_1Hz or negedge Rst)
  61.       begin
  62.         if(!Rst)
  63.           begin
  64.             Cnt10<=115;
  65.           end
  66.         else
  67.           begin
  68.             if(Cnt10<=0)
  69.               begin
  70.                 Cnt10<=115;//复位
  71.               end
  72.             else
  73.               Cnt10<=Cnt10-1;
  74.             end
  75.           end
  76.           
  77.           
  78.           /*数码管模块*/
  79.           reg[7:0]CntDis;
  80. 			reg[7:0]Cnt71;
  81. 			 reg [7:0] Cnt61;
  82.           always@(posedge Clk_12M)//BCD码转换
  83.           begin
  84.             if(Cnt10>70)
  85.               begin
  86. 				  Cnt71[7:0]<=(Cnt10-70)/10;
  87.                 CntDis[7:4]<=Cnt71[3:0];
  88.                 Cnt61[7:0]<=Cnt10-((Cnt10-70)/10)*10-70;
  89. 					 CntDis[3:0]<=Cnt61[3:0];
  90.               end
  91.             else if (Cnt10>65)
  92.               begin
  93. 					Cnt71[7:0]<=(Cnt10-65)/10;
  94.                 CntDis[7:4]<=Cnt71[3:0];
  95.                 Cnt61[7:0]<=Cnt10-((Cnt10-65)/10)*10-65;
  96. 					 CntDis[3:0]<=Cnt61[3:0];
  97.               end
  98.             else if (Cnt10>50)
  99.               begin
  100.                 Cnt71[7:0]<=(Cnt10-50)/10;
  101.                 CntDis[7:4]<=Cnt71[3:0];
  102.                 Cnt61[7:0]<=Cnt10-((Cnt10-50)/10)*10-50;
  103. 					 CntDis[3:0]<=Cnt61[3:0];
  104.               end
  105.             else if (Cnt10>45)
  106.               begin
  107.                 Cnt71[7:0]<=(Cnt10-45)/10;
  108.                 CntDis[7:4]<=Cnt71[3:0];
  109.                 Cnt61[7:0]<=Cnt10-((Cnt10-45)/10)*10-45;
  110. 					 CntDis[3:0]<=Cnt61[3:0];
  111.               end
  112.             else if (Cnt10>25)
  113.               begin
  114.                 Cnt71[7:0]<=(Cnt10-25)/10;
  115.                 CntDis[7:4]<=Cnt71[3:0];
  116.                 Cnt61[7:0]<=Cnt10-((Cnt10-25)/10)*10-25;
  117. 					 CntDis[3:0]<=Cnt61[3:0];
  118.               end
  119.                else if (Cnt10>20)
  120.               begin
  121.                 Cnt71[7:0]<=(Cnt10-20)/10;
  122.                 CntDis[7:4]<=Cnt71[3:0];
  123.                 Cnt61[7:0]<=Cnt10-((Cnt10-20)/10)*10-20;
  124. 					 CntDis[3:0]<=Cnt61[3:0];
  125.               end
  126.               else if (Cnt10>5)
  127.               begin
  128.                 Cnt71[7:0]<=(Cnt10-5)/10;
  129.                 CntDis[7:4]<=Cnt71[3:0];
  130.                 Cnt61[7:0]<=Cnt10-((Cnt10-5)/10)*10-5;
  131. 					 CntDis[3:0]<=Cnt61[3:0];
  132. 					 end
  133. 					 else if (Cnt10>0)
  134.               begin
  135.                 Cnt71[7:0]<=Cnt10/10;
  136.                 CntDis[7:4]<=Cnt71[3:0];
  137.                 Cnt61[7:0]<=Cnt10;
  138. 					 CntDis[3:0]<=Cnt61[3:0];
  139. 					 end
  140.               
  141. 				  
  142.               end
  143.               
  144.  always@(posedge Clk_12M)
  145.  begin
  146.  ledCntDis<=CntDis[3:0];
  147.  end             
  148.               //数码管调用实例           
  149. 				LED hex(CntDis[3:0],CntDis[7:4],Seg7_VL,Seg7_VH);
  150.           
  151.               
  152.               
  153.               //状态转换
  154.               reg [2:0] state;
  155.               always@(posedge Clk_12M or negedge Rst)
  156.               begin
  157.                 if(!Rst)
  158.                   begin
  159.                     LedR_1<=0;
  160.                     LedG_1<=0;
  161.                     LedB_1<=0;
  162.                     LedR_2<=0;
  163.                     LedG_2<=0;
  164.                     LedB_2<=0;
  165.                   end
  166.                 else
  167.                   begin
  168.                 case(state)
  169.                   S0://主路绿灯45s
  170.                   begin
  171.                     if(Cnt70<=45)
  172.                       begin
  173.                         LedR_1<=1;
  174.                         LedG_1<=0;
  175.                         LedB_1<=1;
  176.                         LedR_2<=0;
  177.                         LedG_2<=1;
  178.                         LedB_2<=1;
  179.                       end
  180.                     else
  181.                       state<=S1;
  182.                     end
  183.                   S1://主路黄灯5s
  184.                   begin
  185.                     if(Cnt70<=50)
  186.                       begin
  187.                         LedR_1<=0;
  188.                         LedG_1<=0;
  189.                         LedB_1<=1;
  190.                         LedR_2<=0;
  191.                         LedG_2<=1;
  192.                         LedB_2<=1;
  193.                       end
  194.                     else
  195.                       state<=S2;
  196.                     end
  197.                     
  198.                     
  199.                     S2://主路蓝灯15s
  200.                     begin
  201.                       if(Cnt70<=65)
  202.                         begin
  203.                           LedR_1<=1;
  204.                           LedG_1<=1;
  205.                           LedB_1<=0;
  206.                           LedR_2<=0;
  207.                           LedG_2<=1;
  208.                           LedB_2<=1;
  209.                         end
  210.                       else
  211.                         state<=S3;
  212.                       end
  213.                       
  214.                       
  215.                     S3://主辅均5s黄
  216.                       begin
  217.                         if(Cnt70<=70)
  218.                           begin
  219.                           LedR_1<=0;
  220.                           LedG_1<=0;
  221.                           LedB_1<=1;
  222.                           LedR_2<=0;
  223.                           LedG_2<=0;
  224.                           LedB_2<=1;
  225.                         end
  226.                       else
  227.                         state<=S4;
  228.                       end
  229.                       
  230.                       
  231.                       S4://辅路绿20s
  232.                     begin
  233.                         if(Cnt70<=90)
  234.                           begin
  235.                           LedR_1<=0;
  236.                           LedG_1<=1;
  237.                           LedB_1<=1;
  238.                           LedR_2<=1;
  239.                           LedG_2<=0;
  240.                           LedB_2<=1;
  241.                         end
  242.                       else
  243.                         state<=S5;
  244.                       end
  245.                       
  246.                       S5://辅路黄灯5s
  247.                       begin
  248.                         if(Cnt70<=95)
  249.                           begin
  250.                           LedR_1<=0;
  251.                           LedG_1<=1;
  252.                           LedB_1<=1;
  253.                           LedR_2<=0;
  254.                           LedG_2<=0;
  255.                           LedB_2<=1;
  256.                         end
  257.                       else
  258.                         state<=S6;
  259.                       end
  260.                       
  261.                       
  262.                       S6://辅路蓝灯15s
  263.                       begin
  264.                         if(Cnt70<=110)
  265.                           begin
  266.                           LedR_1<=0;
  267.                           LedG_1<=1;
  268.                           LedB_1<=1;
  269.                           LedR_2<=1;
  270.                           LedG_2<=1;
  271.                           LedB_2<=0;
  272.                         end
  273.                       else
  274.                         state<=S7;
  275.                       end
  276.                       
  277.                       
  278.                       
  279.                       S7://主辅路均黄灯5s
  280.                       begin
  281.                         if(Cnt70>=111)
  282.                           begin
  283.                           LedR_1<=0;
  284.                           LedG_1<=0;
  285.                           LedB_1<=1;
  286.                           LedR_2<=0;
  287.                           LedG_2<=0;
  288.                           LedB_2<=1;
  289.                         end
  290.                       else
  291.                         state<=S0;
  292.                       end
  293.                       
  294.                   default 
  295.                  begin
  296.                     LedR_1<=0;
  297.                     LedG_1<=0;
  298.                     LedB_1<=0;
  299.                     LedR_2<=0;
  300.                     LedG_2<=0;
  301.                     LedB_2<=0;
  302.                   end
  303.                 endcase
  304.               end
  305.             end
  306.               
  307.               
  308.               
  309.              
  310.             assign {led17,led16,led15}=state;
  311.           endmodule

以上是程序总代码。

 

##四、运行结果展示

FGPA交通灯展示

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/702142
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号