Lampioni stradali ad alta efficienza energetica: 8 passaggi

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

Il nostro obiettivo con questo progetto era creare qualcosa che risparmiasse energia e risorse finanziarie alle comunità. I lampioni attivati dal movimento farebbero entrambe le cose. In tutta la nazione l'energia viene sprecata per i lampioni stradali che illuminano le strade vuote. Il nostro sistema di illuminazione stradale assicura che le luci siano accese solo quando necessario, facendo risparmiare alle comunità innumerevoli dollari. Utilizzando i sensori di movimento, il sistema accende le luci solo in presenza di auto. Sempre per la sicurezza dei pedoni, abbiamo implementato un pulsante di override che accende tutte le luci della strada. I seguenti passaggi ti guideranno attraverso il modo in cui abbiamo progettato e realizzato il nostro modello in scala ridotta del progetto utilizzando Vivado e una scheda Basys 3.

Passaggio 1: scatola nera del sistema

Abbiamo iniziato questo progetto disegnando un semplice diagramma a scatola nera. Un diagramma a scatola nera mostra semplicemente gli input e gli output richiesti dal nostro sistema per completare tutti i processi necessari. Abbiamo cercato di mantenere il nostro design il più semplice ed essenziale possibile. I nostri tre ingressi di sistema includevano un bus di sensori di movimento (4 per il nostro modello ridotto), un pulsante di esclusione pedonale e un ingresso orologio. Dall'altro lato la nostra singola uscita è un bus di luci a LED che rappresentano i nostri lampioni. Per questo modello abbiamo utilizzato uno scenario di 16 lampioni semplicemente perché questo è il numero massimo di uscite LED integrate sulla scheda Basys 3. Infine, utilizzando questo diagramma siamo stati in grado di creare il nostro progetto Vivado, i file di origine e di vincolo con input e output appropriati.

Passaggio 2: componenti

In questo passaggio ci addentriamo più a fondo esaminando i componenti che compongono il nostro diagramma a scatola nera. Il nostro primo componente è un file sorgente VHDL contenente D flip-flop. I flip-flop D prendono semplicemente qualsiasi segnale venga loro inviato dai sensori sul fronte di salita del clock e bloccano quei dati fino al successivo fronte di salita. Ciò impedisce ai nostri sensori di movimento sensibili di causare il "sfarfallio" dei LED di uscita. Inoltre, abbiamo inserito un singolo flip-flop D sul segnale di ingresso del pulsante per mantenere i LED accesi per circa 5-7 secondi dopo che il pulsante è stato premuto. Abbiamo anche passato questo attraverso un divisore dell'orologio.

entità clk_div2 è la porta (clk: in std_logic; sclk: out std_logic); fine clk_div2;

architettura my_clk_div di clk_div2 è

costante max_count: intero:= (300000000); 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;

Il nostro componente finale in questo diagramma è un file sorgente VHDL comportamentale contenente i condizionali per gli output basati sulla configurazione dei segnali di input.

Passaggio 3: D Infradito

I quattro flip-flop collegati ai segnali di ingresso sono essenziali per la funzionalità del nostro sistema. Come detto in precedenza, con sensori di movimento sensibili e un pulsante di override, i flip-flop utilizzano i latch per emettere il nostro segnale di ingresso solo sul fronte di salita del clock. Questa logica sequenziale significa che i nostri lampioni possono rimanere accesi per un determinato periodo di tempo dopo essere stati attivati da un movimento rapido. La codifica per un D-Flip Flop è piuttosto semplice:

beginprocess (CLK) begin if rise_edge(CLK) then Q <= D; finisci se; fine del processo;

L'intera cosa può essere compilata in un'unica istruzione if. Una volta ottenuto questo pezzo, abbiamo creato un file sorgente VHDL strutturale contenente tutti e quattro i nostri flip-flop necessari:

begin DFF0: mappa della porta DFF (CLK => CLK, D => D(0), Q => Q(0)); DFF1: mappa della porta DFF (CLK => CLK, D => D(1), Q => Q(1)); DFF2: mappa della porta DFF (CLK => CLK, D => D(2), Q => Q(2)); DFF3: mappa delle porte DFF (CLK => CLK, D => D(3), Q => Q(3));

fine comportamentale;

Ciò aiuta a mantenere il nostro file strutturale principale in cui riuniamo tutti i componenti del sistema in modo molto più pulito e organizzato.

Passaggio 4: condizionali

Per mantenere il nostro codice compatto ed efficiente, abbiamo scritto tutti i nostri condizionali in un'unica istruzione case. Per il nostro modello ridotto, avevamo 16 possibili configurazioni di uscita LED poiché ogni sensore di movimento è responsabile di un gruppo di 4 LED.:

caso NMS è quando "1111" => LED LED LED LED LED LED LED LED LED LED LED LED LED LED LED LED <= "111111111111111"; caso finale;

Passaggio 5: vincoli

Per dichiarare correttamente i tuoi input e output usando Vivado, devi implementare un file di vincoli che indichi tutte le porte, i pulsanti, i LED e gli orologi utilizzati.

set_property PACKAGE_PIN W5 [get_ports CLK] set_property IOSTANDARD LVCMOS33 [get_ports CLK]

set_property PACKAGE_PIN U16 [get_ports {LED[0]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[0]}] set_property PACKAGE_PIN E19 [get_ports {LED[1]}] set_property IOSTANDARD LVCMOS33_PAGE]PACKs {LED[1]} U19 [get_ports {LED[2]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[2]}] set_property PACKAGE_PIN V19 [get_ports {LED[3]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[3]}] set_property 18 [PACKAGE_PIN W get_ports {LED[4]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[4]}] set_property PACKAGE_PIN U15 [get_ports {LED[5]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[5]}] set_property UV14 PACKAGE_PIN {get_PIN LED[6]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[6]}] set_property PACKAGE_PIN V14 [get_ports {LED[7]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[7]}] set_property PACKAGE_PIN V13 [get 8]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[8]}] set_property PACKAGE_PIN V3 [get_ports {LED[9]}] set_property IO STANDARD LVCMOS33 [get_ports {LED[9]}] set_property PACKAGE_PIN W3 [get_ports {LED[10]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[10]}] set_property PACKAGE_PIN U3 [get_ports {LED[11]}OSTANDARD LVCMOS33 [get_ports {LED[11]}] set_property PACKAGE_PIN P3 [get_ports {LED[12]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[12]}] set_property PACKAGE_PIN N3 [get_ports {LED[13]}] set_property IOSTANDARD LVCMOS33 {LED[13]}] set_property PACKAGE_PIN P1 [get_ports {LED[14]}] set_property IOSTANDARD LVCMOS33 [get_ports {LED[14]}] set_property PACKAGE_PIN L1 [get_ports {LED[15]}] set_property IOSTANDARD LVCMOS33 [get [15]}]

set_property PACKAGE_PIN U18 [get_ports BTN] set_property IOSTANDARD LVCMOS33 [get_ports BTN]

set_property PACKAGE_PIN A14 [get_ports {MS[0]}] set_property IOSTANDARD LVCMOS33 [get_ports {MS[0]}] set_property PACKAGE_PIN A16 [get_ports {MS[1]}] set_property IOSTANDARD LVCMOS33_PAGE]PACKs {MS[1]} B15 [get_ports {MS[2]}] set_property IOSTANDARD LVCMOS33 [get_ports {MS[2]}] set_property PACKAGE_PIN B16 [get_ports {MS[3]}] set_property IOSTANDARD LVCMOS33 [get_ports {MS[3]}]

Passaggio 6: file sorgente principale

In questo file principale riuniamo tutti i file sorgente dei componenti menzionati in precedenza. Questo file funziona come codice strutturale che riunisce i diversi componenti.

entità Master_Final_Project è la porta (BTN: in STD_LOGIC; CLK: in STD_LOGIC; MS: in STD_LOGIC_VECTOR (3 fino a 0); LED: out STD_LOGIC_VECTOR (15 fino a 0)); fine Master_Final_Project;

architettura Il comportamento di Master_Final_Project è

componente final_project è Port (--CLK: in STD_LOGIC; NMS: in STD_LOGIC_VECTOR (3 fino a 0); BTN: in STD_LOGIC; --sw: in STD_LOGIC_Vector (1 fino a 0); LED: out STD_LOGIC_VECTOR (15 fino a 0)); componente finale;

componente Final_DFF è

Porta (CLK: in STD_LOGIC; D: in STD_LOGIC_Vector (3 fino a 0); Q: out STD_LOGIC_Vector (3 fino a 0)); componente finale;

segnale DFF02proj30: STD_LOGIC;

segnale DFF12proj74: STD_LOGIC; segnale DFF22proj118: STD_LOGIC; segnale DFF32proj1512: STD_LOGIC;

inizio

DFF0: Mappa delle porte Final_DFF (CLK => CLK, D(0) => MS(0), D(1) => MS(1), D(2) => MS(2), D(3) => MS(3), Q(0) => DFF02proj30, Q(1) => DFF12proj74, Q(2) => DFF22proj118, Q(3) => DFF32proj1512); Proj0: mappa delle porte final_project (NMS(0) => DFF02proj30, NMS(1) => DFF12proj74, NMS(2) => DFF22proj118, NMS(3) => DFF32proj1512, BTN => BTN, LED => LED); fine comportamentale;

Passaggio 7: assemblaggio

L'assemblaggio hardware per questo progetto è minimo. Gli unici pezzi richiesti sono i seguenti:

1. Scheda Basys 3 (1)

2. Sensori di movimento economici che puoi trovare su Amazon qui. (4)

3. Cavi da maschio a femmina (4)

Assemblea:

1. Collegare 4 cavi maschi alle porte JB dell'intestazione PMod 1-4 (vedere la figura).

2. Collegare le estremità femmina al pin di uscita di ciascun sensore di movimento.

Passaggio 8: caricamento del programma

Ora siamo pronti per caricare il file sorgente master VHDL sulla scheda Basys 3. Assicurati di eseguire la sintesi, l'implementazione e generare il controllo del flusso di bit per eventuali errori. Se tutto funziona correttamente, apri il gestore hardware e programma il dispositivo Basys 3. Il tuo progetto ora è completo!