LED dimmerabile utilizzando la scheda Basys 3: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

In questa guida andremo a costruire e controllare un sistema di regolazione LED esterno. Con i pulsanti disponibili, l'utente può regolare la lampadina LED a qualsiasi luminosità desiderata. Il sistema utilizza la scheda Basys 3 ed è collegato a una breadboard che contiene un resistore e la lampadina LED. Premendo il pulsante "su" designato aumenterà la luminosità e premendo il pulsante "giù" si diminuirà la luminosità fino a zero. Ciò non solo impedisce all'utente di essere accecato da lampadine luminose come il sole, ma consente anche di risparmiare energia!

Passaggio 1: creare un contatore di input

Per questo passaggio creiamo il componente che determina il livello di luminosità (tramite un orologio) utilizzando due interruttori: uno per aumentare e uno per diminuire. Usando VHDL, abbiamo prodotto il contatore attraverso l'uso di infradito D. Premendo il pulsante "su" si spinge lo stato successivo allo stato attuale, emettendo l'output sul display a sette segmenti e sulla lampadina a LED.

l'entità updown_counter è

Porta (present_state: out STD_LOGIC_VECTOR (3 fino a 0); precedente_state: in STD_LOGIC_VECTOR (3 fino a 0); next_state: in STD_LOGIC_VECTOR (3 fino a 0); clk: in STD_LOGIC; down_enable: in STD_LOGIC; up_enable: in STD_ fine updown_counter; architettura Il comportamento di updown_counter è 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 <= stato_successivo; elsif (down_enable = '1' and not(previous_state= "1111")) then present_state <= previous_state; finisci se; finisci se; fine processo flop; fine comportamentale;

Abbiamo anche bisogno di un clock su cui agganciare ogni ingresso (quando sale), quindi abbiamo anche creato un divisore di clock che determina la velocità con cui i pulsanti possono essere premuti tra ogni livello di luminosità. Questo divisore dell'orologio ci permette di visualizzare correttamente il giusto livello sul display a sette segmenti e di produrre il giusto livello di intensità per ogni livello.

entità counter_clkDiv è

Porta (clk: in std_logic; sclk: out std_logic); fine counter_clkDiv; architettura my_clk_div di counter_clkDiv è costante max_count: intero: = (10000000); segnale tmp_clk: std_logic:= '0'; begin my_div: variabile di processo (clk, tmp_clk) div_cnt: intero:= 0; begin if (rising_edge(clk)) then if (div_cnt >= MAX_COUNT) then tmp_clk <= not tmp_clk; div_cnt:= 0; else div_cnt:= div_cnt + 1; finisci se; finisci se; sclk <= tmp_clk; termina il processo my_div; termina my_clk_div;

Passaggio 2: crea un divisore per orologio a LED

Per questo passaggio creiamo un divisore orologio per la lampadina LED per determinare 16 diversi livelli di intensità. Con 0 da spento a 15 che visualizza la luminosità massima, il divisore dell'orologio incrementa ogni pressione del pulsante di quelli che abbiamo impostato come livelli di luminosità. Ogni aumento del livello significava un aumento dell'orologio per la lampadina a LED. Ricordando che la luminosità non aumenta in modo lineare, abbiamo alzato l'orologio al massimo possibile e diminuito di conseguenza i nostri orologi.

Nota: stiamo usando un LED blu. L'uso di un colore diverso (come il rosso) richiederà orologi leggermente diversi; un'impostazione di luminosità media per il blu potrebbe già essere la luminosità massima per il rosso. Ciò accade perché diverse lunghezze d'onda della luce richiedono quantità diverse di energia, con i colori più freddi come il viola e il blu che richiedono più energia, mentre i colori più caldi come il rosso e l'arancione richiedono meno energia.

entità led_clkDiv è Port (present_state: in STD_LOGIC_VECTOR (3 fino a 0); clk: in STD_LOGIC; led_clk: fuori STD_LOGIC); fine led_clkDiv; architettura Il comportamento di led_clkDiv è il segnale tmp_clk: std_logic:= '0'; variabile condivisa max_count: intero;begin count_stuff: process (present_state) begin case present_state è quando "0000" => max_count:= 0; quando "0001" => max_count:= 2; quando "0010" => max_count:= 4; quando "0011" => max_count:= 6; quando "0100" => max_count:= 8; quando "0101" => max_count:= 10; quando "0110" => max_count:= 12; quando "0111" => max_count:= 14; quando "1000" => max_count:= 16; quando "1001" => max_count:= 25; quando "1010" => max_count:= 50; quando "1011" => max_count:= 100; quando "1100" => max_count:= 150; quando "1101" => max_count:= 200; quando "1110" => max_count:= 250; quando "1111" => max_count:= 300; caso finale; fine processo count_stuff; my_div: variabile di processo (clk, tmp_clk, present_state) div_cnt: intero:= 0; begin if (rising_edge(clk)) then if (div_cnt >= max_count) then tmp_clk <= not tmp_clk; div_cnt:= 0; else div_cnt:= div_cnt + 1; finisci se; finisci se; led_clk <= tmp_clk; termina il processo my_div; fine comportamentale;

Passaggio 3: creazione del controller LED

Ora che siamo arrivati fino a questo punto, è il momento di combinare finalmente tutti i componenti che abbiamo creato finora nel file del controller LED.

Riassumendo, i componenti utilizzati sono i seguenti:

• Contatore ingressi (updown_counter)
• Divisore orologio (counter_clkDiv)
• Divisore orologio LED (led_clkDiv)
• Driver display a sette segmenti (sseg_dec) (file allegato)

Il driver del display a sette segmenti non è stato effettivamente discusso in precedenza perché in realtà abbiamo preso in prestito il file VHDL dal Dr. Bryan Mealy a causa del suo codice lungo e complicato. Ciò che essenzialmente fa è guidare i nostri ingressi dei pulsanti sul display a sette segmenti sulla scheda Basys 3 in modo da sapere quale livello di luminosità è attivo.

Andando avanti, il controller LED utilizza le infradito per aumentare o diminuire il conteggio che controlla contemporaneamente sia il display a sette segmenti che il livello di luminosità della lampadina a LED.

contatore di entità è Port (clk: in STD_LOGIC; up_enable: in STD_LOGIC; down_enable: in STD_LOGIC; SEGMENTS: out STD_LOGIC_VECTOR (7 fino a 0); DISP_EN: out STD_LOGIC_VECTOR (3 fino a 0); led_clk: out STD_LOGIC); fine contatore; architettura Il comportamento del contatore è il componente updown_counter è Port (present_state: out STD_LOGIC_VECTOR (3 fino a 0); previous_state: in STD_LOGIC_VECTOR (3 fino a 0); next_state: in STD_LOGIC_VECTOR (3 fino a 0); clk: in STD_LOGIC; down_enable: in STD_LOGIC; up_enable: in STD_LOGIC); componente finale updown_counter; componente counter_clkDiv è Port (clk: in std_logic; sclk: out std_logic); componente finale counter_clkDiv; componente sseg_dec è Port (ALU_VAL: in std_logic_vector(7 downto 0); SIGN: in std_logic; VALID: in std_logic; CLK: in std_logic; DISP_EN: out std_logic_vector(3 downto 0); SEGMENTS: down_out std; componente finale sseg_dec; componente led_clkDiv è Port (present_state: in STD_LOGIC_VECTOR (3 fino a 0); clk: in STD_LOGIC; led_clk: fuori STD_LOGIC); componente finale led_clkDiv; segnale present_state: STD_LOGIC_VECTOR (3 fino a 0):= "0000"; segnale next_state: STD_LOGIC_VECTOR (3 fino a 0):= "0000"; segnale precedente_stato: STD_LOGIC_VECTOR (3 fino a 0):= "0000"; segnale Alu_Val: STD_LOGIC_VECTOR (7 fino a 0); segnale sclk: STD_LOGIC; begin Alu_Val(7 downto 4) <= "0000"; Alu_Val(3 fino a 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) e present_state(1)) xor present_state(2); next_state(3) <= (present_state(0) e present_state(1) e present_state(2)) xor present_state(3); stato_precedente(0) <= not(stato_presente(0)); stato_precedente(1) <= stato_presente(0) xnor stato_presente(1); stato_precedente(2) <= (stato_presente(0) né stato_presente(1)) xor stato_presente(2); stato_precedente(3) sclk, stato_successivo => stato_successivo, stato_precedente => stato_precedente, up_enable => stato_up, stato_down => stato_down, stato_presente => stato_presente); display: sseg_dec port map(ALU_VAL => Alu_Val, SIGN => '0', VALID => '1', CLK => clk, DISP_EN => DISP_EN, SEGMENTS => SEGMENTS); led_div: mappa porta led_clkDiv(clk => clk, present_state => present_state, led_clk => led_clk); clk_div: counter_clkDiv port map(clk => clk, sclk => sclk); fine comportamentale;

Passaggio 4: definizione dei vincoli e assemblaggio

vincoli

Per impostare e programmare correttamente la scheda Basys 3, dobbiamo prima impostare il nostro file dei vincoli che è allegato a questo passaggio. Le seguenti impostazioni sono state modificate:

pulsanti

• T18 cambiato in "up_enable" (aumenta la luminosità)
• Modificato U17 in "down_enable" (riduce la luminosità)

Display a 7 segmenti

• W7, W6, U8, V8, U5, V5, U7, V7 rappresentano ogni segmento di un display
• U2, U4, V4, W4 rappresentano ogni anodo visualizzato (solo 2 sono attivi perché il nostro numero più alto è 15)

Intestazione PMOD JC

JC7 è dove colleghiamo uno dei fili della lampadina a LED e l'altro filo porta a TERRA

Dopo aver impostato tutto, tutto ciò che devi fare è generare il tuo bitstream (con qualsiasi software tu stia utilizzando, ad esempio Vivado), programmare la tua scheda e boom! Ti sei procurato un tavolo da lavoro.

Nota: la mappatura dei pin può essere trovata nella scheda tecnica Basys 3 qui.

Assemblea

Passaggio 5: utilizzo dell'interruttore dimmer

Se tutto va bene, dovresti avere un sistema dimmer perfettamente funzionante. Per riassumere, premendo il pulsante in alto si aumenterà la luminosità (fino a 15) e premendo il pulsante in basso si diminuirà la luminosità (fino a 0). Spero che tutto vada bene per la tua vista ora rilassata!