vhdl anfänger mit problem

Tigger Gast #1463268
Lesenswert?
• ▲
▼ 
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:

1
 ----------------------------------------------------------------------------------

2


3
-- Company: 

4


5
-- Engineer: 

6


7
-- 

8


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

10


11
-- Design Name: 

12


13
-- Module Name:    tas - Behavioral 

14


15
-- Project Name: 

16


17
-- Target Devices: 

18


19
-- Tool versions: 

20


21
-- Description: 

22


23
--

24


25
-- Dependencies: 

26


27
--

28


29
-- Revision: 

30


31
-- Revision 0.01 - File Created

32


33
-- Additional Comments: 

34


35
--

36


37
----------------------------------------------------------------------------------

38


39
library IEEE;

40


41
use IEEE.STD_LOGIC_1164.ALL;

42


43
use IEEE.STD_LOGIC_ARITH.ALL;

44


45
use IEEE.STD_LOGIC_UNSIGNED.ALL;

46


47


48


49
---- Uncomment the following library declaration if instantiating

50


51
---- any Xilinx primitives in this code.

52


53
--library UNISIM;

54


55
--use UNISIM.VComponents.all;

56


57


58


59
entity tas is

60


61
    Port ( CLK : in  STD_LOGIC;

62


63
           RESET : in  STD_LOGIC;

64


65
           bcd0 : in  STD_LOGIC_VECTOR (3 downto 0);

66


67
     bcd1 : in  STD_LOGIC_VECTOR (3 downto 0);

68


69
     bcd2 : in  STD_LOGIC_VECTOR (3 downto 0);

70


71
            bcd3 : in  STD_LOGIC_VECTOR (3 downto 0);

72


73
     bcd4 : in  STD_LOGIC_VECTOR (3 downto 0);

74


75
     bcd5 : in  STD_LOGIC_VECTOR (3 downto 0);

76
     bcd6 : in  STD_LOGIC_VECTOR (3 downto 0);

77
       operator : in STD_LOGIC_VECTOR (3 downto 0);

78


79
           DIG0_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

80


81
           DIG1_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

82


83
           DIG2_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

84


85
           DIG3_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

86


87
           DIG4_SEG : out  STD_LOGIC_VECTOR (7 downto 0);

88


89
           DIG5_SEG : out  STD_LOGIC_VECTOR (7 downto 0));

90


91
end tas;

92


93


94


95
architecture Behavioral of tas is

96


97


98


99
begin

100
process(operator, CLK)

101


102
if (operator /= "1111")

103
then

104


105


106


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

108


109


110


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

112


113


114


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

116


117


118


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

120


121


122


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

124


125


126


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

128


129


130
else

131


132


133


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

135


136
begin

137


138


139


140
if (bcd6 <= "0000") then

141


142


143


144
case bcd0 is

145


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

147


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

149


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

151


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

153


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

155


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

157


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

159


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

161


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

163


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

165


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

167


168
end case;

169


170


171


172
case bcd1 is

173


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

175


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

177


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

179


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

181


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

183


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

185


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

187


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

189


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

191


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

193


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

195


196
end case;

197


198


199


200
case bcd2 is

201


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

203


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

205


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

207


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

209


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

211


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

213


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

215


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

217


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

219


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

221


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

223


224
end case;

225


226


227


228
case bcd3 is

229


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

231


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

233


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

235


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

237


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

239


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

241


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

243


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

245


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

247


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

249


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

251


252
end case;

253


254


255


256
case bcd4 is

257


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

259


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

261


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

263


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

265


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

267


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

269


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

271


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

273


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

275


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

277


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

279


280
end case;

281


282


283


284
case bcd5 is

285


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

287


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

289


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

291


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

293


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

295


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

297


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

299


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

301


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

303


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

305


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

307


308
end case;

309


310


311


312


313


314
else 

315


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

317


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

319


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

321


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

323


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

325


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

327


328
end if;

329


330


331


332


333


334
end process;

335


336
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Achim Gast #1463291
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #1463319
Lesenswert?
• ▲
▼ 
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  :-(
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Iulius Gast #1463382
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lothar M. Moderator (Firma: Titel) Persönliche Seite #1463476
Lesenswert?
• ▲
▼ 
> 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.

1
 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 ;-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas R. (Firma: abaxor engineering) #1463511
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Iulius Gast #1463539
Lesenswert?
• ▲
▼ 
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...
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tigger Gast #1464766
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren