LED reglabil folosind placa Basys 3: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

În acest ghid vom construi și controla un sistem extern de estompare cu LED-uri. Cu butoanele disponibile, utilizatorul poate estompa becul LED la orice luminozitate dorită. Sistemul folosește placa Basys 3 și este conectat la o placă care conține un rezistor și becul LED. Apăsarea butonului „sus” desemnat va crește luminozitatea, iar apăsarea butonului „jos” va reduce luminozitatea până la zero. Acest lucru nu numai că împiedică utilizatorul să fie orbit de becurile strălucitoare ca și soarele, dar conservă și energia!

Pasul 1: Creați un contor de intrare

Pentru acest pas creăm componenta care determină nivelul de luminozitate (printr-un ceas) folosind două comutatoare: unul pentru a crește și unul pentru a scădea. Folosind VHDL, am produs contorul prin utilizarea de flip-flops D. Apăsarea butonului „sus” împinge următoarea stare la starea actuală, ieșind pe afișajul cu șapte segmente și becul LED.

entitatea updown_counter este

Port (present_state: out STD_LOGIC_VECTOR (3 downto 0); previous_state: in STD_LOGIC_VECTOR (3 downto 0); next_state: in STD_LOGIC_VECTOR (3 downto 0); clk: in STD_LOGIC; down_enable: in STD_LOGIC; up_en; end updown_counter; arhitectură Comportamentul updown_counter este begin flop: process (next_state, clk, up_enable, down_enable, previous_state) begin if (rising_edge (clk)) then if (up_enable = '1' and not (next_state = "0000")) then present_state <= next_state; elsif (down_enable = '1' and not (previous_state = "1111")) then present_state <= previous_state; incheie daca; incheie daca; încheierea procesului flop; final Comportamental;

De asemenea, avem nevoie de un ceas pentru fiecare intrare pe care să fie blocat (când crește), așa că am creat și un divizor de ceas care determină cât de repede pot fi apăsate butoanele între fiecare nivel de luminozitate. Acest divizor de ceas ne permite să afișăm corect nivelul corect pe afișajul de șapte segmente și să producem nivelul corect de intensitate pentru fiecare nivel.

entitatea counter_clkDiv este

Port (clk: in std_logic; sclk: out std_logic); end counter_clkDiv; arhitectura my_clk_div din counter_clkDiv este constantă max_count: întreg: = (10000000); semnal tmp_clk: std_logic: = '0'; începe my_div: process (clk, tmp_clk) variabilă div_cnt: întreg: = 0; începe if (rising_edge (clk)) atunci if (div_cnt> = MAX_COUNT) atunci tmp_clk <= not tmp_clk; div_cnt: = 0; else div_cnt: = div_cnt + 1; incheie daca; incheie daca; sclk <= tmp_clk; end process my_div; end my_clk_div;

Pasul 2: Creați un divizor de ceas LED

Pentru acest pas creăm un separator de ceas pentru becul LED pentru a determina 16 niveluri diferite de intensitate. Cu 0 dezactivat până la 15 afișând luminozitatea maximă, divizorul de ceas crește fiecare apăsare a butonului cu ceea ce am setat a fi nivelurile de luminozitate. Fiecare nivel în creștere a însemnat o creștere a ceasului pentru becul LED. Amintindu-ne că luminozitatea nu crește liniar, am pornit ceasul la cel mai înalt nivel și ne-am redus ceasurile în consecință.

Notă: folosim un LED albastru. Utilizarea unei culori diferite (cum ar fi roșul) va necesita cu totul ceasuri ușor diferite; o setare de luminozitate medie pentru albastru ar putea fi deja luminozitate maximă pentru roșu. Acest lucru se întâmplă deoarece diferite lungimi de undă ale luminii vor necesita cantități diferite de energie, culorile mai reci, cum ar fi violetul și albastrul, necesită mai multă energie, în timp ce culorile mai calde, cum ar fi roșul și portocaliul, necesită mai puțină energie.

entitatea led_clkDiv este Port (prezent_stat: în STD_LOGIC_VECTOR (3 până la 0); clk: în STD_LOGIC; led_clk: în afara STD_LOGIC); end led_clkDiv; arhitectură Comportamentul led_clkDiv este semnalul tmp_clk: std_logic: = '0'; variabilă partajată max_count: întreg; begin count_stuff: process (present_state) begin case present_state este când "0000" => max_count: = 0; când "0001" => max_count: = 2; când "0010" => max_count: = 4; când "0011" => max_count: = 6; când "0100" => max_count: = 8; când "0101" => max_count: = 10; când "0110" => max_count: = 12; când "0111" => max_count: = 14; când "1000" => max_count: = 16; când "1001" => max_count: = 25; când "1010" => max_count: = 50; când "1011" => max_count: = 100; când "1100" => max_count: = 150; când "1101" => max_count: = 200; când "1110" => max_count: = 250; când "1111" => max_count: = 300; caz final; sfârșitul procesului count_stuff; my_div: process (clk, tmp_clk, present_state) variabilă div_cnt: întreg: = 0; începe if (rising_edge (clk)) atunci if (div_cnt> = max_count) atunci tmp_clk <= not tmp_clk; div_cnt: = 0; else div_cnt: = div_cnt + 1; incheie daca; incheie daca; led_clk <= tmp_clk; end process my_div; final Comportamental;

Pasul 3: Crearea controlerului LED

Acum, că am ajuns până acum, este timpul să combinăm în cele din urmă toate componentele pe care le-am creat până acum în fișierul LED Controller.

Pentru a rezuma, componentele utilizate sunt următoarele:

• Contor de intrare (updown_counter)
• Divizor de ceas (counter_clkDiv)
• Separator de ceas cu LED (led_clkDiv)
• Driver de afișare cu șapte segmente (sseg_dec) (fișier atașat)

Driverul de afișare cu șapte segmente nu a fost discutat anterior, deoarece am împrumutat de fapt fișierul VHDL de la Dr. Bryan Mealy datorită codului său lung și complicat. Ceea ce face în esență este să conducă intrările butoanelor noastre pe afișajul cu șapte segmente de pe placa Basys 3, astfel încât să știm ce nivel de luminozitate este activat.

Mergând înainte, controlerul cu LED utilizează flip flops pentru a crește sau micșora numărul care controlează atât afișajul cu șapte segmente, cât și nivelul de luminozitate al becului LED simultan.

contorul de entități este Port (clk: în STD_LOGIC; up_enable: în STD_LOGIC; down_enable: în STD_LOGIC; SEGMENTE: out STD_LOGIC_VECTOR (7 downto 0); DISP_EN: out STD_LOGIC_VECTOR (3 downto 0); led_clk: out STD_LOG; contor de capăt; arhitectura Comportamentul contorului este component updown_counter este Port (prezent_stat: out STD_LOGIC_VECTOR (3 până la 0); precedent_stat: în STD_LOGIC_VECTOR (3 până la 0); următor_stat: în STD_LOGIC_VECTOR (3 până la 0); clk: în STD_LOGIC; up_enable: în STD_LOGIC); component final endown_counter; component counter_clkDiv este Port (clk: in std_logic; sclk: out std_logic); component final counter_clkDiv; componenta sseg_dec este Port (ALU_VAL: în std_logic_vector (7 până la 0); SIGN: în std_logic; VALABIL: în std_logic; CLK: în std_logic; DISP_EN: out std_logic_vector (3 până la 0); SEGMENTS: out std_logic_vector (7 down); componentă finală sseg_dec; componenta led_clkDiv este Port (prezent_stat: în STD_LOGIC_VECTOR (3 până la 0); clk: în STD_LOGIC; led_clk: în afara STD_LOGIC); component final led_clkDiv; signal present_state: STD_LOGIC_VECTOR (3 downto 0): = "0000"; semnal next_state: STD_LOGIC_VECTOR (3 downto 0): = "0000"; semnal anterior_stat: STD_LOGIC_VECTOR (3 până la 0): = "0000"; semnal Alu_Val: STD_LOGIC_VECTOR (7 până la 0); semnal sclk: STD_LOGIC; începe Alu_Val (7 până la 4) <= "0000"; Alu_Val (3 downto 0) <= present_state; next_state (0) <= not (present_state (0)); next_state (1) <= present_state (0) xor present_state (1); next_state (2) <= (present_state (0) and present_state (1)) xor present_state (2); next_state (3) <= (present_state (0) and present_state (1) and present_state (2)) xor present_state (3); previous_state (0) <= not (present_state (0)); previous_state (1) <= present_state (0) xnor present_state (1); previous_state (2) <= (present_state (0) nor present_state (1)) xor present_state (2); previous_state (3) sclk, next_state => next_state, previous_state => previous_state, up_enable => up_enable, down_enable => down_enable, present_state => present_state); afișare: harta portului sseg_dec (ALU_VAL => Alu_Val, SIGN => '0', VALID => '1', CLK => clk, DISP_EN => DISP_EN, SEGMENTS => SEGMENTS); led_div: led_clkHarta portului Div (clk => clk, present_state => present_state, led_clk => led_clk); clk_div: counter_clkHarta porturilor Div (clk => clk, sclk => sclk); final Comportamental;

Pasul 4: Stabilirea constrângerilor și asamblarea

Constrângeri

Pentru a configura și programa corect placa Basys 3, trebuie mai întâi să configurați fișierul nostru de constrângeri care este atașat acestui pas. Au fost ajustate următoarele setări:

Butoane

• S-a schimbat T18 în „up_enable” (crește luminozitatea)
• S-a schimbat U17 la „down_enable” (scădere luminozitate)

Afișaj pe 7 segmente

• W7, W6, U8, V8, U5, V5, U7, V7 reprezintă fiecare segment al unui afișaj
• U2, U4, V4, W4 reprezintă fiecare anod afișat (doar 2 sunt activi deoarece numărul nostru cel mai mare este 15)

PMOD Header JC

JC7 este locul în care conectăm unul dintre firele becului cu LED, iar celălalt fir duce la Pământ

După ce ați configurat totul, tot ce trebuie să faceți este să vă generați fluxul de biți (cu orice software pe care îl utilizați, adică Vivado), să vă programați placa și să boom! Ți-ai luat un consiliu de lucru.

Notă: maparea pinilor poate fi găsită în foaia de date Basys 3 aici.

Asamblare

Pasul 5: Utilizarea comutatorului Dimmer

Dacă totul merge bine, ar trebui să aveți un sistem de dimmer complet funcțional. Pentru a rezuma, apăsarea butonului de sus vă va crește luminozitatea (până la 15), iar apăsarea butonului în jos vă va reduce luminozitatea (până la 0). Sper că totul merge bine pentru vederea ta acum relaxată!