Progr. Logik - 5

Wenn mit Xilinx ISE ein neues Projekt oder Source-File angelegt wird, fragt der Wizzard nach EA und Bitbreiten. Nach einem Klick auf "DONE" wird dann ein neues Sourcefile angelegt, in dem aber ein riesiger Header und die alten Synopsys-Libs eingebunden sind:

--------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    11:21:38 01/04/2010 
-- Design Name: 
-- Module Name:    Defaulttext - 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;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity Defaulttext is
    Port ( clk : in  STD_LOGIC;
           d : in  STD_LOGIC;
           o : out  STD_LOGIC);
end Defaulttext;

architecture Behavioral of Defaulttext is

begin


end Behavioral;

Das musste ich geändert haben:
Ich will als Standard-Lib die NUMERIC_STD einbinden, die UNISIM soll raus, und der Header etwas verschlankt werden.

ISE Version 13
Hier müssen dazu die beiden TCL-Scripte
C:\Xilinx\ISE_DS\ISE\data\projnav\scripts\dpm_sourceTasks.tcl
C:\Xilinx\ISE_DS\ISE\data\testbnch2.tcl
angepasst werden.

Im Script dpm_sourceTasks.tcl wird die Erzeugung eines neuen VHDL-Sourcecodemodul gesteuert. Hier muss die Prozedur proc dpm_sourceCreateVHDL geändert werden. Hier hat sich im Gegensatz zu früheren Versionen (siehe Beschreibung unten) das $_fs in ein $hFile geändert.

Im testbnch2.tcl wird die Generierung der Testbench gesteuert. Hier hat sich einiges getan, und ich musste erst mal die automatische Reset-Suche pensionieren. Auch die Taktgenerierung hat mir nicht gefallen, so dass sich da ebenso einiges geändert hat.

Damit die Suche nicht so schwer fällt, gibt es hier meine beiden Templates zum Download: IseTemplates.zip



ISE Versionen 9 bis 11
Etwa in der Mitte dieses TCL-Scripts  
C:\Xilinx\data\projnav\scripts\dpm_sourceTasks.tcl
findet sich die Stelle, die angepasst werden muss:

      $_iHdlData GetPorts _portIter
      puts $_fs "----------------------------------------------------------"
      puts $_fs "-- Engineer: Lothar Miller"
      puts $_fs "-- "
      puts $_fs "-- Create Date:    $_ts "
      puts $_fs "-- Design Name: "
      puts $_fs "-- Module Name:    $_entityName - $_archName "
      puts $_fs "----------------------------------------------------------"
      puts $_fs "library IEEE;"
      puts $_fs "use IEEE.STD_LOGIC_1164.ALL;"
      puts $_fs "use IEEE.NUMERIC_STD.ALL;"
      puts $_fs ""

Nach der Änderung dieser Datei kommt beim Erzeugen eines neuen Projekts/Sourcefiles der gewünschte Customer-Header.

--------------------------------------------------------
-- Engineer: Lothar Miller
-- 
-- Create Date:    11:21:38 01/04/2010 
-- Design Name: 
-- Module Name:    Defaulttext - Behavioral 
--------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Defaulttext is
    Port ( clk : in  STD_LOGIC;
           d : in  STD_LOGIC;
           o : out  STD_LOGIC);
end Defaulttext;

architecture Behavioral of Defaulttext is

begin


end Behavioral;

Für die Voreinstellungen beim Erstellen der Testbench werden die Scriptdateien

C:\Xilinx\ISE_DS\ISE\data\testbnch2.tcl

und

C:\Xilinx\ISE_DS\ISE\data\testbnch2.tft

verwendet.

Ein DCF-Signal besteht aus Impulsfolgen, die pro Sekunde mit unterschiedlich langen High-Pegeln eine 0 (=100ms high) bzw. eine 1 (=200ms high) codieren. Die 59. Sekunde wird zur Synchronisation verwendet und wird mit low-Pegel ausgegeben. Die steigende Flanke nach der 58. skeunde ist daher dann die Sekunde 0.

Die Auswertung des DCF-Signals wird also von einem Zähler übernommen, der mit einer steigenden Flanke zurückgesetzt wird. Bei einer fallenden Flanke wird dann entsprechend dem Zählerstand eine '0' (<150ms) oder eine '1' (>150ms) übernommen.
Alternativ kann auch beim Zählerstand 150ms einfach der Pegel des DCF-Signals eingelesen werden.

Erreicht der Zähler einen Wert größer 1 Sekunde, war das die 59. Sekunde. Bei der der nächsten steigenden Flanke des DCF-Signals werden dann die eingelesenen Bits zur weiteren Verarbeitung über ein Pufferregister bereitgestellt.

In dem folgenden Code sollte vor der Synthese eine der beiden Varianten (beide funktionieren gleich gut) der Bit-Auswertung auskommentiert werden

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity DCF77 is
    Generic( fclk : integer := 50000000 ); -- 50MHz
    Port   ( clk       : in  std_logic; 
             dcf       : in  std_logic;
             dcf_sec0  : out std_logic;
             bitsout   : out std_logic_vector (58 downto 0) );
end DCF77;

architecture Behavioral of DCF77 is
constant cntmax    : integer := (11*fclk)/10;        -- 1.1 sec
constant cntsample : integer := (15*fclk)/100;       -- 150 ms
signal cnt         : integer range 0 to cntmax := 0; -- Zähler bis 1.1 sec
signal dcfsr       : std_logic_vector(2 downto 0);
signal bits        : std_logic_vector(58 downto 0):= (others=>'0');
begin
   process begin
      wait until rising_edge(clk);
      -- Einsynchronisieren
      dcfsr <= dcfsr(1 downto 0) & dcf;
   
      -- erst Zaehler hochzählen (sättigend bei 1.1 sec)
      if (cnt < cntmax) then 
         cnt <= cnt+1; 
      end if;
      
      -- steigende Flanke vom DCF-Signal
      dcf_sec0 <= '0';             -- für 1 Taktzyklus bei Sekunde 0 aktiv
      if (dcfsr(2 downto 1)="01") then 
         if (cnt = cntmax) then    -- Überlauf? ja: Sekunde 59 war da
            dcf_sec0 <= '1';       -- Sekunde 0 anzeigen
            bitsout <= bits;       -- die gesammelten Daten übergeben
            bits <= (others=>'0'); -- Bit-Schiebegregister zuruecksetzen
         end if;
         cnt <= 0;
      end if;
   
      -- Variante 1: einlesen bei fallender Flanke vom DCF-Signal
      if (dcfsr(2 downto 1)="10") then 
         if (cnt < cntsample) then           -- kurzer Impuls? Grenze 150ms
            bits <= '0' & bits(58 downto 1); -- ja: 0 von links einschieben
         else
            bits <= '1' & bits(58 downto 1); -- nein: 1 von links einschieben
         end if;      
      end if;
      -- --> Ressourcenverbrauch    
      -- Number of Slices       88
      -- Number of Slice FFs    137
      -- Number of 4 input LUTs 104
      
      -- Variante 2: bei Zeitpunkt "150ms" einlesen   
      if (cnt = cntsample) then             -- DCF-Signal einlesen bei 150ms
          bits <= dcfsr(2) & bits(58 downto 1); 
      end if;
      -- --> Ressourcenverbrauch
      -- Number of Slices       87
      -- Number of Slice FFs    137
      -- Number of 4 input LUTs 103

   end process;
end Behavioral;

Zusammen mit der Testbench unten ergeben sich folgende Waveforms:

Überblick

Detail mit Sekunde 59 und darauffolgender Datenübergabe

Hier der DCF77-Decoder incl. Testbench zum Download: DCF77.zip

Mit diesem Decoder werden nur die rohen Daten bereitgestellt. In dem Modul darüber muß dann noch die gesamte Plausibilitätskontrolle (Parity), die Validierung und die weitere Verwaltung der empfangenen Daten realisiert werden.

Sollen Zahlen z.B. an ein Display oder über eine serielle Schnittstelle ausgegeben werden, dann ist es naheliegend, sie zuerst in ein BCD-Format und anschliessend in ASCII umzuwandeln. Das geht ganz einfach: zu jeder der 4-Bit Gruppen der BCD-Zahl wird der ASCII-Wert '0' dazuaddiert. Fertig.
Durch die dafür nötige Hin- und Zurückkonvertiererei wird das aber recht sperrig. Man kann die Sache vereinfachen, wenn man sich die ASCII-Tabelle ansieht und feststellt, dass die relevanten ASCII-Werte einfach für den Wert bei x"30" beginnen und mit dem Wert 9 bei x"39" aufhören. Man muss also nur die x"3" vor die 4-Bit Binärzahl bringen und fertig ist der ASCII Wert.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity BCD2ASCII is
    Port ( di : in  STD_LOGIC_VECTOR (3 downto 0);
           do : out STD_LOGIC_VECTOR (7 downto 0));
end BCD2ASCII;

-- Entweder die ASCII-'0' dazuaddieren ...
architecture Behavioral of BCD2ASCII is
begin
     do <= std_logic_vector(to_unsigned(character'pos('0')+to_integer(unsigned(di)),8));
end Behavioral;

-- ... oder einfach den Wert "0011" anhängen.
architecture Behavioral of BCD2ASCII is
begin
     do <= x"3" & di;
end Behavioral;

Zur Eingabe von Daten bietet sich eine PS/2 Tastatur an. Die Dinger gibts für ein paar Euros und das Protokoll ist in der einfachsten Variante sehr überschaubar.

Ich habe hier mehrere Implementationen: die Erste ist sehr einfach gehalten und gibt alle empfangenen Scancodes incl. Break und Extended Keycodes einfach mit einem Handshake weiter an ein übergeordnetes Modul:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity PS2_Keyboard is
    Port ( PS2_Data    : in  std_logic;
           PS2_Clk     : in  std_logic;
           RxData      : out std_logic_vector(7 downto 0);
           RxActive    : out std_logic;
           DataReady   : out std_logic; -- Handshake-Signal: Daten bereit
           DataFetched : in  std_logic; -- Handshake-signal: Daten übernommen
           CLK         : in  std_logic);
end PS2_Keyboard;

architecture Behavioral of PS2_Keyboard is
signal RxTimeout   : integer range 0 to 500000 := 0; -- max. 10ms
signal RxRegister  : std_logic_vector(10 downto 0) := (others=>'1');
signal DataSR      : std_logic_vector(1 downto 0)  := (others=>'1');
signal ClkSR       : std_logic_vector(1 downto 0)  := (others=>'1');
type PS2RXStateType is (IDLE, RECEIVE, READY); 
signal PS2RXState : PS2RXStateType := IDLE;

begin
   process begin
      wait until rising_edge(CLK);
      RxTimeout <= RxTimeout+1;
      
      DataSR    <= DataSR(0) & PS2_Data;
      ClkSR     <= ClkSR(0)  & PS2_Clk;
      
      if (ClkSR = "10") then -- fallende Flanke am PS2_CLK
         RxRegister <= DataSR(1) & RxRegister(10 downto 1);
      end if;

      case PS2RXState is
      when IDLE =>
         RxRegister <= (others=>'1');
         RxActive   <= '0';
         DataReady  <= '0';
         RxTimeout  <= 0;
         if (DataSR(1) = '0' and ClkSR(1) = '1') then -- STARTBIT erkannt
            PS2RXState <= RECEIVE;
            RxActive   <= '1';       
         end if;
      when RECEIVE =>
         if (RxTimeout = 500000) then     -- 10 ms
            PS2RXState <= IDLE;
         elsif (RxRegister(0) = '0') then -- Startbit ganz durchgeschoben?
            DataReady  <= '1';            -- SCANCODE empfangen
            RxData     <= RxRegister(8 downto 1);
            PS2RXState <= READY;
         end if;
      when READY =>                       -- warten, bis Daten abgeholt sind
         if (DataFetched='1') then
            PS2RXState <= IDLE;
            DataReady  <= '0';
            RxActive   <= '0';            
         end if;
      end case;
   end process;
end Behavioral;

Realisiert wurde dieses PS/2 Interface in Form eines 11 Bit breiten Schieberegisters, das zu Beginn im Zustand IDLE mit '1'en vorbelegt wird. Mit jeder fallenden Flanke am PS2-Clk wird dieses Schieberegister um 1 Bit von links her weitergeschoben. In das MSB wird dabei der Zustand des einsynchronisierten PS2-Data Pins eingetragen.
Nachdem ein Startbit erkannt wurde, wechselt der Zustand auf RECEIVE und es werden solange Bits eingeschoben, bis das Startbit das rechte Ende (Bit0) des Schieberegisters erreicht hat. Dann werden die Daten in das Pufferregister übernommen und im Zustand READY gewartet, bis die Daten abgeholt sind.

Zusammen mit dieser Testbench:

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
 
ENTITY PS2_tb IS
END PS2_tb;
 
ARCHITECTURE behavior OF PS2_tb IS 
 
   procedure PS2Send( signal din :  in std_logic_vector(7 downto 0); 
                      signal ps2c : OUT std_logic;
                      signal ps2d : OUT std_logic) is
   variable parity : std_logic := '1';
   begin
      wait for 1 ns;
      ps2c  <= '1';
      ps2d  <= '1';
      wait for 5us;
      ps2d  <= '0';  -- startbit
      wait for 20us;
      ps2c  <= '0';
      wait for 40us;
      ps2c  <= '1';
      wait for 20us;
      
      parity := '1';
      for i in 0 to 7 loop
         ps2d <= din(i);
         if(din(i)='1') then 
            parity := not parity; 
         end if;
         wait for 20us;
         ps2c  <= '0';
         wait for 40us;
         ps2c  <= '1';
         wait for 20us;
      end loop;
      
      ps2d <= parity;  -- parity
      wait for 20us;
      ps2c  <= '0';
      wait for 40us;
      ps2c  <= '1';
      wait for 20us;
   
      ps2d <= '1';     -- stopbit
      wait for 20us;
      ps2c  <= '0';
      wait for 40us;
      ps2c  <= '1';
      wait for 20us;
   end procedure;
   
    -- Component Declaration for the Unit Under Test (UUT)
    COMPONENT PS2_Keyboard
    PORT(
         PS2_Data : IN  std_logic;
         PS2_Clk : IN  std_logic;
         RxData : OUT  std_logic_vector(7 downto 0);
         RxActive : OUT  std_logic;
         DataReady : OUT  std_logic;
         DataFetched : IN  std_logic;
         CLK : IN  std_logic
        );
    END COMPONENT;
    
   signal TxData : std_logic_vector(7 downto 0);

   --Inputs
   signal PS2_Data : std_logic := '1';
   signal PS2_Clk : std_logic := '1';
   signal DataFetched : std_logic := '0';
   signal CLK : std_logic := '0';

    --Outputs
   signal RxData : std_logic_vector(7 downto 0);
   signal RxActive : std_logic;
   signal DataReady : std_logic;

   -- Clock period definitions
   constant CLK_period : time := 20 ns; -- 50MHz
 
BEGIN
 
   -- Instantiate the Unit Under Test (UUT)
   uut: PS2_Keyboard PORT MAP (
          PS2_Data => PS2_Data,
          PS2_Clk => PS2_Clk,
          RxData => RxData,
          RxActive => RxActive,
          DataReady => DataReady,
          DataFetched => DataFetched,
          CLK => CLK
        );

   -- Clock process definitions
   CLK <= not CLK after CLK_period/2;

   -- Stimulus process
   DataFetched <= DataReady after 10 us; -- fake handshake
   
   stim_proc: process
   begin      
      -- hold reset state for 100 ns.
      wait for 100 ns;   
      
      TXData<=x"AA";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   

      TXData<=x"55";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   

      TXData<=x"11";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   

      TXData<=x"80";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   

      TXData<=x"01";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   

      TXData<=x"C3";
      PS2Send(TXData,PS2_Clk,PS2_Data);
      wait for 100 us;   
      
      wait;
   end process;
END;

ergibt sich dann folgende Waveform:

Waveform Simulation PS2 Interface

Hier die zusammengepackte Quelldatei und die passende Testbench:
Download PS2_Simplest.zip

In der zweiten Variante werden die Steuerkommandos (Break und Extended Keycode) in Flags umgewandelt:
Download PS2_Simple.zip

Die dritte Variante schliesslich erlaubt auch das Senden von Kommandos an die Tastatur. Damit können dann z.B. die LEDs auf der Tastatur an- und ausgeschaltet werden.
Download PS2_Full.zip

Eine Wurzel zu ziehen kann recht aufwendig sein. Erschwert wird das Ganze, wenn es in VHDL geschehen soll. Hier eine Gegenüberstellung des Ressourcenverbrauchs einer rein kombinatorischen Lösung verglichen mit einer sequentiellen getakteten Variante in einem Xilinx Spartan3 XC3S200 FPGA.

Hier als Bezugspunkt die parallel implementierte kombinatorische Lösung:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity SQRT is
    Generic ( b  : natural range 4 to 32 := 16 ); -- Breite 
    Port ( value  : in   STD_LOGIC_VECTOR (15 downto 0);
           result : out  STD_LOGIC_VECTOR (7 downto 0));
end SQRT;

architecture Behave of SQRT is
begin
   process (value)
   variable vop  : unsigned(b-1 downto 0);  
   variable vres : unsigned(b-1 downto 0);  
   variable vone : unsigned(b-1 downto 0);  
   begin
      vone := to_unsigned(2**(b-2),b);
      vop  := unsigned(value);
      vres := (others=>'0'); 
      while (vone /= 0) loop
         if (vop >= vres+vone) then
            vop   := vop - (vres+vone);
            vres  := vres/2 + vone;
         else
            vres  := vres/2;
         end if;
         vone := vone/4;
      end loop;
      result <= std_logic_vector(vres(result'range));
   end process;
end;

Mit diesem Ansatz ergibt sich folgender Ressourcenbedarf:

So eine Wurzel braucht schon Platz...

Und jetzt zum Vergleich die Variante mit der getakteten Berechnung der Wurzel:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity SQRT is
    Generic ( b  : natural range 4 to 32 := 16 ); -- Breite 
    Port ( clk    : in   STD_LOGIC;
           start  : in   STD_LOGIC;
           value  : in   STD_LOGIC_VECTOR (15 downto 0);
           result : out  STD_LOGIC_VECTOR (7 downto 0);
           busy   : out  STD_LOGIC);
end SQRT;

architecture Behave of SQRT is
signal op  : unsigned(b-1 downto 0); -- 
signal res : unsigned(b-1 downto 0); -- 
signal one : unsigned(b-1 downto 0); -- 

signal bits : integer range b downto 0;
type zustaende is (idle, shift, calc, done);
signal z : zustaende;

begin
   process begin
      wait until rising_edge(clk);
      case z is 
         when idle => 
            if (start='1') then 
               z <= shift; 
               busy <= '1';
            end if;
            one <= to_unsigned(2**(b-2),b);
            op  <= unsigned(value);
            res <= (others=>'0');

         when shift =>
            if (one > op) then
               one <= one/4;
            else
               z   <= calc;
            end if;

         when calc =>
            if (one /= 0) then
               if (op >= res+one) then
                  op   <= op - (res+one);
                  res  <= res/2 + one;
               else
                  res  <= res/2;
               end if;
               one <= one/4;
            else
               z    <= done;
            end if;
            
         when done =>
            busy <= '0';
            -- Handshake: wenn nötig warten, bis start='0'
            if (start='0') then 
               z <= idle; 
            end if;
      end case;
   end process;
   
   result <= std_logic_vector(res(result'range));
end;

Das Design Summary zeigt jetzt einen deutlich kleineren Ressourcenverbrauch an, wobei der Verbrauch an Slices insgesamt nicht mal so sehr viel höher ist:

... aber es geht auch wesentlich kompakter

Die Wurzelberechnung basiert auf diesem C Code von Jack W. Crenshaw:

int sqrt(int num) {
    int op = num;
    int res = 0;
    int one = 1 << 30; // The second-to-top bit is set: 1L<<30 for long

    // "one" starts at the highest power of four <= the argument.
    while (one > op)
        one >>= 2;
   
    while (one != 0) {
        if (op >= res + one) {
            op -= res + one;
            res += 2 * one;
        }
        res >>= 1;
        one >>= 2;
    }
    return res;
}