Generate PWM Signal From Spartan 3E

Let's get PWM Using Spartan 3E

Dans la meme série de tutoriels que j'ai fait au but de la découverte de technologie FPGA et en particulier la carte Spartan 3E, Aujourd'hui je vais vous montrer comment on fait pour generer un signal PWM (pulse widh modulation), vous expliquer les étapes de programmation que j'ai fait en passant par un test pratique démonstratif.

La modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM), est une technique couramment utilisée pour synthétiser des signaux continus à l'aide de circuits à fonctionnement tout ou rien, ou plus généralement à états discrets.

Le principe général est qu'en appliquant une succession d'états discrets pendant des durées bien choisies, on peut obtenir en moyenne sur une certaine durée n'importe quelle valeur intermédiaire.

Ce phénomène est fortement recommandé pour assurer la variation de vitesse de moteur a courant continu, aujourd'hui je vais vous démontrer comment on peut générer un signal PWM d'une carte FPGA Spartan 3E et visualiser son présence sur des diodes LEDs.

  

Passons maintenant au programmation; 

Voici le programme  du projet :

PWM Top Code :
----------------------------------------------------------------------------------
-- Company: There is no company  
-- Engineer: Aymen Lachkhem
-- 
-- Create Date:    02:27:11 03/27/2016 
-- Design Name: 
-- Module Name:    counter - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity top is
    Port ( 
    clk : in std_logic;
  pwm_out : out std_logic;
    rotary_a : in std_logic;
    rotary_b : in std_logic
);end top;

architecture Behavioral of top is
component pwm
 port(
  clk: in std_logic;
  pwm_var: in std_logic_vector(7 downto 0);
  pwm_out: out std_logic);
 end component;
 component rotary
 port(
  pwm_var : out std_logic_vector(7 downto 0);
      rotary_a : in std_logic;
      rotary_b : in std_logic;
      clk : in std_logic);
 end component;
signal pwm_var: std_logic_vector (7 downto 0);
begin
U1 : pwm
 port map(
  clk => clk,
  pwm_var=>pwm_var,
  pwm_out=>pwm_out
 );
U2 : rotary
 port map(
 pwm_var=>pwm_var,
   rotary_a=>rotary_a,
   rotary_b=>rotary_b,
   clk =>clk
 );
end Behavioral;

Pour les configurations physiques de mon programme avec la carte Spartan 3E j'ai choisis ces entrées sorties: 

NET "clk" PERIOD = 20.0ns HIGH 50%;

NET "clk" LOC = "C9" | IOSTANDARD = LVTTL;

NET "rotary_a"     LOC = "K18" | IOSTANDARD = LVTTL | PULLUP;

NET "rotary_b"     LOC = "G18" | IOSTANDARD = LVTTL | PULLUP;

NET "pwm_out" LOC = "D5" | IOSTANDARD = LVTTL | SLEW = SLOW | DRIVE = 6 ;

Le programme TOP il inclus deux component que j'ai écris en VHDL aussi :

PWM  Code :
----------------------------------------------------------------------------------
-- Company: There is no company  
-- Engineer: Aymen Lachkhem
-- 
-- Create Date:    02:27:00 03/27/2016 
-- Design Name: 
-- Module Name:    counter - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.numeric_std.all;

entity pwm is
port(
 clk: in std_logic;
 pwm_var: in std_logic_vector(7 downto 0);
 pwm_out: out std_logic
 
);
end pwm;
architecture Behavioral of pwm is
signal counter: std_logic_vector(7 downto 0):="00000000";
signal max_counter: std_logic_vector(7 downto 0):="11111111";
begin
process(clk)
begin
 if rising_edge(clk) then
  counter <= std_logic_vector( unsigned(counter) + 1 );  
  if counter=max_counter then
   counter<="00000000";
  else
   if counter<pwm_var then
    pwm_out<='1';
   else
    pwm_out<='0';
   end if;
  end if;
 end if;
end process;
end Behavioral;

Et

ROTARY ENCODER  Code :
----------------------------------------------------------------------------------
-- Company: There is no company  
-- Engineer: Aymen Lachkhem
-- 
-- Create Date:    02:24:42 03/27/2016 
-- Design Name: 
-- Module Name:    counter - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
-- 
----------------------------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity rotary is
    Port (         pwm_var : out std_logic_vector(7 downto 0);
                  rotary_a : in std_logic;
                  rotary_b : in std_logic;
                       clk : in std_logic
);end rotary;

architecture Behavioral of rotary is
signal      rotary_a_in : std_logic;
signal      rotary_b_in : std_logic;
signal        rotary_in : std_logic_vector(1 downto 0);
signal        rotary_q1 : std_logic;
signal        rotary_q2 : std_logic;
signal  delay_rotary_q1 : std_logic;
signal     rotary_event : std_logic;
signal      rotary_left : std_logic;

signal      led_pattern : std_logic_vector(7 downto 0):= "00000000";
begin

  rotary_filter: process(clk)
  begin
    if clk'event and clk='1' then
      rotary_a_in <= rotary_a;
      rotary_b_in <= rotary_b;
      rotary_in <= rotary_b_in & rotary_a_in;

      case rotary_in is

        when "00" => rotary_q1 <= '0';         
                     rotary_q2 <= rotary_q2;
 
        when "01" => rotary_q1 <= rotary_q1;
                     rotary_q2 <= '0';

        when "10" => rotary_q1 <= rotary_q1;
                     rotary_q2 <= '1';

        when "11" => rotary_q1 <= '1';
                     rotary_q2 <= rotary_q2; 

        when others => rotary_q1 <= rotary_q1; 
                       rotary_q2 <= rotary_q2; 
      end case;
    end if;
  end process rotary_filter;
  direction: process(clk)
  begin
    if clk'event and clk='1' then
      delay_rotary_q1 <= rotary_q1;
      if rotary_q1='1' and delay_rotary_q1='0' then
        rotary_event <= '1';
        rotary_left <= rotary_q2;
       else
        rotary_event <= '0';
        rotary_left <= rotary_left;
      end if;

    end if;
  end process direction;
  -- PWM control.
  led_display: process(clk)
  begin
    if clk'event and clk='1' then
      if rotary_event='1' then
        if rotary_left='1' then 
    led_pattern<=led_pattern+'1'; --INCREASE
         else
    led_pattern<=led_pattern-'1'; --DECREASE  
        end if;
      end if;
      pwm_var <= led_pattern; 
    end if;
  end process led_display;
end Behavioral;

Le reste c'est d’implémenter  le programme pour avoir ceci : 

Let's Discover FPGA !!

La technologie FPGA (Field-Programmable Gate Array) continue de gagner du terrain au domaine :  le marché mondial du FPGA devrait passer d'1,9 milliard de dollars en 2005 à 2,75 milliards d'ici 2010. Depuis leur invention par Xilinx en 1984, les FPGA sont partis d'un simple rôle d'« interfaçage d'appoint » pour arriver à véritablement remplacer les ASIC (circuits intégrés à application spécifique) et les processeurs personnalisés dans des applications de contrôle et de traitement de signaux.

Afin d'expliquer ce succès, cet article propose une introduction à la technologie FPGA et met en évidence quelques-uns des nombreux avantages que les FPGA sont aujourd'hui les seuls à offrir, introduire le lien direct entre FPGA et VHDL.

Les FPGA (Field Programmable Gate Arrays ou "réseaux logiques programmables") sont des composants entièrement reconfigurables ce qui permet de les reprogrammer à volonté afin d'accélérer notablement certaines phases de calculs.

L'avantage de ce genre de circuit est sa grande souplesse qui permet de les réutiliser à volonté dans des algorithmes différents en un temps très court.
Le progrès de ces technologies permet de faire des composants toujours plus rapides et à plus haute intégration, ce qui permet de programmer des applications importantes.
Les FPGA sont bien distincts des autres familles de circuits programmables tout en offrant le plus haut niveau d'intégration logique.
Les circuits FPGA sont constitués d'une matrice de blocs logiques programmables entourés de blocs d'entrée sortie programmable. L'ensemble est relié par un réseau d'interconnexions programmable. 
Il y a 4 principales catégories disponible commercialement:

• Tableau symétrique.

• En colonne.

• Mers de portes.

• Les PLD hiérarchique.

Voici la structure interne d'un FPGA de type matrice symétrique. Il s'agit de l'architecture que l'on retrouve dans les FPGA de la série XC4000 de chez Xilinx.

On programme aussi les interconnexions entre les cellules:

Anisi que les entrées et sorties du circuit. L'avantage des FPGA est de pouvoir être configuré sur place, sans envoi du circuit chez le fabricant, ce qui permet de les utiliser quelques minutes après leur conceptions. Les FPGA les plus récents sont configurables en une centaine de millisecondes. Les FPGA sont utilisés pour un développement rapide et bon marché des ASIC.

Les cinq principaux atouts de la technologie FPGA:

• Performances
• Temps de mise sur le marché
• Coût
• Fiabilité
• Maintenance à long terme

Passons au VHDL maintenant, en faite la définition générale de cette dernière va vous expliquez pourquoi on la utilise au programmation du FPGA.

VHDL est le sigle de VHSIC hardware description language ; VHSIC vient quant à lui de very-high-speed integrated circuits, une initiative de la Défense américaine dans les années 1980 visant la construction de circuits intégrés très rapides. Le VHDL est un langage de description du matériel utilisé en électronique. En tant que standard, il est indépendant du logiciel utilisé pour la compilation, la programmation des composants, la simulation, etc.Il autorise plusieurs méthodologies de conception (comportemental, flot de données, structurel) tout en étant d'un très haut niveau d'abstraction en électronique (il est indépendant de la technologie utilisée : FPGA, CPLD, ASIC, etc.). Cette abstraction permet d'ailleurs de le simuler sur ordinateur avant de programmer la moindre puce.Lors de sa conception, l'objectif n'était pas de produire un nouveau langage ex nihilo : la Défense avait récemment mis au point le langage Ada, il était préférable de partir sur ces bases et en exploiter autant que possible la syntaxe, en l'adaptant au contexte de l'électronique numérique.  

Il n'est pas le seul sur le marché : Verilog, par exemple, est également un langage très utilisé, possédant une syntaxe fort différente mais des fonctionnalités équivalentes, si ce n'est égales. VHDL semble plus utilisé en Europe. Une belle proportion des outils disponibles supportent indifféremment les deux.

Aujourd'hui je vais vous montrer comment initialer un tel projet en VHDL et le faire implanter sur une carte FPGA.

Le logiciel sur lequel on va écrire nos programme en VHDL est :

ISE WebPACK Design Software

Voici ce premier exemple du programme VHDL fait pas à pas sur ISE dans la vidéo si dessous:

Le programme que j'ai écrit si dessus est celui la :

-- Company: 
-- Engineer: Aymen Lachkhem 
-- Create Date:    19:06:52 03/21/2016 
-- Design Name: 
-- Module Name:    Logic_Gate_Code - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
-- Dependencies: 
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
---------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- Uncomment the following library declaration if using
-- arithmetic functions with Signed or Unsigned values
--use IEEE.NUMERIC_STD.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity Logic_Gate_Code is
    Port ( x : in  STD_LOGIC;
           y : in  STD_LOGIC;
           s : out  STD_LOGIC);
end Logic_Gate_Code;
architecture Behavioral of Logic_Gate_Code is
begin
s <= x AND y;
end Behavioral;

Ce logiciel nous offre l'utilité d'éviter d'écrire notre programme comme si dessous en mais de faire réaliser une programmation graphique " Schematic" , céci facilite la programmation il suffit de choisir les ports ou les circuits intégrées ou les portes logiques qu'on a besoin de le faire connecter pour avoir notre fonctionnement demandé.
Voila un exemple de ce que j'ai dis, dans la vidéo au dessous j'ai réalisé un projet sur ISE pas à pas mais au lieu d'écrire mot a mot mon programme j'ai juste fait intervenir le Schematic.