Lampadaires écoénergétiques activés par le mouvement : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Notre objectif avec ce projet était de créer quelque chose qui permettrait aux communautés d'économiser de l'énergie et des ressources financières. Les lampadaires activés par le mouvement feraient ces deux choses. Partout dans le pays, l'énergie est gaspillée dans les lampadaires qui éclairent les rues vides. Notre système d'éclairage public garantit que les lumières ne sont allumées qu'en cas de besoin, ce qui permet aux communautés d'économiser d'innombrables dollars. À l'aide de capteurs de mouvement, le système allume les lumières uniquement lorsque des voitures sont présentes. Également pour la sécurité des piétons, nous avons mis en place un bouton de dérogation qui allume toutes les lumières de la rue. Les étapes suivantes vous expliqueront comment nous avons conçu et construit notre modèle réduit du projet à l'aide de Vivado et d'une carte Basys 3.

Étape 1: boîte noire du système

Nous avons commencé ce projet en dessinant un simple diagramme de boîte noire. Un diagramme de boîte noire montre simplement les entrées et les sorties dont notre système a besoin pour terminer tous les processus nécessaires. Nous avons essayé de garder notre conception aussi simple et basique que possible. Nos trois entrées système comprenaient un bus de capteurs de mouvement (4 pour notre modèle réduit), un bouton de priorité pour piétons et une entrée d'horloge. De l'autre côté notre unique sortie est un bus de lumières LED représentant nos lampadaires. Pour ce modèle, nous avons utilisé un scénario de 16 lampadaires simplement parce que c'est le nombre maximum de sorties LED intégrées sur la carte Basys 3. Enfin, à l'aide de ce diagramme, nous avons pu créer nos fichiers de projet, source et contrainte Vivado avec les entrées et sorties appropriées.

Étape 2: Composants

Dans cette étape, nous approfondissons l'examen des composants qui composent notre diagramme de la boîte noire. Notre premier composant est un fichier source VHDL contenant des bascules D. Les bascules D prennent simplement le signal qui leur est envoyé par les capteurs sur le front montant de l'horloge et verrouillent ces données jusqu'au prochain front montant. Cela empêche nos capteurs de mouvement sensibles de provoquer le "scintillement" des LED de sortie. De plus, nous plaçons une seule bascule D sur le signal d'entrée du bouton pour que les LED restent allumées pendant environ 5 à 7 secondes après avoir appuyé sur le bouton. Nous avons également fait passer cela à travers un diviseur d'horloge.

l'entité clk_div2 est le port (clk: in std_logic; sclk: out std_logic); fin clk_div2;

l'architecture my_clk_div de clk_div2 est

constante max_count: entier:= (300000000); signal tmp_clk: std_logic:= '0'; begin my_div: processus (clk, tmp_clk) variable div_cnt: entier:= 0; begin if (rising_edge(clk)) then if (div_cnt = MAX_COUNT) then tmp_clk <= not tmp_clk; div_cnt:= 0; sinon div_cnt:= div_cnt + 1; fin si; fin si; sclk <= tmp_clk; fin du processus my_div; fin my_clk_div;

Notre dernier composant dans ce diagramme est un fichier source VHDL comportemental contenant des conditions pour les sorties basées sur la configuration des signaux d'entrée.

Étape 3: D Tongs

Les quatre bascules attachées aux signaux d'entrée sont essentielles à la fonctionnalité de notre système. Comme indiqué précédemment, avec des capteurs de mouvement sensibles et un bouton de priorité, les bascules utilisent des verrous pour ne sortir notre signal d'entrée que sur le front montant de l'horloge. Cette logique séquentielle signifie que nos lampadaires peuvent rester allumés pendant une période de temps définie après avoir été déclenchés par un mouvement rapide. Le codage d'un D-Flip Flop est assez simple:

beginprocess (CLK) begin if missing_edge(CLK) alors Q <= D; fin si; processus final;

Le tout peut être compilé en une seule instruction if. Une fois que nous avons eu cette pièce, nous avons créé un fichier source VHDL structurel contenant nos quatre bascules nécessaires:

begin DFF0: mappage des ports DFF (CLK => CLK, D => D(0), Q => Q(0)); DFF1: mappage des ports DFF (CLK => CLK, D => D(1), Q => Q(1)); DFF2: mappage des ports DFF (CLK => CLK, D => D(2), Q => Q(2)); DFF3: mappage des ports DFF (CLK => CLK, D => D(3), Q => Q(3));

mettre fin au comportement;

Cela aide à garder notre fichier structurel principal où nous rassemblons tous les composants du système beaucoup plus propres et organisés.

Étape 4: Conditions

Afin de garder notre code compact et efficace, nous avons écrit toutes nos conditions dans une seule instruction case. Pour notre modèle réduit, nous avions 16 configurations de sortie LED possibles car chaque capteur de mouvement est responsable d'un groupe de 4 LED.:

le cas NMS est lorsque "1111" => LED LED LED LED LED LED LED LED LED LED LED LED LED LED LED LED <= "111111111111111111"; cas d'extrémité;

Étape 5: Contraintes

Afin d'indiquer correctement vos entrées et sorties à l'aide de Vivado, vous devez implémenter un fichier de contraintes indiquant tous les ports, boutons, LED et horloges utilisés.

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 LVCAGE_MOS33 [get_PORTs_property {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 W18 PACKAGE_PIN 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 PACKAGE_PIN U14 [get_ports 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_ports {LED[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]}] set_property [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_ports IOSTANDARD LVCMOS33 [getANDARD LVCMOS {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_porterty IOSTANDARD LVCMOS33 [getLED_LVCMOS33

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 LVCAGE_MOS33 [get_ports_property {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]}]

Étape 6: Fichier source principal

Dans ce fichier principal, nous rassemblons tous les fichiers sources des composants mentionnés précédemment. Ce fichier fonctionne comme un code structurel rassemblant les composants disparates.

l'entité Master_Final_Project est Port (BTN: dans STD_LOGIC; CLK: dans STD_LOGIC; MS: dans STD_LOGIC_VECTOR (3 jusqu'à 0); LED: out STD_LOGIC_VECTOR (15 jusqu'à 0)); fin Master_Final_Project;

architecture Le comportement de Master_Final_Project est

le composant final_project est Port (--CLK: dans STD_LOGIC; NMS: dans STD_LOGIC_VECTOR (3 jusqu'à 0); BTN: dans STD_LOGIC; --sw: dans STD_LOGIC_Vector (1 jusqu'à 0); LED: out STD_LOGIC_VECTOR (15 jusqu'à 0)); composant final;

le composant Final_DFF est

Port (CLK: dans STD_LOGIC; D: dans STD_LOGIC_Vector (3 jusqu'à 0); Q: out STD_LOGIC_Vector (3 jusqu'à 0)); composant final;

signal DFF02proj30: STD_LOGIC;

signal DFF12proj74: STD_LOGIC; signal DFF22proj118: STD_LOGIC; signal DFF32proj1512: STD_LOGIC;

commencer

DFF0: Mappage des ports 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: mappage des ports final_project (NMS(0) => DFF02proj30, NMS(1) => DFF12proj74, NMS(2) => DFF22proj118, NMS(3) => DFF32proj1512, BTN => BTN, LED => LED); mettre fin au comportement;

Étape 7: Assemblage

L'assemblage du matériel pour ce projet est minime. Les seules pièces requises sont les suivantes:

1. Carte Basys 3 (1)

2. Détecteurs de mouvement bon marché que l'on peut trouver sur amazon ici. (4)

3. Fils mâle-femelle (4)

Assemblée:

1. Connectez 4 fils mâles aux ports JB de l'en-tête PMod 1-4 (voir la figure).

2. Connectez les extrémités femelles à la broche de sortie de chaque capteur de mouvement.

Étape 8: Chargement du programme

Nous sommes maintenant prêts à charger le fichier source principal VHDL sur la carte Basys 3. Assurez-vous d'exécuter la synthèse, la mise en œuvre et la génération de flux de bits en vérifiant les éventuelles erreurs. Si tout s'exécute avec succès, ouvrez le gestionnaire de matériel et programmez l'appareil Basys 3. Votre projet est maintenant terminé !