kuntzschcl
/
ESY1_Projekt_2023
Watch 2
Star 1
Fork 1
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

„Ampelansteuerung/LED_control.sv“ löschen

master^2
Niklas Boese 1 year ago
parent
11608814fb
commit
6f34badb25
1 changed files with 0 additions and 498 deletions
Split View Show Diff Stats
  1. 0
    498
      Ampelansteuerung/LED_control.sv

+ 0
- 498
Ampelansteuerung/LED_control.sv View File

@@ -1,498 +0,0 @@
// ==================================================================
// >>>>>>>>>>>>>>>>>>>>>>> COPYRIGHT NOTICE <<<<<<<<<<<<<<<<<<<<<<<<<
// ------------------------------------------------------------------
// Copyright (c) 2017 by Lattice Semiconductor Corporation
// ALL RIGHTS RESERVED
// ------------------------------------------------------------------
//
// Permission:
//
// Lattice SG Pte. Ltd. grants permission to use this code
// pursuant to the terms of the Lattice Reference Design License Agreement.
//
//
// Disclaimer:
//
// This VHDL or Verilog source code is intended as a design reference
// which illustrates how these types of functions can be implemented.
// It is the user's responsibility to verify their design for
// consistency and functionality through the use of formal
// verification methods. Lattice provides no warranty
// regarding the use or functionality of this code.
//
// --------------------------------------------------------------------
//
// Lattice SG Pte. Ltd.
// 101 Thomson Road, United Square #07-02
// Singapore 307591
//
//
// TEL: 1-800-Lattice (USA and Canada)
// +65-6631-2000 (Singapore)
// +1-503-268-8001 (other locations)
//
// web: http://www.latticesemi.com/
// email: techsupport@latticesemi.com
//
// --------------------------------------------------------------------
//
// Project: iCE5UP 5K RGB LED Tutorial
// File: LED_control.v
// Title: LED PWM control
// Description: Creates RGB PWM per control inputs
//
//
// --------------------------------------------------------------------
//
//------------------------------------------------------------
// Notes:
//
//
//------------------------------------------------------------
// Development History:
//
// __DATE__ _BY_ _REV_ _DESCRIPTION___________________________
// 04/05/17 RK 1.0 Initial tutorial design for Lattice Radiant
//
//------------------------------------------------------------
// Dependencies:
//
//
//
//------------------------------------------------------------


module LED_control1 (
// inputs
input wire clk12M, // 12M clock
input wire rst, //Asynchronous reset
input wire [1:0] color_sel, // for selecting color using switches
input wire RGB_Blink_En, //Enabling Blink
//outputs
output reg red_pwm, // Red
output reg blu_pwm, // Blue
output reg grn_pwm // Green
);


//------------------------------
// INTERNAL SIGNAL DECLARATIONS:
//------------------------------
// parameters (constants)
parameter on_hi = 2'b10;
parameter on_lo = 2'b01;
parameter off = 2'b00;

parameter LED_OFF = 2'b00;
parameter RAMP_UP = 2'b01;
parameter LED_ON = 2'b10;
parameter RAMP_DOWN = 2'b11;

parameter on_max_cnt = 28'h16E35ED; // 1 sec steady

parameter Brightness=4'b0111; //50% Brightness
parameter BreatheRamp=4'b0111; //4x
parameter BlinkRate=4'b0101; //1sec


// wires (assigns)
wire [3:0]RGB_color;
wire [4:0] red_intensity;
wire [4:0] grn_intensity;
wire [4:0] blu_intensity;
wire clk24M;
wire LOCK;

// regs (always)
reg [1:0] clk_div_cnt; //

reg [3:0] RGB_color_s; // sample values from SPI i/f
reg [3:0] Brightness_s;
reg [3:0] BreatheRamp_s;
reg [3:0] BlinkRate_s;

reg [1:0] red_set; // hi/lo/off
reg [1:0] grn_set;
reg [1:0] blu_set;

reg [31:0] red_peak; // LED 'on' peak intensity (high precision)
reg [31:0] grn_peak;
reg [31:0] blu_peak;

reg [27:0] off_max_cnt; // LED off duration
reg [3:0] step_shift; // scaling calculation aid

reg [27:0] ramp_max_cnt; // LED ramp up/down duration
reg [31:0] red_intensity_step; // LED intensity step when ramping
reg [31:0] grn_intensity_step;
reg [31:0] blu_intensity_step;

reg [1:0] blink_state; // state variable
reg [27:0] ramp_count; // counter for LED on/off duration
reg [27:0] steady_count; // counter for LED ramp up/down duration

reg [31:0] red_accum; // intensity accumulator during ramp
reg [31:0] grn_accum;
reg [31:0] blu_accum;

reg [17:0] curr_red; // current LED intensity ( /256 = PWM duty cycle)
reg [17:0] curr_grn;
reg [17:0] curr_blu;

reg [17:0] pwm_count; // PWM counter
reg [7:0] count = 8'b0;

//------------------------------
// PLL Instantiation
//------------------------------
//Block to reset the PLL initially
pll_24M __(.ref_clk_i(clk12M ), .rst_n_i(~rst), .lock_o(LOCK), .outcore_o( ), .outglobal_o(clk24M));

//Selecting color using "color_sel"
assign RGB_color = {2'b0,color_sel};

// Capture stable parameters in local clock domain
always @ (posedge clk24M or posedge rst)
if (rst) begin
RGB_color_s <= 4'b0000;
Brightness_s <= 4'b0111;
BreatheRamp_s <= 4'b0000;
BlinkRate_s <= 4'b0101;
end else if(!RGB_Blink_En) begin
RGB_color_s <= RGB_color ;
Brightness_s <= Brightness ;
BreatheRamp_s <= 4'b0000 ;
BlinkRate_s <= 4'b0000 ;
end else begin
RGB_color_s <= RGB_color ;
Brightness_s <= Brightness ;
BreatheRamp_s <= BreatheRamp ;
BlinkRate_s <= BlinkRate ;
end


// interpret 'brightness' setting
assign red_intensity = Brightness_s + 1'b1;
assign grn_intensity = Brightness_s + 1'b1;
assign blu_intensity = Brightness_s + 1'b1;


// interpret 'color' setting
always @ (RGB_color_s)
case (RGB_color_s)
4'b0000: begin red_set <= on_hi; grn_set <= off; blu_set <= off; end //Red
4'b0001: begin red_set <= on_hi; grn_set <= on_lo; blu_set <= off; end //Orange
4'b0010: begin red_set <= off; grn_set <= on_hi; blu_set <= off; end //Green
4'b0011: begin red_set <= off; grn_set <= on_hi; blu_set <= on_hi; end //Cyan
4'b0100: begin red_set <= off; grn_set <= on_hi; blu_set <= on_lo; end //SpringGreen
4'b0101: begin red_set <= on_hi; grn_set <= on_hi; blu_set <= off; end //Yellow
4'b0110: begin red_set <= on_lo; grn_set <= on_hi; blu_set <= off; end //Chartreuse
4'b0111: begin red_set <= off; grn_set <= on_lo; blu_set <= on_hi; end //Azure
4'b1000: begin red_set <= off; grn_set <= off; blu_set <= on_hi; end //Blue
4'b1001: begin red_set <= on_lo; grn_set <= off; blu_set <= on_hi; end //Violet
4'b1010: begin red_set <= on_hi; grn_set <= off; blu_set <= on_hi; end //Magenta
4'b1011: begin red_set <= on_hi; grn_set <= off; blu_set <= on_lo; end //Rose
4'b1111: begin red_set <= on_hi; grn_set <= on_hi; blu_set <= on_hi; end //White
default: begin red_set <= off; grn_set <= off; blu_set <= off; end //2'b00
endcase

// set peak values per 'brightness' and 'color'
// when color setting is 'on_lo', then peak intensity is divided by 2
always @ (posedge clk24M or posedge rst)
if (rst) begin
red_peak <= 32'b0;
end else begin
case (red_set)
on_hi: red_peak <= {red_intensity, 27'h000}; // 100%
on_lo: red_peak <= {1'b0,red_intensity, 26'h000}; // 50%
default: red_peak <= 32'h00000;
endcase
end
always @ (posedge clk24M or posedge rst)
if (rst) begin
grn_peak <= 32'b0;
end else begin
case (grn_set)
on_hi: grn_peak <= {grn_intensity, 27'h000}; // 100%
on_lo: grn_peak <= {1'b0,grn_intensity, 26'h000}; // 50%
default: grn_peak <= 32'h00000;
endcase
end
always @ (posedge clk24M or posedge rst)
if (rst) begin
blu_peak <= 32'b0;
end else begin
case (blu_set)
on_hi: blu_peak <= {blu_intensity, 27'h000}; // 100%
on_lo: blu_peak <= {1'b0,blu_intensity, 26'h000}; // 50%
default: blu_peak <= 32'h00000;
endcase
end
// interpret 'Blink rate' setting
// 'off_max_cnt' is time spent in 'LED_OFF' states
// 'step_shift' is used to scale the intensity step size.
// Stated period is blink rate with no ramp. Ramping adds to the period.
always @ (posedge clk24M or posedge rst)
if (rst) begin
off_max_cnt <= 28'h0 - 1;
//step_shift <= 4'b0;
end else begin
case (BlinkRate_s)
4'b0001: begin off_max_cnt <= 28'h016E35F; end // 1/16sec
4'b0010: begin off_max_cnt <= 28'h02DC6BE; end // 1/8 sec
4'b0011: begin off_max_cnt <= 28'h05B8D7B; end // 1/4 sec
4'b0100: begin off_max_cnt <= 28'h0B71AF6; end // 1/2 sec
4'b0101: begin off_max_cnt <= 28'h16E35ED; end // 1 sec
4'b0110: begin off_max_cnt <= 28'h2DC6BDA; end // 2 sec
4'b0111: begin off_max_cnt <= 28'h5B8D7B3; end // 4 sec


default: begin off_max_cnt <= 28'h0; end //
endcase
end


// interpret 'Breathe Ramp' setting
// 'ramp_max_cnt' is time spent in 'RAMP_UP', RAMP_DOWN' states
// '***_intensity_step' is calculated to add to color accumulators each ramp step
always @ (posedge clk24M or posedge rst)
if (rst) begin
ramp_max_cnt <= 28'b0;
red_intensity_step <= 28'b0;
grn_intensity_step <= 28'b0;
blu_intensity_step <= 28'b0;
end else begin
case (BreatheRamp_s)
4'b0001: begin
ramp_max_cnt <= 28'h016E35F; // 1/16sec
red_intensity_step <= red_peak >> (21) ;
grn_intensity_step <= grn_peak >> (21) ;
blu_intensity_step <= blu_peak >> (21) ;
end
4'b0010: begin
ramp_max_cnt <= 28'h02DC6BE; // 1/8 sec
red_intensity_step <= red_peak >> (22) ;
grn_intensity_step <= grn_peak >> (22) ;
blu_intensity_step <= blu_peak >> (22) ;
end
4'b0011: begin
ramp_max_cnt <= 28'h05B8D7B; // 1/4 sec
red_intensity_step <= red_peak >> (23) ;
grn_intensity_step <= grn_peak >> (23) ;
blu_intensity_step <= blu_peak >> (23) ;
end
4'b0100: begin
ramp_max_cnt <=28'h0B71AF6;
red_intensity_step <= red_peak >> (24) ;//1/2
grn_intensity_step <= grn_peak >> (24) ;
blu_intensity_step <= blu_peak >> (24) ;
end
4'b0101: begin
ramp_max_cnt <= 28'h16E35ED; // 1 sec
red_intensity_step <= red_peak >> (25) ;
grn_intensity_step <= grn_peak >> (25) ;
blu_intensity_step <= blu_peak >> (25) ;
end
4'b0110: begin
ramp_max_cnt <= 28'h2DC6BDA;
red_intensity_step <= red_peak >> (26) ; //2 sec
grn_intensity_step <= grn_peak >> (26) ;
blu_intensity_step <= blu_peak >> (26) ;
end
4'b0111: begin
ramp_max_cnt <= 28'h5B8D7B3; // 4 sec
red_intensity_step <= red_peak >> (27) ;
grn_intensity_step <= grn_peak >> (27) ;
blu_intensity_step <= blu_peak >> (27) ;
end
default: begin
ramp_max_cnt <= 28'd0;
red_intensity_step <= 28'b0;
grn_intensity_step <= 28'b0;
blu_intensity_step <= 28'b0;
end
endcase
end

// state machine to create LED ON/OFF/RAMP periods
// state machine is held (no cycles) if LED is steady state on/off
// state machine is reset to LED_ON state whenever parameters are updated.
always @ (posedge clk24M or posedge rst)
if (rst) begin
blink_state <= LED_OFF;
ramp_count <= 28'b0;
steady_count <= 28'b0;
end else begin
if(BlinkRate_s == 4'b0000) begin
blink_state <= LED_ON;
ramp_count <= 0;
steady_count <= 0;
end else if (BlinkRate_s == 4'b1000) begin
blink_state <= LED_OFF;
ramp_count <= 0;
steady_count <= 0;
end else begin
case (blink_state)
LED_OFF: begin
if(steady_count >= off_max_cnt) begin
ramp_count <= 0;
steady_count <= 0;
blink_state <= RAMP_UP;
end else begin
steady_count <= steady_count + 1;
end
end
RAMP_UP: begin
if(ramp_count >= ramp_max_cnt) begin
ramp_count <= 0;
steady_count <= 0;
blink_state <= LED_ON;
end else begin
ramp_count <= ramp_count + 1;
end
end
LED_ON: begin
if(steady_count >= on_max_cnt) begin
ramp_count <= 0;
steady_count <= 0;
blink_state <= RAMP_DOWN;
end else begin
steady_count <= steady_count + 1;
end
end
RAMP_DOWN: begin
if(ramp_count >= ramp_max_cnt) begin
ramp_count <= 0;
steady_count <= 0;
blink_state <= LED_OFF;
end else begin
ramp_count <= ramp_count + 1;
end
end
default: begin
blink_state <= LED_OFF;
ramp_count <= 28'b0;
steady_count <= 28'b0;
end
endcase
end
end


// RampUP/DN accumulators
always @ (posedge clk24M or posedge rst)
if (rst) begin
red_accum <= 32'b0;
grn_accum <= 32'b0;
blu_accum <= 32'b0;
end else begin
case (blink_state)
LED_OFF: begin
red_accum <= 0;
grn_accum <= 0;
blu_accum <= 0;
end
LED_ON: begin
// red_accum <= red_accum;
// grn_accum <= grn_accum;
// blu_accum <= blu_accum;
red_accum <= red_peak;
grn_accum <= grn_peak;
blu_accum <= blu_peak;
end
RAMP_UP: begin
red_accum <= red_accum + red_intensity_step;
grn_accum <= grn_accum + grn_intensity_step;
blu_accum <= blu_accum + blu_intensity_step;
end
RAMP_DOWN: begin
red_accum <= red_accum - red_intensity_step;
grn_accum <= grn_accum - grn_intensity_step;
blu_accum <= blu_accum - blu_intensity_step;
end
default: begin
red_accum <= 0;
grn_accum <= 0;
blu_accum <= 0;
end
endcase
end


// set PWM duty cycle. 8-bit resolution 0x100 is 100% on
always @ (posedge clk24M or posedge rst)
if (rst) begin
curr_red <= 18'b0;
curr_grn <= 18'b0;
curr_blu <= 18'b0;
end else begin
case (blink_state)
LED_ON: begin
curr_red <= red_peak[31:14]; // there should be no discrepancy between _peak and _accum in this state
curr_grn <= grn_peak[31:14];
curr_blu <= blu_peak[31:14];
end
RAMP_UP: begin
curr_red <= red_accum[31:14];
curr_grn <= grn_accum[31:14];
curr_blu <= blu_accum[31:14];
end
RAMP_DOWN: begin
curr_red <= red_accum[31:14];
curr_grn <= grn_accum[31:14];
curr_blu <= blu_accum[31:14];
end
LED_OFF: begin
curr_red <= 0;
curr_grn <= 0;
curr_blu <= 0;
end
default: begin
curr_red <= 0;
curr_grn <= 0;
curr_blu <= 0;
end
endcase
end

// generate PWM outputs
always @ (posedge clk24M or posedge rst)
if (rst) begin
pwm_count <= 18'b0;
red_pwm <= 0;
grn_pwm <= 0;
blu_pwm <= 0;
end else begin
if(pwm_count < 131071)
pwm_count <= pwm_count + 1;
else
pwm_count <= 0;
if(pwm_count < curr_red)
red_pwm <= 1;
else
red_pwm <= 0;

if(pwm_count < curr_grn)
grn_pwm <= 1;
else
grn_pwm <= 0;

if(pwm_count < curr_blu)
blu_pwm <= 1;
else
blu_pwm <= 0;
end


endmodule // LED_control



Write Preview
Loading…
Cancel
Save