1-- Literatur: Vorlesungsunterlagen EDS2 von Markus Pfaff (FH-Hagenberg)
2
3-- VHDL Vhsic Hardware Description Language
4-- VHSIC Very High Speed Integrated Circuits
5
6-- entity / architecture
7 entity PieceOfHw is
8 generic (
9 gAddrWidth : integer := 10;
10 gDataWidth : integer := 8
11 );
12 port (
13 iClk : in bit;
14 inResAsync : in bit;
15 iCountUp : in bit;
16 oCounter : out integer
17 -- wie Signals zu behandeln
18 -- (durch in, out, inout eingeschraenkt)
19 );
20 end entity PieceOfHw;
21
22 architecture PieceOfHwBhv of PieceOfHw is
23 -- Deklarationen
24
25 signal vTemp0 : integer;
26 begin
27 -- Struktur und/oder Verhaltensbeschreibung
28
29 CalcSomething: process is
30 -- lokale Deklarationen
31
32 variable vTemp1 : integer;
33 begin
34 vTemp1 := iTempInput + 2; -- von Ausserhalb
35 wait;
36 end process CalcOtherPeople;
37
38 end architecture PieceofHwBhv;
39
40 -- die Architektur sollte in einem separaten Datei abgelegt werden,
41 -- da es fuer eine Entity mehrere Implementierungen (Bhv, Rtl)
42 -- geben kann
43
44
45-- Entities "verdrahten"
46 library Work; -- Library bekannt machen
47
48 Timer1: entity Work.PieceOfHw(PieceOfHwBhv)
49 generic map(
50 gAddrWidth => 10,
51 gDataWidth => 16
52 )
53 port map(
54 iClk => sClk,
55 inResAsync => snRes,
56 iCountUp => sCntUp,
57 oCounter => sCntr
58 );
59
60
61-- diverse Deklarationen
62 variable vTemp2 : integer := 0; -- initiale Wert
63 constant vTemp3 : integer := 12; -- Konstante (muss initalisiert
64 -- werden, ist nicht schreibbar)
65
66 -- integer 0, -2, 1E6, 1000000
67 -- real 1.0, 0.0, 1.0E+30, -3.32E-10
68 -- character 'a', 'B', '1', '@'
69 -- boolean false, true
70 -- string "many characters."
71 -- bit '0', '1'
72 -- time 10 ns, 20 hr, 30 ps, 40.3 s
73
74 -- character'('0') explizite Zuordnung
75 -- bit'('0')
76
77 type aOwnType1 is range -256 to 255; -- selbst definierte Typen
78 type aOwnType2 is (SideA, SideB, SideC);
79 type aOwnType3 is (
80 'a',
81 '1',
82 a,
83 1,
84 asdf
85 );
86
87 -- abgeleiteter Typ
88 subtype aSignedByte is integer range -128 to 127;
89
90 -- unconstrained array types - Array Typen ohne Bereichsangabe
91 type string is array (positive range <>) of character;
92 -- constrained array types - Array Typen mit Bereichsangaben
93 subtype aAddress is range (0 to 255);
94 type aByte is array (7 downto 0) of bit;
95 type aMemory is array (aAddress) of aByte;
96
97
98-- Zuweisung
99 type aRegister is array (1 to 4) of integer;
100 variable vXReg : aRegister := (0, 0, 0, 0);
101 vXReg := (1=>12, 2=>234, others=>0);
102
103 variable vBitVector1 : bit_vector(31 downto 0);
104 variable vBitVector2 : bit_vector(15 downto 0);
105 variable vBitVector3 : bit_vector(1 to 4);
106 vBitVector1(0) := vBitVector2(15);
107 vBitVector2 := vBitVector1(15 downto 0);
108 vBitVector2 := vBitVector1; -- Zuordnung von links nach rechts
109 -- (15) := (31)
110 -- (14) := (30)
111 -- ...
112 -- (0) := (16)
113 vBitVector3 := vBitVector2; -- (1) := (15)
114 -- (2) := (14)
115 -- (3) := (13)
116 -- (4) := (12)
117
118
119-- Rocord Typen
120 type aRecord is record
121 Description : string;
122 Code : bit_vector (7 downto 0);
123 NrOfAddressBytes : natural;
124 end record aRecord;
125
126 constant cRec1 : aRecord := (
127 Description => "asdf",
128 Code => "10011111",
129 NrOfAddressBytes => 0
130 );
131 variable vRec2 : aRecord;
132
133 vActDescr := cRec1.Description;
134 vRec2 := cRec1;
135
136
137-- Zusammenstellungen (Concatenation)
138 variable vABus, vBBus, vCBus : bit_vector (3 downto 0);
139 variable vA, vB, vC, vD : bit;
140 vABus := vA & vB & vC & vD; -- von links nach rechts
141 vABus := vBBus(3 downto 2) & vCBus(1 downto 0);
142 vABus := (vBBus(3 downto 2), vCBus(1 downto 0));
143
144
145-- logische Operatoren
146 -- and, or, nand, nor, xor, xnor, not
147 vBit1 := vBit2 and vBit3;
148 vBool1 := vBool2 nor vBool3;
149 -- vBool1 := vBit2 and vBit2; -- boolean und bit nicht mischen
150
151
152-- relationale Operatoren
153 -- >, >=, <, <=, =, /= liefert boolean
154 vBool1 := (1 < 3);
155
156 variable vShort : bit_vector(4 to 6) := ('1', '0', '1');
157 variable vLong : bit_vecotr(0 to 7) := (1=>'1', others=>'0');
158 vBool2 := vShort > vLong;
159 -- von links nach rechts
160 -- 1 0 1 : groesser
161 -- 0 1 0 0 0 0 0 0 : kleiner
162
163
164-- arithmetische Operatoren
165 -- -, +, *, /, mod, rem, **(Hochfunktion), abs
166 -- fuer integer, real(nicht mod, rem), time
167
168 -- a mod b -> positiver Rest
169 -- a rem b -> Rest hat Vorzeichen von a
170
171
172-- Schiebeoperationen
173 sll -- shift left logical "11110000" sll 2 => "11000000"
174 srl -- shift right logical "00001111" srl 2 => "00000011"
175 sla -- shift left arithmetic "00001111" sla 2 => "00111100"
176 sra -- shift right arithmetic "00111111" sra 2 => "00001111"
177 -- bzw. "11110000" sra 2 => "11111100"
178 rol -- rotate left "00110011" rol 2 => "11001100"
179 ror -- rotate right "11001100" ror 2 => "00110011"
180
181-- Attribute
182 subtype SmallInt is integer range 0 to 2356;
183 -- SmallInt'left = 0
184 -- SamllInt'right = 2356
185 -- SmallInt'range = 0 to 2356
186
187 signal BinNr : bit_vector (31 downto 0);
188 -- BinNr'left = 31
189 -- BinNr'right = 0
190 -- BinNr'low = 0
191 -- BinNr'high = 31
192 -- BinNr'range = 31 downto 0
193 -- BinNr'length = 32
194
195 signal Flag : bit;
196 -- Flag'event ... Event aufgetreten?
197 -- Flag'stable(T) ... waehrend des Zeitraums stabil?
198 -- Flag'active ... momentan aktiv?
199 -- Flag'delayed(T) ... Kopie von Flag, um T verzoegert
200 -- Flag'last_event, Flag'last_active, Flag'last_value
201
202
203-- diverse Ablauf-Statements
204 -- if
205 if (vA > vB) and (vA < vC) then
206 vGr := vA;
207 elsif (vD > vF) then
208 vGr := vD;
209 else
210 vGr := vB;
211 end if;
212
213
214 -- case
215 type aState is (stateA, stateB, stateC, stateD);
216 variable vActState : aState;
217 case vActState is
218 when stateA =>
219 vTemp1 := 12;
220 when stateB =>
221 vTemp1 := 24;
222 when others =>
223 null;
224 end case;
225
226
227 -- while Schleife
228 while (vIndex <= 3) loop
229 -- ...
230 vIndex := vIndex + 1;
231 end loop;
232
233 -- for Schleife
234 for vIndex in 8 downto 0 loop
235 -- ...
236 end loop;
237
238 -- endlos Schleife
239 loop
240 -- ...
241 end loop;
242
243
244-- Assertion / Report
245 assert (vSomethingGoesWrong = false)
246 report "output message"
247 severity warning;
248 -- note
249 -- warning
250 -- error
251 -- failure
252
253 report "output message"
254 severity warning;
255
256
257-- Funktion
258 -- Werte werden eingegeben und ein Ergebnis wird zurueck geliefert
259 -- Eingabewerte sind im Inneren konstant
260 function Larger (cVal1, cVal2 : integer) return integer is
261 variable vResult : integer;
262 begin
263 if cVal1 > cVal2 then
264 vResult := cVal1;
265 else
266 vResult := cVal2;
267 end if;
268 return vResult;
269 end function Larger;
270
271 vRes := Larger(vVar1, vVar2);
272
273
274-- Prozedur
275 -- Werte ein- oder ausgeben
276 procedure Swap ( variable vA, vB : inout integer;
277 constant cPermitSwap : boolean ) is
278 variable vTemporal : integer;
279 begin
280 if cPermitSwap then
281 vTemporal := vA;
282 vA := vB;
283 vB := vTemporal;
284 return;
285 end if;
286 end procedure Swap;
287
288 Swap(vVar1, vVar2, true);
289
290
291-- Simulationszeit
292 wait; -- fuer immer warten
293 wait for 14 ms; -- fuer 14ms warten
294 wait on sA, sB; -- auf Aenderung von sA oder sB warten
295 wait on sA for 14 sec; -- warte auf Event sA, max. 14 Sekunden
296 wait on sA until sA > 3; -- warte auf Event sA, mit Bedingung sA>3
297 wait until sA > 3; -- -,,-
298 wait on sA, sB until sA = 10 for 16 us;
299
300 sA <= transport sB after 14 us; -- Simulation von Verzoegerungs-
301 -- zeiten (propagation delay)
302 -- Simulation von Traegheitszeiten
303 -- (inertial delay)
304 -- Wert muss mindestens 5 ns lang
305 -- anders sein, um uebernommen
306 -- zu werden
307 sA <= reject 5 ns inertial sB after 10 ns;
308
309 sA <= reject 5 ns inertial sB after 5 ns; -- =
310 sA <= inertial sB after 5 ns; -- =
311 sA <= sB after 5 us;
312 sA <=
313 '0' after 10 ns,
314 '1' after 30 ns,
315 '0' after 90 ns;
316
317
318-- shared Variables (nicht brauchbar)
319 -- Ergebnis ist nicht definiert, kommt darauf an welcher Prozess
320 -- zuerst abgearbeitet wird. Es werden beide Variablen vA oder vB,
321 -- da shared varible den Wert immer direkt uebernehmen.
322 entity Swapper is
323 end entity Swapper;
324 architecture SwapperBhv of Swapper is
325 shared variable vA : integer := 10;
326 shared variable vB : integer := 13;
327 begin
328 MakeA2B: process is
329 begin
330 wait for 1 ms;
331 vA := vB;
332 end process MakeA2B;
333
334 MakeB2A: process is
335 begin
336 wait for 1 ms;
337 vB := vA;
338 end process MakeB2A;
339 end architecture SwapperBhv;
340
341
342-- signals
343 -- fuer eine bestimmte Zeit werden alle vorherigen Werte zwischen-
344 -- gespeichert und mit den gespeicherten Werten werden alle Signals
345 -- neu berechnet.
346 entity Swapper is
347 end entity Swapper;
348 architecture SwapperBhv of Swapper is
349 signal vA : integer := 10;
350 signal vB : integer := 13;
351 begin
352 MakeA2B: process is
353 begin
354 wait for 1 ms;
355 vA <= vB;
356 end process MakeA2B;
357
358 MakeB2A: process is
359 begin
360 wait for 1 ms;
361 vB <= vA;
362 end process MakeB2A;
363 end architecture SwapperBhv;
364
365
366-- postponed process
367 -- Wir sind nur fuer die stabilisierten Werte interessiert.
368 -- (ignoriert delta-Cycles)
369 TestFinalValues : postponed process is
370 begin
371 assert (A < B)
372 report "TM: A and B do not relate as desired !"
373 severity warning;
374 wait on A, B;
375 end postponed process TestFinalValues;
376
377
378-- Generate Statement
379 OthrStgs : for Stage in
380 FilteredThrough'left to
381 FilteredThrough'right-1 generate
382 begin
383 OneOtherStage : entity Work.Filter(SomehowElse)
384 port map (
385 iNoisy => FilteredThrough(Stage),
386 oCalm => FilteredThrough(Stage+1)
387 );
388 end generate OtherStages ;
389
390
391 MayDefuzzyfy : if DefuzzyfyIt generate
392 begin
393 Defuzzyfying : entity Work.Defuzzyfier(Anyhow)
394 port map (
395 iFuzzy => FilteredThrough(FilteredThrough'length),
396 oClean => oFiltered
397 );
398 end generate MayDefuzzify;
399
400
401-- Component Instantiation
402 architecture Structure of Any is
403 -- Komponente Deklarieren
404 component Stacker is
405 port (
406 iClk : in bit;
407 inResAsync : in bit;
408 ...
409 );
410 end component Stacker;
411
412 -- Konfiguration Spezifizieren
413 for TheStacker1 use entity work.AStack(Somehow)
414 port map (
415 iClk => iClk,
416 inResAsync => inResAsync,
417 ...
418 );
419 begin
420 -- Komponente Instanzieren
421 TheStacker1: Stacker
422 generic map (...)
423 port map (...);
424 end architecture Structure;
425
426
427-- Package Deklarieren
428 package ProjectGlobal is
429 constant cBitwidth : integer := 8;
430 type aBinaryNr is bit_vector (cBitWidth-1 downto 0);
431 subtype aIntNr is integer range 0 to 2**cBitwidth-1;
432
433 function Bin2Int (cBinary : aBinaryNr) return aIntNr;
434 procedure Swap (vBinary1, vBinary2 : inout aBinaryNr);
435
436 constant cDecidedOk : boolean;
437 end package ProjectGlobal;
438
439
440 package body ProjectGlobal is
441 constant cDecidedOk : boolean := true;
442
443 function Bin2Int (cBinaryNr : aBinaryNr) return aIntNr is
444 variable vAccumulated : integer := 0;
445 begin
446 for Digit in cBinaryNr'range loop
447 if cBinaryNr(Digit) = '1' then
448 vAccumulated := vAccumulated + 2**Digit;
449 end if;
450 end loop;
451 return vAccumulated;
452 end function Bin2Int;
453
454 procedure Swap (vBinary1, vBinary2 : inout aBinaryNr) is ...
455 end package body ProjectGlobal;
456
457
458-- Package nutzen
459 library IEEE; -- in welcher Lib. befinded sich Package
460 use IEEE.std_logic_1164; -- Package Deklarationen sichtbar machen
461 use IEEE.std_logic_1164.all;
462
463 library std; -- Standard Library fuer vordefinierte
464 -- Sprach-Umgebung
465 library work; -- Standard User Library
466 use std.standard.all; -- Deklaration von vordefinierten
467 -- Typen und Operationen
468
469 library IEEE; -- Standard Library fuer standardisierte
470 -- Sprach-Erweiterung
471 use IEEE.std_logic_1164.all;-- 9-wertige Logic Typen und
472 -- verfuegbare Operationen
473 -- 'U' ... uninitialisiert
474 -- 'X' ... Wert unbekannt (Fehler)
475 -- '-' ... egal ob durch '0' oder
476 -- '1' ersetzt wird
477 -- '0', '1'
478 -- 'Z' ... high Impedanz
479 -- 'L' ... low
480 -- 'H' ... high
481 -- 'W' ... weak
482 std_ulogic_vector -- unresolved Datentyp (wird Signal an
483 -- mehreren Stellen geschrieben, so
484 -- wird Error gemeldet)
485 std_logic_vector -- resolved Datentyp
486
487
488-- Sensitivity List
489 DoIt: process is
490 begin
491 -- ...
492 wait on A, B, C, D, ...
493 end process DoIt; -- =
494
495 DoIt: process (A, B, C, D, ...) is
496 begin
497 -- ...
498 end process DoIt;
499
500
501-- Concurrent Assertion-Statement
502 TestIt: process is
503 begin
504 assert (A > B)
505 report "message"
506 severity warning;
507 wait on A, B;
508 end processs TestIt; -- =
509
510 assert (A > B)
511 report "message"
512 severity warning;
513
514
515-- Concurrent Signal-Assignment
516 LabelIt: process is
517 begin
518 SesamStreet <= Ernie and Bert after 20 us;
519 wait on Ernie, Bert;
520 end process TestIt; -- =
521
522 LabelIt: SesamStreet <= Ernie and Bert after 20 us;
523
524-- Concurrent Conditional Signal-Assignment
525 Labeled: process is
526 begin
527 if A < B then
528 SesamStreet <= Ernie and Bert;
529 elsif A = B then
530 SesamStreet <= Bibo;
531 else
532 SesamStreet <= Gonzo;
533 end if;
534 wait on A, B, Ernie, Bert, Bibo, Gonzo;
535 end process TestIt; -- =
536
537 Labeled: SesamStreet <=
538 Ernie and Bert when (A<B) else
539 Bibo when (A=B) else
540 Gonzo;
541
542
543-- Concurrent Selected Signal-Assignment
544 ALabel: process is
545 begin
546 case Month is
547 when May =>
548 SesamStreet <= Ernie and Bert;
549 when Jun | Oct =>
550 SesamStreet <= Bibo;
551 when others =>
552 SesamStreet <= Gonzo;
553 end case;
554 wait on Month, Ernie, Bert, Bibo, Gonzo;
555 end process TestIt; -- =
556
557 ALabel: with Month select
558 SesamStreet <= Ernie and Bert when May,
559 Bibo when Jun | Oct,
560 Gonzo when others;
561
562
563-- Concurrent Procedure-Call
564 Calling: process is
565 begin
566 CheckTiming (D, Clk, Reset, TSetup, THold);
567 wait on D, Clk, Reset;
568 end processs TestIt; -- =
569
570 Calling: CheckTiming (D, Clk, Reset, TSetup, THold);
