交通燈控制器的verilog實現

用狀態機實現交通燈控制器，仿真通過，有代碼以及testbench。

---

 

要求：

方向1是主干道，綠燈時間較長，交通燈狀態循環為：

綠：40

黃：5

左：15

黃：5

紅：55

方向2不是主干道，綠燈時間較少，交通燈狀態循環為：

紅：65

綠：30

黃：5

左：15

黃：5

---

 

 注意：

1. 此處將兩個交通燈的狀態合在一起，從而便於對兩個等進行同步控制。將兩個燈的5個狀態合為8個狀態，即：

綠1：40

黃1：5

左1：15

黃1：5

綠2：30

黃2：5

左2：15

黃2：5

對狀態轉換以及輸出控制采用組合邏輯，在調試的過程中也曾使用時序邏輯來實現，仿真發現各種時序混亂。

在狀態轉換控制中，在change有效后，馬上將其清零，代碼如下，這是為了便於控制，調試時，發現這樣比較方便，其他方法易出錯。

在仿真圖上就看不到change有效過，但仿真圖上的其他信號是正確的。

    G2   : if(trigger)  
                           nxt_state = G1;
           else if(change)  
                  begin
                        change = 1'b0; 7                         nxt_state = Y2_1;

 

---

 

代碼如下：

module traffic_light(rst_n,
                            clk,
                            trigger, //觸發信號，使得狀態機進入循環
                            light1,
                            light2
                                 );
input rst_n;
input clk;
input trigger;

output [3:0] light1;   //4bit分別對應綠、黃、左、紅燈
output [3:0] light2;

//燈亮時間
parameter G1_T = 7'd40;  //方向1的亮燈時間
parameter Y1_T = 7'd5;
parameter L1_T = 7'd15;

parameter G2_T = 7'd30;    //方向2的亮燈時間
parameter Y2_T = 7'd5;
parameter L2_T = 7'd15;

//狀態編碼
parameter IDLE = 4'd0;    //此處為了方便采用簡單的binary編碼，可用one-hot或gray提高性能
parameter G1 = 4'd1;
parameter Y1_1 = 4'd2;
parameter L1 = 4'd3;
parameter Y1_2 = 4'd4;

parameter G2 = 4'd5;
parameter Y2_1 = 4'd6;
parameter L2 = 4'd7;
parameter Y2_2 = 4'd8;

reg [3:0] cur_state;
reg [3:0] nxt_state;

reg [3:0] light1;
reg [3:0] light2;

reg [3:0] light1_tmp;
reg [3:0] light2_tmp;

reg [6:0] light_t_tmp;
reg [6:0] light_t;

reg change;
reg start;

//狀態寄存，時序邏輯
always@(posedge clk)
    if(!rst_n)
        cur_state <= IDLE;
    else
        cur_state <= nxt_state;

//狀態轉換，組合邏輯        
always@(*)
    if(!rst_n)
        begin
            //start <= 1'b0;
            nxt_state = IDLE;
        end
    else  
        begin
            case(cur_state)
                IDLE : //if(change) 
                        if(trigger)  //狀態機通過trigger進入狀態循環
                            begin
                                //start <= 1'b1;  //start與計數值light_t_tmp是同步的，因此一同寫在輸出控制中 
                                nxt_state = G1;  //狀態變換由組合邏輯實現，采用阻塞賦值即=，而非<=
                            end
                G1   : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                                begin
                                    //start <= 1'b1;
                                    change = 1'b0;
                                    nxt_state = Y1_1;
                                end
                Y1_1 : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = L1;
                            end
                L1   : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = Y1_2;
                            end
                Y1_2 : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = G2;
                            end
                G2   : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = Y2_1;
                            end
                Y2_1 : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state= L2;
                            end
                L2   : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = Y2_2;
                            end
                Y2_2 : if(trigger)  
                            begin
                                //start <= 1'b1;
                                nxt_state = G1;
                            end
                        else if(change)  
                            begin
                                //start <= 1'b1;
                                change = 1'b0;
                                nxt_state = G1;
                            end
                default : nxt_state = IDLE;
            endcase
        end        
        
//輸出控制，組合邏輯
//start與計數值light_t_tmp是同步的，因此一同寫在輸出控制中 
//always@(posedge clk)   //輸出為組合邏輯，因此不在clk下動作
always@(*)
    if(!rst_n)
        begin
            start = 1'b0;
            light_t_tmp = 7'd0;
            light1_tmp = 4'b0000;
            light2_tmp = 4'b0000;
        end
    else case(cur_state)
            G1   : begin
                        start = 1'b1;
                        light_t_tmp = G1_T;
                        light1_tmp = 4'b1000;
                        light2_tmp = 4'b0001;                    
                     end
            Y1_1 : begin
                        start = 1'b1;
                        light_t_tmp = Y1_T;
                        light1_tmp = 4'b0100;
                        light2_tmp = 4'b0001;                
                     end
            L1   : begin
                        start = 1'b1;
                        light_t_tmp = L1_T;
                        light1_tmp = 4'b0010;
                        light2_tmp = 4'b0001;                
                     end
            Y1_2 : begin
                        start = 1'b1;
                        light_t_tmp = Y1_T;
                        light1_tmp = 4'b0100;
                        light2_tmp = 4'b0001;                
                     end
            G2   : begin
                        start = 1'b1;
                        light_t_tmp = G2_T;
                        light1_tmp = 4'b0001;
                        light2_tmp = 4'b1000;                
                     end
            Y2_1 : begin
                        start = 1'b1;
                        light_t_tmp = Y2_T;
                        light1_tmp = 4'b0001;
                        light2_tmp = 4'b0100;                
                     end
            L2   : begin
                        start = 1'b1;
                        light_t_tmp = L2_T;
                        light1_tmp = 4'b0001;
                        light2_tmp = 4'b0010;                
                     end
            Y2_2 : begin
                        start = 1'b1;
                        light_t_tmp = Y2_T;
                        light1_tmp = 4'b0001;
                        light2_tmp = 4'b0100;                
                     end
        endcase

//燈亮時間倒計時
//時序邏輯，要在clk時鍾下動作
always@(posedge clk)
    if(!rst_n)
        begin
            light_t <= 7'd0;
        end
    else if(start)
                begin
                    start <= 1'b0;
                    light_t <= light_t_tmp;
                end
         else
            begin
                light_t <= light_t - 1'b1;
            end
            
//在light_t減到2時，置為change信號
//用組合邏輯
always@(*)
    if(!rst_n)
        change = 1'b0;  
    else if(light_t == 4'd2)
        change = 1'b1;
        
//輸出寄存    
always@(posedge clk)
    if(!rst_n)
        begin
            light1 <= 4'd0;
            light2 <= 4'd0;
        end
    else
        begin
            light1 <= light1_tmp;
            light2 <= light2_tmp;
        end
        
//下面是調試過程中對change以及start的控制    
//因為使用了時序邏輯，導致各種錯誤
/*
always@(posedge clk)
    if(!rst_n)
        begin
            light_t <= 7'd0;
            //change <= 1'b0;  //復位，開始狀態轉換
        end
    else if(start)
                begin
                    start <= 1'b0;
                    //change <= 1'b0;
                    //change_r <= 1'b0;
                    light_t <= light_t_tmp;
                end
            //else if(light_t == 4'd1)
            //        change <= 1'b1;
                 else
                    begin
                        light_t <= light_t - 1'b1;
                        //change <= 1'b0;
                    end
*/
            
/*            
always@(*)
    if(!rst_n)
        change = 1'b0;  //復位，開始狀態轉換
    else if(start)
            change = 1'b0;
        else if(light_t == 4'd1)
        else if(light_t == 4'd2)
            change = 1'b1;        
*/    

endmodule

testbench如下：

module traffic_light_tb;

    // Inputs
    reg rst_n;
    reg clk;
    reg trigger;

    // Outputs
    wire [3:0] light1;
    wire [3:0] light2;

    // Instantiate the Unit Under Test (UUT)
    traffic_light uut (
        .rst_n(rst_n), 
        .clk(clk), 
        .trigger(trigger),
        .light1(light1), 
        .light2(light2)
    );
    
    parameter CLK_PERIOD = 10;

    initial begin
        rst_n = 0;
        clk = 1;
        trigger = 0;

        #100;    
        rst_n = 1;
        trigger = 1;   //初始給出trigger信號，使得狀態機進行狀態循環
        #CLK_PERIOD trigger = 0;
        
        //#1000 trigger = 1;  //trigger復位狀態機
        //#100 trigger = 0;
        
    end
    
    always #(CLK_PERIOD/2) clk = ~clk;
      
endmodule

ISIM仿真結果：

可以看到，兩個交通燈從給定的狀態間循環，且時間同步。