内容介绍

项目需求

完全使用WebIDE的图形化编程，使用常规的74系列的元器件，构建一个交通灯控制系统：

在数码管上显示计时信息 - 图形化
蜂鸣器报警 - 图形化
接近传感器检测人员走近 -Verilog
环境光感知，自动点亮路灯（小脚丫核心板上的单色LED）- Verilog

软硬件平台

1. Diamond

Diamond 是莱迪思半导体为其 FPGA 产品打造的设计软件，支持 Verilog、VHDL 等设计输入，集成综合引擎，有强大布局布线与时序分析功能，能进行仿真、功耗计算，支持多 IP 核，界面友好且支持双系统，适用于物联网、消费电子等成本与功耗敏感场景。

2. WebIDE

小脚丫FPGA是一款专为FPGA初学者设计的开发平台，特别适合学习数字电路和Verilog编程。它基于Lattice MXO2系列芯片，支持瞬时上电启动和U盘模式下载，用户只需将生成的.jed文件拖入虚拟U盘即可完成配置，无需安装驱动程序。小脚丫还提供了WebIDE，用户可以通过浏览器在线完成FPGA的编程、编译和下载，操作简单直观，支持Windows、Mac OS和Linux等操作系统。此外，WebIDE内置了丰富的示例项目和教学资源，帮助用户快速上手并理解FPGA应用.

3. STEP Baseboard4.0底板+STEP MXO2 LPC核心板

STEP BaseBoard V4.0是第4代小脚丫FPGA扩展底板，可以用于全系列小脚丫核心板的功能扩展，采用100mm*161.8mm的黄金比例尺寸，板子集成了存储器、温湿度传感器、接近式传感器、矩阵键盘、旋转编码器、HDMI接口、RGBLCD液晶屏、8个7位数码管、蜂鸣器模块、UART通信模块、ADC模块、DAC模块和WIFI通信模块，配合小脚丫FPGA板能够完成多种实验，是数字逻辑、微机原理、可编程逻辑语言以及EDA设计工具等课程完美的实验平台。

功能框图

（1）图形化部分框图

（2）Verilog部分框图

设计思路

WebIDE的链接：stepfpga

图形化数码管显示模块

首先是功能是实时显示交通灯倒计时信息
实现逻辑是：首先来自计数器模块(CNT_1s_MAX)的二进制计时数值，再使用74系列芯片（74HC595移位寄存器）将二进制数值转换为数码管段码。再通过动态扫描方式来驱动多位数码管。且在状态机模块（time_ctrl）根据交通灯的阶段（红灯/绿灯/黄灯）发送当前倒计时目标值。再倒计时结束时触发数码管闪烁（通过seq_tdn_2逻辑控制）

蜂鸣器报警模块

在倒黄灯时发出警示音。
实现逻辑是：当计数器（CNT_1s_MAX）达到设定阈值（如1s或3s）时激活。使用74HC04反相器（图中标注sn74hc-c04）增强驱动能力。通过PWM信号控制蜂鸣器频率（图中标注music参数配置为none或特定频率）。

create_data.v

核心功能是计时与时间数据生成，具体实现以下两点：
秒级计时器
在环境光感知场景中，周期性触发数据更新（例如每秒更新一次环境光强度）。
在接近传感器触发时，为数码管显示提供时间基准（如累计触发时长）。
时间数据格式化
输出 sec0（秒个位）和 sec1（秒十位）的 BCD码，可直接驱动数码管显示模块（如 seg_ctrl.v)。

module create_data #(
    parameter CNT_1s_MAX = 12_000_000  // 12MHz时钟，1秒的周期
)
(
    input                       clk,        // 12MHz时钟输入
    input                       rst_n,      // 低有效复位信号
    output  wire [3:0]          sec0,       // 秒的个位
    output  wire [3:0]          sec1        // 秒的十位
);


reg [3:0]           sec0_R            ;    // 秒的个位
reg [3:0]           sec1_R            ;     // 秒的十位


assign  sec0 = sec0_R;
assign  sec1 = sec1_R;


reg [23:0] counter;          // 用于12百万周期的24位计数器



always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        counter <= 0;
        sec0_R <= 0;sec1_R <= 0;
    end else if (counter == CNT_1s_MAX - 1) begin
        counter <= 0;  // 每秒重置计数器
        if (sec0_R == 9) begin
            if(sec1_R == 1)begin
                sec0_R <= 0;sec1_R <= 0;
            end else begin
                sec1_R <= sec1_R + 1;  // 递减倒计时器
                sec0_R <= 0;
            end
        end else begin
            sec0_R <= sec0_R + 1;  // 递减倒计时器
        end  
    end else begin
        counter <= counter + 1;  // 递增计数器
    end
end

endmodule

seg_ctrl.v

核心功能是传感器数据稳定性检测与数码管显示使能控制，具体实现以下两点：
传感器数据滤波：对输入的接近传感器数据 prox_dat 进行两级缓存 + 差值校验，输出稳定的 prox_dat2。防止传感器噪声或突变值导致显示抖动。
数码管显示使能控制：当稳定后的传感器值 prox_dat2 超过阈值（≥30）时，使能数码管显示 (seg_en=1)，否则关闭显示 (seg_en=0)。当 seg_en=1 时，数码管显示计时（来自 create_data.v）和传感器数值（来自 prox_dat2）。当 seg_en=0 时，数码管可能关闭或显示待机信息。

module seg_ctrl(
    input  wire                 clk,
    input                       rst_n,
    input   [15:0]              prox_dat        ,
    input                       dat_valid       ,
    output  reg                 seg_en
    );
    //第1段：解析出稳定的prox_dat2
    reg	[15:0] prox_dat0,prox_dat1,prox_dat2;
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n)begin
            prox_dat0 <= 16'd0;
            prox_dat1 <= 16'd0;
            prox_dat2 <= 16'd0;
        end
        else if(dat_valid) begin
            prox_dat0 <= prox_dat;
            prox_dat1 <= prox_dat0;
            if(((prox_dat1-prox_dat0) >= 16'h800)||((prox_dat1-prox_dat0) >= 16'h800)) 
                prox_dat2 <= prox_dat2;
            else 
                prox_dat2 <= prox_dat0;
        end
        else begin
            prox_dat0 <= prox_dat0;
            prox_dat1 <= prox_dat1;
            prox_dat2 <= prox_dat2;
        end
    end
    //第2段数码管使能
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            seg_en <= 1'b0;
        else if(prox_dat2 >= 30)
            seg_en <= 1'b1;
        else
            seg_en <= 1'b0;
    end
endmodule

beeper_ctrl.v

核心功能是动态音调报警控制，具体实现以下两点：
多模式报警：
模式一（短时报警）：当接近传感器触发时，蜂鸣器以固定频率鸣响 2秒（由 cnt_2s 控制）。
模式二（动态音调）：当传感器数值持续超过阈值时，蜂鸣器音调随距离变化（越近音调越高）。
传感器数据滤波与阈值判断：
复用 seg_ctrl.v 的滤波逻辑（三级缓存 + 差值校验），输出稳定的 prox_dat2。
根据 prox_dat2 与阈值 ThreHold 的关系，切换报警模式和音调频率。

module beeper_ctrl
(
    input                       clk             ,
    input                       rst_n           ,
    input                       beeper_en       ,
    output  wire                beeper          ,
    input   [15:0]              prox_dat        ,
    input                       dat_valid
);
	 //声调
	parameter                   L1 = 16'd45872          ;	//L1,
	parameter                   L2 = 16'd40858          ;	//L2,
	parameter                   L3 = 16'd36408          ;	//L3,
	parameter                   L4 = 16'd34364          ;	//L4,
	parameter                   L5 = 16'd30612          ;	//L5,
	parameter                   L6 = 16'd27273          ;	//L6,
	parameter                   L7 = 16'd24296          ;	//L7,
	parameter                   M1 = 16'd22931          ;	//M1,
	parameter                   M2 = 16'd20432          ;	//M2,
	parameter                   M3 = 16'd18201          ;	//M3,
	parameter                   M4 = 16'd17180          ;	//M4,
	parameter                   M5 = 16'd15306          ;	//M5,
	parameter                   M6 = 16'd13636          ;	//M6,
	parameter                   M7 = 16'd12148          ;	//M7,
	parameter                   H1 = 16'd11478          ;	//H1,
	parameter                   H2 = 16'd10215          ;	//H2,
    parameter                   CNT_1s_MAX = 12_000_000 ;   // 12MHz时钟，1秒的周期
    parameter           ThreHold = 100;
    parameter           ALARM_PRT =  2_000_000;
    reg                 beeper_R;
    assign              beeper = beeper_R;
    
    reg   [15:0]        cnt;
    reg   [31:0]        cnt_2s;
    reg   [31:0]        cnt_alarm;
    reg                 beeper_en2;
    reg   [15:0]        cycle;
    //第1段：解析出稳定的prox_dat2
    reg	[15:0] prox_dat0,prox_dat1,prox_dat2;
    always @(posedge clk or negedge rst_n) begin
        if(!rst_n)begin
            prox_dat0 <= 16'd0;
            prox_dat1 <= 16'd0;
            prox_dat2 <= 16'd0;
        end
        else if(dat_valid) begin
            prox_dat0 <= prox_dat;
            prox_dat1 <= prox_dat0;
            if(((prox_dat1-prox_dat0) >= 16'h800)||((prox_dat1-prox_dat0) >= 16'h800)) 
                prox_dat2 <= prox_dat2;
            else 
                prox_dat2 <= prox_dat0;
        end
        else begin
            prox_dat0 <= prox_dat0;
            prox_dat1 <= prox_dat1;
            prox_dat2 <= prox_dat2;
        end
    end
    //第2段-1：音调节奏计数
    always @(posedge clk or negedge rst_n)
        if(!rst_n) 
            cnt <= 1'b1;
        else if(cnt >= cycle) 
            cnt <= 1'b1;
        else 
            cnt <= cnt + 1'b1;
    //第2段-2:警报器使能计数
    always @(posedge clk or negedge rst_n)
        if(!rst_n) 
            cnt_alarm <= 1'b1;
        else if(prox_dat2 > ThreHold)
            if(cnt_alarm >= ALARM_PRT) 
                cnt_alarm <= 1;
            else 
                cnt_alarm <= cnt_alarm + 1'b1;
        else
            cnt_alarm <= 1;
    
    //第3段：beeper_R寄存器开始震动，代表音调
    always@(posedge clk or negedge rst_n)
        if(!rst_n)
            beeper_R <= 1'b1;
        else if(beeper_en || beeper_en2)
            if(cnt < cycle >>1) 
                beeper_R <= 1'b1;
            else 
                beeper_R <= 1'b0;
        else
            beeper_R <= 1'b1;
    // 第5段：模式一下蜂鸣器每次只响2s，因此对其进行计数
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            cnt_2s <= 32'd0;
        else if(beeper_en)
            cnt_2s <= cnt_2s + 1'b1;
        else
            cnt_2s <= 32'd0;
    end
    //第7段：模式二：有人接近时
    //随着人接近的距离，音调逐渐变高
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)
            beeper_en2 <= 1'b0;
        else
            if(prox_dat2 >= ThreHold)
                if(cnt_alarm == ALARM_PRT)
                    beeper_en2 <= ~beeper_en2;
                else
                    beeper_en2 <= beeper_en2;
            else
                beeper_en2 <= 1'b0;
    end
    always@(posedge clk or negedge rst_n) begin
        if(!rst_n)begin
            cycle <= L3;
        end else begin
            if(prox_dat2 <= ThreHold) begin cycle <= L3;end	//L1,
            else begin cycle <= L7;end    //L7
        end
    end
endmodule

rgb_led_module.v

自主红绿灯倒计时

计时逻辑：
红灯周期：当 sec1 == 1（即10~19秒），RGB灯显示红色。
绿灯周期：当 sec1 == 0 且 sec0 <= 6（即0~6秒），RGB灯显示绿色。
蓝灯周期：当 sec1 == 0 且 sec0 > 6（即7~9秒），RGB灯显示蓝色（可能代表黄灯过渡）。
2. 蜂鸣器提醒
触发条件：在蓝灯周期（7~9秒），蜂鸣器以 0.25秒间隔（4Hz）鸣响，提示倒计时结束。
实现方式：通过 cnt_1_4s 计数器生成周期信号，控制 beeper_en 翻转。

module rgb_led_module #(
    parameter CNT_1s_MAX = 12_000_000  // 12MHz时钟，1秒的周期
)
(
    input                       clk,        // 12MHz时钟输入
    input                       rst_n,      // 低有效复位信号
    output     [2:0]            led_rgb,
    output                      beeper_en
);
parameter           SEC0_START  = 0;
parameter           SEC1_START  = 0;
parameter           SEC0_END    = 5;
parameter           SEC1_END    = 2;
parameter           SEC0_RED    = 5;
parameter           SEC1_RED    = 1;
parameter           SEC0_YELLOW = 3;
parameter           SEC1_YELLOW = 1;
wire [3:0]          sec0              ;         // 秒的个位
wire [3:0]          sec1              ;         // 秒的十位
reg [3:0]           sec0_R            ;    // 秒的个位
reg [3:0]           sec1_R            ;     // 秒的十位
reg [2:0]           led_rgb_R         ;     // 红灯011，绿灯101
reg                 beeper_en_R       ;
reg [31:0]          cnt_1_4s          ;
assign  sec0 = sec0_R;
assign  sec1 = sec1_R;
assign  led_rgb = led_rgb_R;
assign  beeper_en = beeper_en_R;
reg [23:0] counter;          // 用于12百万周期的24位计数器
localparam RED_COLOR    = 3'b011;
localparam GREEN_COLOR  = 3'b101;
localparam BLUE_COLOR   = 3'b110;
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        counter <= 0;
        sec0_R <= SEC0_START;sec1_R <= 0;
    end else if (counter == CNT_1s_MAX - 1) begin
        counter <= 0;  // 每秒重置计数器
        if (sec0_R == 9) begin
            if(sec1_R == 1)begin
                sec0_R <= 0;sec1_R <= 0;
            end else begin
                sec1_R <= sec1_R + 1;  // 递减倒计时器
                sec0_R <= 0;
            end
        end else begin
            sec0_R <= sec0_R + 1;  // 递减倒计时器
        end  
    end else begin
        counter <= counter + 1;  // 递增计数器
    end
end
always@(posedge clk or negedge rst_n)
    if(!rst_n)
        led_rgb_R <= GREEN_COLOR;
    else if(sec1 == 1)
        led_rgb_R <= RED_COLOR;
    else if(sec0 > 6)
        led_rgb_R <= BLUE_COLOR;
    else
        led_rgb_R <= GREEN_COLOR;
always@(posedge clk or negedge rst_n)
    if(!rst_n)
        beeper_en_R <= 0;
    else if(sec1 == 1)
        beeper_en_R <= 0;
    else if(sec0 > 6)
        if(cnt_1_4s == CNT_1s_MAX >> 2)
            beeper_en_R <= ~beeper_en_R;
        else
            beeper_en_R <= beeper_en_R;
    else
        beeper_en_R <= 0;
always@(posedge clk or negedge rst_n)
    if(!rst_n)
        cnt_1_4s <= 0;
    else if(sec0 > 6 && sec1 == 0)
        if(cnt_1_4s == CNT_1s_MAX >> 2)
            cnt_1_4s <= 0;
        else
            cnt_1_4s <= cnt_1_4s + 1'b1; 
    else
        cnt_1_4s <= 0;
endmodule

TOP.v

top.v 是系统的核心整合模块，负责协调传感器数据采集、报警控制、RGB/LED显示、数码管驱动等子模块的交互。：

传感器数据流
传感器驱动 (rpr0521rs_driver)：
输出 prox_dat（接近传感器原始数据）、ch0_dat（环境光数据）、dat_valid（数据有效标志）。
数据流向：
prox_dat → seg_ctrl（滤波） → seg_en（显示使能）。
prox_dat → beeper_ctrl（报警控制）。
ch0_dat → decoder（环境光数据处理）→ lux_data → 数码管显示。
2. 报警与显示联动
蜂鸣器控制 (beeper_ctrl)：
输入 prox_dat 和 beeper_en（来自 rgb_led_module）。
问题：rgb_led_module 的 beeper_en 当前基于自主倒计时生成，而非传感器触发，导致报警逻辑错乱。
数码管使能 (seg_ctrl)：
当 prox_dat2 ≥ 30 时，seg_en=1，触发数码管显示。
3. 计时与显示
计时模块 (create_data)：
输出 sec0（秒个位）和 sec1（秒十位）。
问题：复位信号错误连接到 seg_en，导致计时器在显示使能时被复位。
数码管显示 (segment_scan)：
显示 prox_data_bcd（接近传感器数值）和 lux_data（环境光强度）。

module top(
    input                   clk         ,
    input                   rst_n       ,
	output [8:0]            seg_led_1   ,		//在小脚丫上控制一个数码管需要9个信号 MSB~LSB=DIG、DP、G、F、E、D、C、B、A
	output [8:0]            seg_led_2   ,		//在小脚丫上第二个数码管的控制信号  MSB~LSB=DIG、DP、G、F、E、D、C、B、A
	output [7:0]	        led		    ,       //led灯
    output [2:0]            led_rgb     ,
    output [2:0]            led_rgb2    ,  
    output                  beeper      ,
 	output			        i2c_scl     ,	    //I2C时钟总线
	inout			        i2c_sda     ,	    //I2C数据总线
	output			        seg_rck     ,		// 74HC595的RCK管脚
	output			        seg_sck     ,		// 74HC595的SCK管脚
	output			        seg_din     		// 74HC595的SER管脚
    );
    //u1_seg_data_gen
    wire  [3:0]             sec0;
    wire  [3:0]             sec1; 
    //u2_rgb_led_module
    wire                    beeper_en;
    //u3_rpr0521rs_driver
    wire dat_valid;
    wire [15:0] ch0_dat, ch1_dat, prox_dat;
    //u4_seg_ctrl
    wire                    seg_en;
    //u6_decoder
    wire [31:0] lux_data,prox_data_bcd;
   
    create_data  #(
        .CNT_1s_MAX                 (12_000_000)  // 12MHz时钟，1秒的周期
    )
    u1_create_data(
        .clk                        (clk         ),        
        .rst_n                      (seg_en      ),      
        .sec0                       (sec0        ),       
        .sec1                       (sec1        )        
    );
    rgb_led_module #(
        .CNT_1s_MAX                 (12_000_000)  // 12MHz时钟，1秒的周期
    )
    u2_rgb_led_module(
        .clk                        (clk            ),        
        .rst_n                      (rst_n          ),      
        .led_rgb                    (led_rgb        ),
        .beeper_en                  (beeper_en      )
    );
    beeper_ctrl #(
	    .L1                     (16'd45872  )       ,	//L1,
	    .L2                     (16'd40858  )       ,	//L2,
	    .L3                     (16'd36408  )       ,	//L3,
	    .L4                     (16'd34364  )       ,	//L4,
	    .L5                     (16'd30612  )       ,	//L5,
	    .L6                     (16'd27273  )       ,	//L6,
	    .L7                     (16'd24296  )       ,	//L7,
	    .M1                     (16'd22931  )       ,	//M1,
	    .M2                     (16'd20432  )       ,	//M2,
	    .M3                     (16'd18201  )       ,	//M3,
	    .M4                     (16'd17180  )       ,	//M4,
	    .M5                     (16'd15306  )       ,	//M5,
	    .M6                     (16'd13636  )       ,	//M6,
	    .M7                     (16'd12148  )       ,	//M7,
	    .H1                     (16'd11478  )       ,	//H1,
	    .H2                     (16'd10215  )       ,	//H2,
        .ALARM_PRT              (200            )     
    )
    u2_beeper_ctrl
    (
        .clk                    (clk           ),
        .rst_n                  (rst_n         ),
        .beeper_en              (beeper_en     ),
        .beeper                 (beeper        ),
        .prox_dat               (prox_dat      ),
        .dat_valid              (dat_valid     )
    );
    
    rpr0521rs_driver u3_rpr0521rs_driver(
		.clk				(clk			),	//系统时钟
		.rst_n				(rst_n			),	//系统复位，低有效
		.i2c_scl			(i2c_scl		),	//I2C总线SCL
		.i2c_sda			(i2c_sda		),	//I2C总线SDA
		.dat_valid			(dat_valid		),	//数据有效脉冲
		.ch0_dat			(ch0_dat		),	//ALS数据
		.ch1_dat			(ch1_dat		),	//IR数据
		.prox_dat			(prox_dat		)	//Prox数据
	);
    ////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////
    //仿真
// module TOP(
//     input                   clk         ,
//     input                   rst_n       ,
// 	output [8:0]            seg_led_1   ,		//在小脚丫上控制一个数码管需要9个信号 MSB~LSB=DIG、DP、G、F、E、D、C、B、A
// 	output [8:0]            seg_led_2   ,		//在小脚丫上第二个数码管的控制信号  MSB~LSB=DIG、DP、G、F、E、D、C、B、A
// 	output [7:0]	        led		    ,       //led灯
//     output [2:0]            led_rgb     ,
//     output [2:0]            led_rgb2    ,                 
//     output                  beeper      ,
//  	output			        i2c_scl     ,	    //I2C时钟总线
// 	inout			        i2c_sda     ,	    //I2C数据总线
// 	output			        seg_rck     ,		// 74HC595的RCK管脚
// 	output			        seg_sck     ,		// 74HC595的SCK管脚
// 	output			        seg_din     ,		// 74HC595的SER管脚
//     input                   dat_valid   ,
// 	input  [15:0]	        ch0_dat     ,
// 	input  [15:0]	        ch1_dat     ,
// 	input  [15:0]	        prox_dat
//     );
    
//     //u1_create_data
//     wire  [3:0]             sec0;
//     wire  [3:0]             sec1;
//     //u2_rgb_led_module
//     wire                    beeper_en;
//     //u4_seg_ctrl
//     wire                    seg_en;
//     //u6_decoder
//     wire [31:0] lux_data,prox_data_bcd;
//     create_data  #(
//         .CNT_1s_MAX                 (12_0)  // 12MHz时钟，1秒的周期
//     )
//     u1_create_data(
//         .clk                        (clk         ),        
//         .rst_n                      (seg_en      ),      
//         .sec0                       (sec0        ),       
//         .sec1                       (sec1        )        
//     );
//     rgb_led_module #(
//         .CNT_1s_MAX                 (12_0)  // 12MHz时钟，1秒的周期
//     )
//     u2_rgb_led_module(
//         .clk                        (clk            ),        
//         .rst_n                      (rst_n          ),      
//         .led_rgb                    (led_rgb        ),
//         .beeper_en                  (beeper_en      )
//     );
//     beeper_ctrl #(
// 	    .L1                     (16'd45         )     ,	//L1,
// 	    .L2                     (16'd40         )     ,	//L2,
// 	    .L3                     (16'd36         )     ,	//L3,
// 	    .L4                     (16'd34         )     ,	//L4,
// 	    .L5                     (16'd30         )     ,	//L5,
// 	    .L6                     (16'd27         )     ,	//L6,
// 	    .L7                     (16'd24         )     ,	//L7,
// 	    .M1                     (16'd22         )     ,	//M1,
// 	    .M2                     (16'd20         )     ,	//M2,
// 	    .M3                     (16'd18         )     ,	//M3,
// 	    .M4                     (16'd17         )     ,	//M4,
// 	    .M5                     (16'd15         )     ,	//M5,
// 	    .M6                     (16'd13         )     ,	//M6,
// 	    .M7                     (16'd12         )     ,	//M7,
// 	    .H1                     (16'd11         )     ,	//H1,
// 	    .H2                     (16'd10         )     ,	//H2,
//         .ALARM_PRT              (200            )     
//     )
//     u3_beeper_ctrl
//     (
//         .clk                    (clk           ),
//         .rst_n                  (rst_n         ),
//         .beeper_en              (beeper_en     ),
//         .beeper                 (beeper        ),
//         .prox_dat               (prox_dat      ),
//         .dat_valid              (dat_valid     )
//     );
    
    ////////////////////////////////////////////////////////////////////
    seg_ctrl    u4_seg_ctrl(
        .clk                    (clk           ),
        .rst_n                  (rst_n         ),
        .prox_dat               (prox_dat      ),
        .dat_valid              (dat_valid     ),
        .seg_en                 (seg_en        )
    );
    segment u5_segment(
        .seg_data_1              (sec1          ),
        .seg_data_2              (sec0          ),
        .seg_led_1               (seg_led_1     ),
        .seg_led_2               (seg_led_2     )
        );
 
    decoder u6_decoder(
            .clk				(clk				),
            .rst_n				(rst_n				),
            .dat_valid			(dat_valid			),
            .ch0_dat			(ch0_dat			),
            .ch1_dat			(ch1_dat			),
            .prox_dat			(prox_dat			),
            .lux_data			(lux_data			),
            .Y_out				(led				),
            .prox_data_bcd		(prox_data_bcd		)
        );
    segment_scan u7_segment_scan(
            .clk			(clk					),					//系统时钟 12mhz
            .rst_n			(rst_n					),				//系统复位 低有效
            .dat_1			(prox_data_bcd[15:12]	),	//seg1 显示的数据输入
            .dat_2			(prox_data_bcd[11: 8]	),	//seg2 显示的数据输入
            .dat_3			(prox_data_bcd[ 7: 4]	),	//seg3 显示的数据输入
            .dat_4			(prox_data_bcd[ 3: 0]	),	//seg4 显示的数据输入
            // .dat_5			(lux_data[23:20]		),	//seg5 显示的数据输入
            // .dat_6			(lux_data[19:16]		),	//seg6 显示的数据输入
            // .dat_7			(lux_data[15:12]		),	//seg7 显示的数据输入
            // .dat_8			(lux_data[11:08]		),	//seg8 显示的数据输入
            .dat_5			(lux_data[27:24]		),	//seg5 显示的数据输入
            .dat_6			(lux_data[23:20]		),	//seg6 显示的数据输入
            .dat_7			(lux_data[19:16]		),	//seg7 显示的数据输入
            .dat_8			(lux_data[15:12]		),	//seg8 显示的数据输入 
            .dat_en			(8'b1111_1111			),	//数码管数据位显示使能，[msb~lsb]=[seg1~seg8]
            .dot_en			(8'b0001_0000			),	//数码管小数点位显示使能，[msb~lsb]=[seg1~seg8]
            .seg_rck		(seg_rck				),	//74hc595的rck管脚
            .seg_sck		(seg_sck				),	//74hc595的sck管脚
            .seg_din		(seg_din				)	//74hc595的ser管脚
        );
    assign led_rgb2 = seg_en ? 3'b000 : 3'b111;
endmodule

实验效果图和叙述

首先是核心板上的RGB1用来实现基础的交通灯控制系统，但是在后续中，我将核心板上的数码管进行了修改，改为在人员靠近或者环境光降低时间的计时，而后是RGB2也是在相同情形下进行光的亮，并且在越靠近传感器或者环境光越低的情况下，蜂鸣器报警的音调越高，且呈现2s间断，并且随着光亮越低，核心板的8位led小红灯将呈现流水灯的形式，最后是底板上的八位数码管会显示出传感器的数值，越靠近传感器数值越大。

FPGA资源占用

遇到的问题和解决方案

-多模块异步操作 + 硬件资源竞争

同步化 → 滤波 →分时复用

对本次活动的心得体会

学习到了FPGA的相关知识。板子功能完善，就是WebIDE不太好用。