vhdl anfänger mit problem

[Tigger (Gast)]

hallo!
hab eine kleines problem mit meiner vhdl file. benutze xilinx ise 9.2.

wir haben von unserem prof die aufgabe bekommen, einen taschenrechner zu 
programmieren. ich bin dabei dafür zuständig, die zahlen die mir im bcd 
code geschickt werden auf der 7 segment anzeige anzeigen zulassen.

folgendes programm habe ich bereits geschrieben:

 ----------------------------------------------------------------------------------

-- Company: 

-- Engineer: 

-- 

-- Create Date:    19:59:46 10/24/2009 

-- Design Name: 

-- Module Name:    tas - 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 tas is

    Port ( CLK : in  STD_LOGIC;

           RESET : in  STD_LOGIC;

           bcd0 : in  STD_LOGIC_VECTOR (3 downto 0);

     bcd1 : in  STD_LOGIC_VECTOR (3 downto 0);

     bcd2 : in  STD_LOGIC_VECTOR (3 downto 0);

            bcd3 : in  STD_LOGIC_VECTOR (3 downto 0);

     bcd4 : in  STD_LOGIC_VECTOR (3 downto 0);

     bcd5 : in  STD_LOGIC_VECTOR (3 downto 0);
     bcd6 : in  STD_LOGIC_VECTOR (3 downto 0);
       operator : in STD_LOGIC_VECTOR (3 downto 0);

           DIG0_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

           DIG1_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

           DIG2_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

           DIG3_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

           DIG4_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

           DIG5_SEG : out  STD_LOGIC_VECTOR (7 downto 0));

end tas;



architecture Behavioral of tas is



begin
process(operator, CLK)

if (operator /= "1111")
then



DIG0_SEG(7 downto 0) <= "00000010";    



DIG1_SEG(7 downto 0) <= "00000010";



DIG2_SEG(7 downto 0) <= "00000010";



DIG3_SEG(7 downto 0) <= "00000010";



DIG4_SEG(7 downto 0) <= "00000010";



DIG5_SEG(7 downto 0) <= "00000010";    


else



process(bcd0, bcd1, bcd2, bcd3, bcd4, bcd5, bcd6, CLK)    -- beginn BCD-Code auslesen und Zahl in DIG schreiben

begin



if (bcd6 <= "0000") then



case bcd0 is

when "0000" => DIG0_SEG(7 downto 0) <= "11111100";

when "0001" => DIG0_SEG(7 downto 0) <= "01100000";

when "0010" => DIG0_SEG(7 downto 0) <= "11011010";

when "0011" => DIG0_SEG(7 downto 0) <= "11110010";

when "0100" => DIG0_SEG(7 downto 0) <= "01100110";

when "0101" => DIG0_SEG(7 downto 0) <= "10110110";

when "0110" => DIG0_SEG(7 downto 0) <= "10111110";

when "0111" => DIG0_SEG(7 downto 0) <= "11100000";

when "1000" => DIG0_SEG(7 downto 0) <= "11111110";

when "1001" => DIG0_SEG(7 downto 0) <= "11110110";

when others => DIG0_SEG(7 downto 0) <= "XXXXXXXX";

end case;



case bcd1 is

when "0000" => DIG1_SEG(7 downto 0) <= "11111100";

when "0001" => DIG1_SEG(7 downto 0) <= "01100000";

when "0010" => DIG1_SEG(7 downto 0) <= "11011010";

when "0011" => DIG1_SEG(7 downto 0) <= "11110010";

when "0100" => DIG1_SEG(7 downto 0) <= "01100110";

when "0101" => DIG1_SEG(7 downto 0) <= "10110110";

when "0110" => DIG1_SEG(7 downto 0) <= "10111110";

when "0111" => DIG1_SEG(7 downto 0) <= "11100000";

when "1000" => DIG1_SEG(7 downto 0) <= "11111110";

when "1001" => DIG1_SEG(7 downto 0) <= "11110110";

when others => DIG1_SEG(7 downto 0) <= "XXXXXXXX";

end case;



case bcd2 is

when "0000" => DIG2_SEG(7 downto 0) <= "11111100";

when "0001" => DIG2_SEG(7 downto 0) <= "01100000";

when "0010" => DIG2_SEG(7 downto 0) <= "11011010";

when "0011" => DIG2_SEG(7 downto 0) <= "11110010";

when "0100" => DIG2_SEG(7 downto 0) <= "01100110";

when "0101" => DIG2_SEG(7 downto 0) <= "10110110";

when "0110" => DIG2_SEG(7 downto 0) <= "10111110";

when "0111" => DIG2_SEG(7 downto 0) <= "11100000";

when "1000" => DIG2_SEG(7 downto 0) <= "11111110";

when "1001" => DIG2_SEG(7 downto 0) <= "11110110";

when others => DIG2_SEG(7 downto 0) <= "XXXXXXXX";

end case;



case bcd3 is

when "0000" => DIG3_SEG(7 downto 0) <= "11111100";

when "0001" => DIG3_SEG(7 downto 0) <= "01100000";

when "0010" => DIG3_SEG(7 downto 0) <= "11011010";

when "0011" => DIG3_SEG(7 downto 0) <= "11110010";

when "0100" => DIG3_SEG(7 downto 0) <= "01100110";

when "0101" => DIG3_SEG(7 downto 0) <= "10110110";

when "0110" => DIG3_SEG(7 downto 0) <= "10111110";

when "0111" => DIG3_SEG(7 downto 0) <= "11100000";

when "1000" => DIG3_SEG(7 downto 0) <= "11111110";

when "1001" => DIG3_SEG(7 downto 0) <= "11110110";

when others => DIG3_SEG(7 downto 0) <= "XXXXXXXX";

end case;



case bcd4 is

when "0000" => DIG4_SEG(7 downto 0) <= "11111100";

when "0001" => DIG4_SEG(7 downto 0) <= "01100000";

when "0010" => DIG4_SEG(7 downto 0) <= "11011010";

when "0011" => DIG4_SEG(7 downto 0) <= "11110010";

when "0100" => DIG4_SEG(7 downto 0) <= "01100110";

when "0101" => DIG4_SEG(7 downto 0) <= "10110110";

when "0110" => DIG4_SEG(7 downto 0) <= "10111110";

when "0111" => DIG4_SEG(7 downto 0) <= "11100000";

when "1000" => DIG4_SEG(7 downto 0) <= "11111110";

when "1001" => DIG4_SEG(7 downto 0) <= "11110110";

when others => DIG4_SEG(7 downto 0) <= "XXXXXXXX";

end case;



case bcd5 is

when "0000" => DIG5_SEG(7 downto 0) <= "11111100";

when "0001" => DIG5_SEG(7 downto 0) <= "01100000";

when "0010" => DIG5_SEG(7 downto 0) <= "11011010";

when "0011" => DIG5_SEG(7 downto 0) <= "11110010";

when "0100" => DIG5_SEG(7 downto 0) <= "01100110";

when "0101" => DIG5_SEG(7 downto 0) <= "10110110";

when "0110" => DIG5_SEG(7 downto 0) <= "10111110";

when "0111" => DIG5_SEG(7 downto 0) <= "11100000";

when "1000" => DIG5_SEG(7 downto 0) <= "11111110";

when "1001" => DIG5_SEG(7 downto 0) <= "11110110";

when others => DIG5_SEG(7 downto 0) <= "XXXXXXXX";    -- ende BCD-Code auslesen und Zahl in DIG0 schreiben

end case;





else 

DIG0_SEG(7 downto 0) <= "10011110";

DIG1_SEG(7 downto 0) <= "11101110";

DIG2_SEG(7 downto 0) <= "11101110";

DIG3_SEG(7 downto 0) <= "11111100";

DIG4_SEG(7 downto 0) <= "11101110";

DIG5_SEG(7 downto 0) <= "00000000";

end if;





end process;

end Behavioral;

sorry, kriegs nich hin, dass die zeilenangaben dabei stehn.. :(

ich bekomme beim compilieren allerdings folgende fehlermeldungen:

ERROR:HDLParsers:164 - "C:/..../tas.vhd" Line 54 parse error, unexpected 
IF
ERROR:HDLParsers:164 - "C:/..../tas.vhd" Line 72 parse error, unexpected 
ELSE


des ganze sind folgende zeilen: 54: if (operator /="1111")

und 72: else

wenn ich den oberen teil auskommentiere erhalte ich noch einen fehler, 
und zwar:

FATAL_ERROR:Xst:Portability/export/Port_Main.h:127:1.17 - This 
application has discovered an exceptional condition from which it cannot 
recover.  Process will terminate. For more information on this error, 
please consult the Answers Database or open a WebCase with this project 
attached at http://www.xilinx.com/support.

da hab ich auch keine ahnung, was es damit auf sich hat.

ich hoffe ihr könnt mir helfen..

mfg

Tigger

[Achim (Gast)]

Schau dir den Syntax der von dir verwendeten VHDL Konstrukte noch mal 
genau an. Bei einem Process muss immer ein "begin" vorhanden sein. Der 
erste Process und die erste If-Abfrage sind außerdem nicht vollständig. 
Vor dem 2ten Process muss der Erste mit "end process;" abgeschlossen 
werden.

Ich habe mich jetzt nur auf den Syntax konzentriert, ob die Umsetzung so 
sinnvoll/korrekt ist steht auf einem anderen Blatt.

PS: Ein so langen Quelltext solltest du als Anhang einfügen. Dann kann 
auch jeder die Zeilennummern nachschauen.

[Tigger (Gast)]

ah, ok, danke für die schnelle hilfe. habs jetz so weit geschafft, dass 
ich wieder nur meinen fatal_error hab. woran könnte denn das noch 
liegen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Du solltest unbedingt deinen Code sinnvoll einrücken, so wie das 
dasteht, ist keinerlei Struktur zu erkennen...
Das macht die Fehlersuche schwierig.
Sieh dir wie gesagt den Aufbau einer Architecture, darin die Prozesse 
und darin die if-Abfragen nochmal genauer an.

> process(bcd0, bcd1, bcd2, bcd3, bcd4, bcd5, bcd6, CLK)
Wozu ist der CLK in der Sensitivliste? Der wird in diesem Prozess doch 
gar nicht verwendet :-/


> FATAL_ERROR:Xst:Portability/export/Port_Main.h:127:1.17 - This
> application has discovered an exceptional condition from which it
> cannot recover.  Process will terminate.
Du hast eine dermaßen unglaubliche+fehlerbehaftete VHDL-Beschreibung 
abgeliefert, dass es den Synthesizer zerhagelt hat. Der ist einfach 
abgestürzt  :-(

[Tigger (Gast)]

hm... des is dann wohl eher ungünstig :(
d.h. ich muss des programm mehr oder weniger nochma komplett neu 
schreiben? oder is da noch iwas von zu retten? ^

[Iulius (Gast)]

Sieh dir doch bitte mal die Konstrukte "array" und "for loop" an.

Das ganze für jedes lcd einzeln hin zu schreiben ist gelinde gesagt ein 
extrem überflüssiger Aufwand und zudem unübersichtlich.


Achja, ein if mit zuweisung wie bei "if (bcd6 <= "0000")" macht genau 
wie etwa in c keinen Sinn.

Blöderweise lässt der compiler diesen solche Fehler zu(passieren mit 
auch gelegentlich)...naja vielleicht erfindet irgentjemand mal eine 
sinnvolle Anwendung dafür.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> Achja, ein if mit zuweisung wie bei "if (bcd6 <= "0000")" macht genau
> wie etwa in c keinen Sinn.
Das ist hier keine Zuweisung, sondern, ein "kleiner gleich". In VHDL 
können Zuweisungen in einer if-Abfrage nicht so "aus Versehen" wie in C 
erfolgen.

 use IEEE.STD_LOGIC_UNSIGNED.ALL;

Allerdings darf hier die Frage gestellt werden, wie bcd6 denn überhaupt 
kleiner als "0000" werden sollte...  :-o
Als Tipp: sieh dir mal die genormte numeric_std an
http://www.lothar-miller.de/s9y/categories/16-Numeric_Std

> Blöderweise lässt der compiler diesen solche Fehler zu
Der Synthesizer zum Glück nicht ;-)

[Thomas R. (Firma: abaxor engineering) (abaxor)]

Ich kenne zwar deinen aktuellen Code nicht, aber wenn du den ersten 
Prozess nur vervollständigt hast, weißt du einem Signal (z.B. DIG0_SEG) 
in mehreren Prozessen einen Wert zu. Das lässt sich nicht 
implementieren. Vielleicht kommt daher dein Syntheser-Problem.

Folgende Regeln stehen jedesmal über der Box, in der du deinen Text 
eingibst.

Wichtige Regeln - erst lesen, dann posten!

    * Groß- und Kleinschreibung verwenden
    * Längeren Sourcecode nicht im Text einfügen, sondern als 
Dateianhang


Tom

[Iulius (Gast)]

Ein kleiner gleich, puh daran habe ich dabei noch nie gedacht. Ich hätte 
das wohl immer anders rum geschrieben "=<" damit es eindeutig ist ggü 
der Zuweisung.

Und was meinst du damit, das der Synthesizer das nicht zulässt ?
Ich denke es wird als kleiner gleich gewertet und damit doch zugelassen 
?

Kann mich zumindest entsinnen schonmal aufgrunddessen eine falsche 
Simulation erhalten zu haben, weil ich per copy und paste die 
Bedingungen zusammengeklickt hatte...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> Und was meinst du damit, das der Synthesizer das nicht zulässt ?
Er lässt keine Zuweisung (<=) im Vergleich (if) zu.

[Tigger (Gast)]

ok, das Programm lässt sich jetzt durch den Synthesizer jagen. :) Morgen 
werd ich noch ne Testbench drüber laufen lassen. Ich hoff, dass des 
ganze jetz so läuft, wie ichs mir vorstell. Ich bedanke mich schonmal 
für die viele Hilfe die ich hier bekommen habe.