Home Aufgabenstellung Pflichtenheft Implementierung Spezifikation Dokumentation

Dokumentation

Umsetzung in VHDL

Schnittstellen:

Die Schnittstellenbeschreibung in VHDL sieht folgendermaßen aus:

entity converter is	   
	port (
	Reset       	: in STD_LOGIC;                		 	  -- Asynchroner Reset
	FSYNC       	: in STD_LOGIC;                			  -- Worttakt
	SCLK	    	: in STD_LOGIC;			                  -- Bittakt
	MONO        	: in STD_LOGIC_VECTOR(0 to 15);           	  -- 16 Bit Mono Signal
	READY       	: in STD_LOGIC;            		          -- Ready Signal

	
	FSYNC_OUT       : out STD_LOGIC;                 		  -- Worttakt
	SDATA_OUT       : out STD_LOGIC;		 		  -- Bittakt
	SCLK_OUT        : out STD_LOGIC 		       	          -- Serielles Datum	
	);
end converter;

Des weiteren werden in der architecture von converter  folgenden Signale deklariert:

signal OLD_FSYNC    	: STD_LOGIC;				

signal M_1		: STD_LOGIC_VECTOR(0 to 15);
signal M_2		: STD_LOGIC_VECTOR(0 to 15); 
signal S		: INTEGER;                                	  --Zustände

signal Z_B              : INTEGER;                            		  -- Zähler Bit
signal Z_D		: INTEGER;		           		  -- Zähler Durchgang
signal Z_M		: INTEGER;		            	          -- Zähler geladene MONO  Signale

Dabei ist OLD_FSYNC der im vorhergehenden Takt empfangen FSYNC Wert.
In M_1 und M_2 werden eingehende MONO Signale gespeichert.
S gibt den Zustand an, wie im Automaten spezifiziert.
Z_B gibt an, welches Bit des eingelesenen MONO Signals als nächstes ausgegeben wird,
Z_D zählt den Durchgang in dem sich die Ausgabe des eingelesenen MONO Signals befindet und Z_M
zählt die Anzahl der eingeladenen MONO Signale.

Realisierung des Automaten

Zuerst wird immer geprüft ob ein Reset vorliegt und falls nicht wird normal in dem else-Zweig fortgesetzt:

if (Reset = '1') then 
M_1 <= "0000000000000000";
M_2 <= "0000000000000000";
            S   <= 0;				            	-- Ein asynchroner Reset ist aufgetreten
Z_B <= 0;								 
            Z_D <= 0;                               .
Z_M <= 0;								
			,
			
        elsif (SCLK'event and SCLK = '1') then
                      --HIER KOMMT DANN DER CODE DES else-Zweigs
        end if;


Im else-Zweig erfolgt dann die restliche Implementierung des Automaten. In den einzelnen if-Abfragen 
stellt das Programm fest in welchem Zustand des Automaten es sich befindet und zu welchem Zustand
es gelangt. Die in den Zweigen ausgeführten Aktionen entsprechen den Befehlen der Spezifikation des
Automaten.

Zustand  s0 und Übergang in den Zustand s1:

         if (S = 0 and READY = '1') then  
				M_1 <= MONO;
				Z_M <= 1;
				Z_D <= 1;
				Z_B <= 15; 
				S <= 1;
				FSYNC_OUT <= FSYNC;
            end if;

Zustand s1 und Übergang in den Zustand s1:
			
            if ( S = 1 and FSYNC = OLD_FSYNC) then
				S <= 1;
            end if;	

Zustand  s1 und Übergang in den Zustand s2:
						
            if (S = 1 and FSYNC /= OLD_FSYNC) then  
				FSYNC_OUT <= FSYNC;
				SDATA_OUT <= M_1(15);
				Z_B <= Z_B-1;
				S <= 2;
            end if;	  	   

Zustand  s2-s15 und Übergang in den jeweils nächsten Zustand:
			
	        if (S >= 2 and S <=(15)) then  
				FSYNC_OUT <= FSYNC;
				SDATA_OUT <= M_1(Z_B);
				Z_B <= Z_B-1;
				if (READY = '1') then
					M_2 <= MONO;
					Z_M <= 2;
				end if;
				S <= S+1;
            end if;

Zustand  s16 und Übergang in den Zustand s1:
			
 if (S = (16) and Z_D = 1) then  
		FSYNC_OUT <= FSYNC;
		Z_B <= (15);
		Z_D <= 2;
		SDATA_OUT <= M_1(0);
		S <= 1;
            end if;	
			
 if (S = (16) and Z_M = 2) then  			
		SDATA_OUT <= M_1(0);
		M_1 <= M_2;
		Z_D <= 1;
		Z_M <= 1;
		Z_B <= (15);
		S <= 1;
            end if;	

			
  if (S = (16) and READY = '1') then  
		SDATA_OUT <= M_1(0);
		M_1 <= MONO;
		Z_D <= 1;
		Z_M <= 1;
		Z_B <= (15);
		S <= 1;
            end if;

Zustand  s16 und Übergang in den Zustand s0:

			
 if (S = (16) and Z_D = 2 and Z_M = 1 and READY = '0') then  				
		S <= 0;
            end if;

Daraufhin wird noch innerhalb des else-Zweigs FSYNC OLD_FSYNC zugewiesen:

OLD_FSYNC <= FSYNC;
			
        end if;	

Und ausserhalb des else-Zweigs wird der Eingangsbittakt an die Ausgabe weitergegeben:
		
        SCLK_OUT <= SCLK;


Test des Programms

In diesem Testbeispiel werden zwei MONO Signale geladen und synchronisiert mit dem FSYNC_OUT
Ausgabesignal jeweils zweimal hintereinander ausgegeben. Die zwei eingegebenen 16 Bit MONO Signale 
sind: 1111111001111111 und 0000000110000000
Bevor jedoch das erste MONO Signale nach M_1 eingelesen wird findet im Beispiel zuerst noch ein Reset
statt und der Startschuss erfolgt wenn READY auf 1 geht. Das zweite Paket wird dann beim zweiten
READY=1 in M_2 eingelesen. Nachdem das erste zweimal ausgegeben ist wandert der Inhalt des zweiten
eingelesenen 16 Bit Pakets von M_2 nach M_1 und wird ebenfalls zweimal ausgegeben.



Hier im Detail der Verlauf der Zähler Signale und des Zustandszählers: Man erkennt den Übergang von Z_M auf 2 sobald das zweite MONO Signal eingelesen wurde, die bei S durchwanderten Zustände, den Zähler der Bitausgabe Z_B sowie den Durchgangszählen Z_D. Dies ist ein Ausschnitt aus dem obigen Beispiel




Home Aufgabenstellung Pflichtenheft Implementierung Spezifikation Dokumentation