LED dimmable à l'aide de la carte Basys 3: 5 étapes

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

Dans ce guide, nous allons construire et contrôler un système de gradation LED externe. Avec les boutons disponibles, l'utilisateur peut tamiser l'ampoule LED à n'importe quelle luminosité souhaitée. Le système utilise la carte Basys 3 et il est connecté à une maquette qui contient une résistance et l'ampoule LED. Appuyez sur le bouton "haut" désigné pour augmenter la luminosité et appuyez sur le bouton "bas" pour diminuer la luminosité jusqu'à zéro. Non seulement cela évite à l'utilisateur d'être aveuglé par des ampoules lumineuses comme le soleil, mais cela permet également d'économiser de l'énergie !

Étape 1: Créer un compteur d'entrée

Pour cette étape, nous créons le composant qui détermine le niveau de luminosité (via une horloge) en utilisant deux commutateurs: un pour augmenter et un pour diminuer. En utilisant VHDL, nous avons produit le compteur à l'aide de bascules D. En appuyant sur le bouton « haut », l'état suivant passe à l'état actuel, en émettant vers l'affichage à sept segments et l'ampoule LED.

l'entité updown_counter est

Port (present_state: out STD_LOGIC_VECTOR (3 jusqu'à 0); previous_state: dans STD_LOGIC_VECTOR (3 jusqu'à 0); next_state: dans STD_LOGIC_VECTOR (3 jusqu'à 0); clk: dans STD_LOGIC; down_enable: dans STD_LOGIC; up_enable: dans STD_LOGIC); fin updown_counter; architecture Le comportement de updown_counter est 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 <= état_suivant; elsif (down_enable = '1' et non(previous_state= "1111")) then present_state <= previous_state; fin si; fin si; flop de processus de fin; mettre fin au comportement;

Nous avons également besoin d'une horloge pour que chaque entrée soit verrouillée (lorsqu'elle augmente), nous avons donc également créé un diviseur d'horloge qui détermine la vitesse à laquelle les boutons peuvent être enfoncés entre chaque niveau de luminosité. Ce diviseur d'horloge nous permet d'afficher correctement le bon niveau sur l'affichage à sept segments et de produire le bon niveau d'intensité pour chaque niveau.

l'entité counter_clkDiv est

Port (clk: in std_logic; sclk: out std_logic); fin counter_clkDiv; l'architecture my_clk_div de counter_clkDiv est constante max_count: entier:= (10000000); 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;

Étape 2: Créer un diviseur d'horloge à LED

Pour cette étape, nous créons un diviseur d'horloge pour l'ampoule LED afin de déterminer 16 niveaux d'intensité différents. Avec 0 étant éteint à 15 affichant la luminosité maximale, le diviseur d'horloge incrémente chaque pression de bouton par ce que nous avons défini comme étant les niveaux de luminosité. Chaque niveau croissant signifiait une augmentation de l'horloge pour l'ampoule LED. En nous souvenant que la luminosité n'augmente pas de manière linéaire, nous avons poussé l'horloge au maximum et diminué nos horloges en conséquence.

Remarque: nous utilisons une LED bleue. L'utilisation d'une couleur différente (comme le rouge) nécessitera des horloges légèrement différentes; un réglage de luminosité moyenne pour le bleu pourrait déjà être une luminosité maximale pour le rouge. Cela se produit parce que différentes longueurs d'onde de lumière nécessiteront différentes quantités d'énergie, les couleurs plus froides comme le violet et le bleu nécessitant plus d'énergie, tandis que les couleurs plus chaudes comme le rouge et l'orange nécessitent moins d'énergie.

l'entité led_clkDiv est Port (present_state: dans STD_LOGIC_VECTOR (3 jusqu'à 0); clk: dans STD_LOGIC; led_clk: out STD_LOGIC); fin led_clkDiv; architecture Le comportement de led_clkDiv est le signal tmp_clk: std_logic:= '0'; variable partagée max_count: entier;begin count_stuff: processus (present_state) begin case present_state est quand "0000" => max_count:= 0; quand "0001" => max_count:= 2; quand "0010" => max_count:= 4; quand "0011" => max_count:= 6; quand "0100" => max_count:= 8; quand "0101" => max_count:= 10; quand "0110" => max_count:= 12; quand "0111" => max_count:= 14; quand "1000" => max_count:= 16; quand "1001" => max_count:= 25; quand "1010" => max_count:= 50; quand "1011" => max_count:= 100; quand "1100" => max_count:= 150; quand "1101" => max_count:= 200; quand "1110" => max_count:= 250; quand "1111" => max_count:= 300; cas d'extrémité; fin du processus count_stuff; my_div: processus (clk, tmp_clk, present_state) 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; led_clk <= tmp_clk; fin du processus my_div; mettre fin au comportement;

Étape 3: Création du contrôleur LED

Maintenant que nous sommes arrivés jusqu'ici, il est temps de combiner enfin tous les composants que nous avons créés jusqu'à présent dans le fichier LED Controller.

Pour résumer, les composants utilisés sont les suivants:

• Compteur d'entrée (updown_counter)
• Diviseur d'horloge (counter_clkDiv)
• Diviseur d'horloge LED (led_clkDiv)
• Pilote d'affichage à sept segments (sseg_dec) (fichier joint)

Le pilote d'affichage à sept segments n'a pas été discuté auparavant car nous avons en fait emprunté le fichier VHDL du Dr Bryan Mealy en raison de son code long et compliqué. Ce qu'il fait essentiellement, c'est diriger nos entrées de bouton vers l'affichage à sept segments de la carte Basys 3 afin que nous sachions quel niveau de luminosité est activé.

À l'avenir, le contrôleur LED utilise des bascules pour augmenter ou diminuer le nombre qui contrôle simultanément l'affichage à sept segments et le niveau de luminosité de l'ampoule LED.

le compteur d'entités est Port (clk: dans STD_LOGIC; up_enable: dans STD_LOGIC; down_enable: dans STD_LOGIC; SEGMENTS: out STD_LOGIC_VECTOR (7 jusqu'à 0); DISP_EN: out STD_LOGIC_VECTOR (3 jusqu'à 0); led_clk: out STD_LOGIC); compteur de fin; architecture Comportement du compteur est le composant updown_counter est Port (present_state: out STD_LOGIC_VECTOR (3 down to 0); previous_state: in STD_LOGIC_VECTOR (3 down to 0); next_state: in STD_LOGIC_VECTOR (3 down to 0); clk: in STD_LOGIC; down_enable: in STD_LOGIC; up_enable: dans STD_LOGIC); composant de fin updown_counter; le composant counter_clkDiv est Port (clk: in std_logic; sclk: out std_logic); composant de fin counter_clkDiv; le composant sseg_dec est Port (ALU_VAL: dans std_logic_vector (7 jusqu'à 0); SIGN: dans std_logic; VALID: dans std_logic; CLK: dans std_logic; DISP_EN: out std_logic_vector (3 jusqu'à 0); SEGMENTS: out std_logic_vector (7 jusqu'à 0)); composant de fin sseg_dec; le composant led_clkDiv est Port (present_state: dans STD_LOGIC_VECTOR (3 jusqu'à 0); clk: dans STD_LOGIC; led_clk: out STD_LOGIC); composant de fin led_clkDiv; signal present_state: STD_LOGIC_VECTOR (3 jusqu'à 0):= "0000"; signal next_state: STD_LOGIC_VECTOR (3 jusqu'à 0):= "0000"; signal previous_state: STD_LOGIC_VECTOR (3 jusqu'à 0):= "0000"; signal Alu_Val: STD_LOGIC_VECTOR (7 jusqu'à 0); signal sclk: STD_LOGIC; commencer Alu_Val(7 jusqu'à 4) <= "0000"; Alu_Val (3 jusqu'à 0) <= present_state; état_suivant(0) <= pas(état_présent(0)); next_state(1) <= present_state(0) xor present_state(1); next_state(2) <= (present_state(0) et present_state(1)) xor present_state(2); next_state(3) <= (present_state(0) et present_state(1) et present_state(2)) xor present_state(3); état_précédent(0) <= pas(état_présent(0)); previous_state(1) <= present_state(0) xnor present_state(1); previous_state(2) <= (present_state(0) ni 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); affichage: sseg_dec port map(ALU_VAL => Alu_Val, SIGN => '0', VALID => '1', CLK => clk, DISP_EN => DISP_EN, SEGMENTS => SEGMENTS); led_div: mappage des ports led_clkDiv (clk => clk, present_state => present_state, led_clk => led_clk); clk_div: mappage des ports counter_clkDiv (clk => clk, sclk => sclk); mettre fin au comportement;

Étape 4: Établir les contraintes et l'assemblage

Contraintes

Pour configurer et programmer correctement la carte Basys 3, nous devons d'abord configurer notre fichier de contraintes qui est joint à cette étape. Les paramètres suivants ont été ajustés:

Boutons

• T18 modifié en "up_enable" (augmenter la luminosité)
• U17 changé en "down_enable" (diminuer la luminosité)

Affichage 7 segments

• W7, W6, U8, V8, U5, V5, U7, V7 représentent chaque segment d'un affichage
• U2, U4, V4, W4 représentent chaque anode affichée (seulement 2 sont actives car notre nombre le plus élevé est 15)

En-tête PMOD JC

JC7 est l'endroit où nous connectons l'un des fils de l'ampoule LED et l'autre fil mène à la TERRE

Après avoir configuré tout cela, tout ce que vous avez à faire est de générer votre bitstream (avec n'importe quel logiciel que vous utilisez, par exemple Vivado), de programmer votre carte et hop ! Vous vous êtes procuré une planche de travail.

Remarque: le mappage des broches peut être trouvé sur la fiche technique Basys 3 ici.

Assemblée

Étape 5: Utilisation de votre gradateur

Si tout se passe bien, vous devriez avoir un système de gradation entièrement fonctionnel. Pour résumer, appuyer sur le bouton du haut augmentera votre luminosité (jusqu'à 15), et appuyer sur le bouton du bas diminuera votre luminosité (jusqu'à 0). J'espère que tout se passe bien pour votre vue désormais détendue !