Filtre numÃ©rique du 1er ordre

samedi 19 juin 2010, par Steve

Introduction

La description qui suit permet de filtrer des Ã©chantillons en temps rÃ©el. Le filtre est implÃ©mentÃ© sous sa forme dit directe.

La synthÃ¨se du filtre (transformÃ©e bilinÃ©aire)

CommenÃ§ons par un peu de thÃ©orie afin de transformer un filtre continu vers un filtre discret.

La forme gÃ©nÃ©rale du filtre dans le domaine de Laplace est :

$H(s) = \frac{a \cdot \omega_{0} + b \cdot s}{c \cdot \omega_{0} + d \cdot s}$

En substituant par $\frac{2}{T_{e}} \cdot \frac{1-z^{-1}}{1 +z^{-1}}$ dans , on obtient :

$H(z) = {\frac{a \cdot \omega_{0} + b \cdot s}{c \cdot \omega_{0} + d \cdot s}}| s = \frac{2}{T_{e}} \cdot \frac{1-z^{-1}}{1+z^{-1}}$

$H(z) = {\frac{a \cdot \omega_{0} + b \cdot \frac{2}{T_{e}} \cdot \frac{1-z^{-1}}{1+z^{-1}}}{c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}} \cdot \frac{1-z^{-1}}{1+z^{-1}}}}$

$H(z) = {\frac{a \cdot \omega_{0} \cdot (1+z^{-1}) + b \cdot \frac{2}{T_{e}} \cdot (1-z^{-1})}{c \cdot \omega_{0} \cdot (1+z^{-1}) + d \cdot \frac{2}{T_{e}} \cdot (1-z^{-1})}}$

On obtient :

$H(z) = \frac{(a \cdot \omega_{0} + b \cdot \frac{2}{T_{e}}) + (a \cdot \omega_{0} - b \cdot \frac{2}{T_{e}})\cdot z^{-1}} {(c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}) + (c \cdot \omega_{0} - d \cdot \frac{2}{T_{e}})\cdot z^{-1}}$

Posons $H(z) = \frac{S(z)}{E(z)}$ :

$S(z) \cdot [(c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}) + (c \cdot \omega_{0} - d \cdot \frac{2}{T_{e}})\cdot z^{-1}] = E(z) \cdot [(a \cdot \omega_{0} + b \cdot \frac{2}{T_{e}}) + (a \cdot \omega_{0} - b \cdot \frac{2}{T_{e}})\cdot z^{-1}]$

$s[k] \cdot (c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}) + s[k-1] \cdot (c \cdot \omega_{0} - d \cdot \frac{2}{T_{e}}) = e[k] \cdot (a \cdot \omega_{0} + b \cdot \frac{2}{T_{e}}) + e[k-1] \cdot (a \cdot \omega_{0} - b \cdot \frac{2}{T_{e}})$

On obtient l’Ã©quation aux diffÃ©rences :

$s[k] = e[k] \cdot \frac{a \cdot \omega_{0} + b \cdot \frac{2}{T_{e}}}{c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}} + e[k-1] \cdot \frac{a \cdot \omega_{0} - b \cdot \frac{2}{T_{e}}}{c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}} - s[k-1] \cdot \frac{c \cdot \omega_{0} - d \cdot \frac{2}{T_{e}}}{c \cdot \omega_{0} + d \cdot \frac{2}{T_{e}}}$

Et finalement, l’Ã©quation aux diffÃ©rences qui sera implÃ©mentÃ©e dans la description VHDL :

$s[k] = \alpha \cdot e[k] + \beta \cdot e[k-1] - \gamma \cdot s[k-1]$

La description

L’implÃ©mentation se base sur trois multiplieur sÃ©rie et un additionneur sÃ©rie.
La description se dÃ©compose en quatre parties :
le multiplieur sÃ©rie,
l’additionneur sÃ©rie,
le registre Ã dÃ©calage de sortie et
le sÃ©quenceur.

Le multiplieur est sous une forme sÃ©quencÃ©e qui nÃ©cessite 37 coups d’horloge afin de produire le rÃ©sultat. Le signal ’start’ dÃ©marre le processus de multiplication. Le bus ’selector’ provient d’un compteur (qui est mutualisÃ© par plusieurs instances du multiplieur) et fournit un auxiliaire dans l’opÃ©ration de multiplication. ’a’ et ’b’ sont respectivement le multiplicande et le multiplicateur. Le produit se prÃ©sente sous la forme d’un flux sÃ©rie, idÃ©al pour alimenter un additionneur sÃ©rie.

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

entity serialMultiplier is
  port ( clr      : in  std_logic;
         clk      : in  std_logic;
         start    : in  std_logic;
         a        : in  std_logic_vector(17 downto 0);
         b        : in  std_logic_vector(17 downto 0);
         selector : in  std_logic_vector(5 downto 0);
         complete : out std_logic;
         r        : out std_logic);
  end serialMultiplier;

architecture Behavioral of serialMultiplier is

  signal internal     : std_logic_vector(17 downto 0);
  signal intermediary : std_logic_vector(18 downto 0);
  signal bitResult    : std_logic_vector(17 downto 0);
  signal multiplier   : std_logic;

  begin
    process (clr, clk)
    begin
      if (clr = '1') then
        internal <= (others => '0');
        complete <= '0';
        r <= '0';
      elsif (rising_edge(clk)) then
        if (start = '0') then
          internal <= (others => '0');
          complete <= '0';
          r <= '0';
        elsif ((selector /= "100100") and (selector /= "100101"))then
          internal <= intermediary(18 downto 1);
          r <= intermediary(0);          
        elsif (selector = "100100") then
          r <= intermediary(0);          
          complete <= '1';
        end if;
      end if;
    end process;
    bitResult <= a when (multiplier = '1') else
                 (others => '0');
    multiplier <= b(0)  when (selector = "000000") else
                  b(1)  when (selector = "000001") else
                  b(2)  when (selector = "000010") else
                  b(3)  when (selector = "000011") else
                  b(4)  when (selector = "000100") else
                  b(5)  when (selector = "000101") else
                  b(6)  when (selector = "000110") else
                  b(7)  when (selector = "000111") else
                  b(8)  when (selector = "001000") else
                  b(9)  when (selector = "001001") else
                  b(10) when (selector = "001010") else
                  b(11) when (selector = "001011") else
                  b(12) when (selector = "001100") else
                  b(13) when (selector = "001101") else
                  b(14) when (selector = "001110") else
                  b(15) when (selector = "001111") else
                  b(16) when (selector = "010000") else
                  b(17) when (selector = "010001") else
                  '0';
    intermediary <= ('0' & internal) + ('0' & bitResult);
  end Behavioral;

L’additionneur sÃ©rie prÃ©sentÃ© ici est basÃ© sur un additionneur complet avec une rÃ©troaction des retenues. Il additionne trois termes correspondant aux produits des multiplieurs dÃ©crits ci-dessus. La somme se prÃ©sente sous un flux sÃ©rie.

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

entity serialAdder is
  port ( clr  : in  STD_LOGIC;
         clk  : in  STD_LOGIC;
         sclr : in  STD_LOGIC;
         ce   : in  STD_LOGIC;
         a    : in  STD_LOGIC;
         b    : in  STD_LOGIC;
         c    : in  STD_LOGIC;
         r    : out STD_LOGIC);
  end serialAdder;

architecture Behavioral of serialAdder is

  signal ea   : std_logic_vector(2 downto 0);
  signal eb   : std_logic_vector(2 downto 0);
  signal ec   : std_logic_vector(2 downto 0);
  signal eci  : std_logic_vector(2 downto 0);
  signal ci   : std_logic_vector(1 downto 0);
  signal co   : std_logic_vector(1 downto 0);
  signal temp : std_logic_vector(2 downto 0);

  begin
    ea <= "00" & a;
    eb <= "00" & b;
    ec <= "00" & c;
    eci <= "0" & ci;
    temp <= ea + eb + ec + eci;
    r <= temp(0);
    co <= temp(2 downto 1);
    process (clr, clk)
    begin
      if (clr = '1') then
        ci <= (others => '0');
      elsif (rising_edge(clk)) then
        if (sclr = '1') then
          ci <= (others => '0');
        elsif (ce = '1') then
          ci <= co;
        end if;
      end if;
    end process;
  end Behavioral;

library ieee;
use ieee.std_logic_1164.all;

entity outputShifter is
  port ( clr     : in  std_logic;
         clk     : in  std_logic;
         shift   : in  std_logic;
         indata  : in  std_logic;
         outdata : out std_logic_vector(19 downto 0));
end outputShifter;

architecture behavioral of outputShifter is

  signal internal : std_logic_vector(outdata'range);

  begin
    process (clr, clk)
    begin
      if (clr = '1') then
        internal <= (others => '0');
      elsif (rising_edge(clk)) then
        if (shift = '1') then
            internal <= indata & internal(19 downto 1);
        end if;
      end if;
    end process;
    outdata <= internal;
  end behavioral;

Filtre numÃ©rique du 1er ordre

Introduction

La synthÃ¨se du filtre (transformÃ©e bilinÃ©aire)

La description

Le multiplieur sÃ©rie

L’additionneur sÃ©rie

Le registre Ã dÃ©calage de sortie

Le sÃ©quenceur du filtre

Le filtre

Un message, un commentaire ?

Electronique

Dans la même rubrique