8333316

ÓÄÊ 681.3
ÁÁÊ 32.973.26-018.2
Ï 54
Ï 54
Ïîëÿêîâ À. Ê.
ßçûêè VHDL è VERILOG â ïðîåêòèðîâàíèè öèôðîâîé àïïàðàòóðû. — Ì.:
ÑÎËÎÍ-Ïðåññ, 2010. — 320 ñ.: èë. — (Ñåðèÿ «Ñèñòåìû ïðîåêòèðîâàíèÿ»).
ISBN 5-98003-016-6
Êíèãà ïîñâÿùåíà ïðîåêòèðîâàíèþ öèôðîâûõ ñèñòåì ñ ïîìîùüþ âûñîêîóðîâíåâûõ
ÿçûêîâ îïèñàíèÿ àïïàðàòóðû (Hardware Description Language — HDL) — Verilog è VHDL. Ýòè
ÿçûêè ÿâëÿþòñÿ ìåæäóíàðîäíûì ñòàíäàðòîì è èñïîëüçóþòñÿ êàê ñèñòåìàìè àíàëèçà (ìîäåëèðîâàíèå), òàê è ñèñòåìàìè ñèíòåçà öèôðîâîé àïïàðàòóðû. Ñ åäèíûõ ïîçèöèé èçëîæåíû îñíîâíûå êîíöåïöèè ýòèõ ÿçûêîâ. Äàíû ðåêîìåíäàöèè ïî ñòèëþ êîäèðîâàíèÿ, ñèíòåçàáåëüíîñòè è âåðèôèêàöèè HDL-îïèñàíèé ïðîåêòèðóåìûõ ñèñòåì.
Ïðèâåäåíû ïðèìåðû ñèíòåçàáåëüíûõ îïèñàíèé óçëîâ è óñòðîéñòâ è îðãàíèçàöèè ôóíêöèîíàëüíûõ òåñòîâ.
 ïðèëîæåíèå âûíåñåíû ñïðàâî÷íûå äàííûå ïî ÿçûêàì VHDL è VERILOG.
Àâòîð ïðåäïîëàãàåò, ÷òî ÷èòàòåëü çíàêîì ñ îñíîâàìè ïðîãðàììèðîâàíèÿ è îñíîâàìè
ïðîåêòèðîâàíèÿ öèôðîâûõ óñòðîéñòâ.
ISBN 5-98003-016-6
© Ìàêåò è îáëîæêà «ÑÎËÎÍ-Ïðåññ», 2010
© À. Ê. Ïîëÿêîâ, 2010
Ñîäåðæàíèå
Ïðåäèñëîâèå. ßçûêè VHDL è VERILOG . . . . . . . . . . . . . . . . 3
Ââåäåíèå. HDL — èñòîðè÷åñêèé ýêñêóðñ è ïåðñïåêòèâû . . . . . . . . 6
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è âçãëÿä ïðîãðàììèñòà . . . . . 15
1.1. HDL — âçãëÿä ðàçðàáîò÷èêà àïïàðàòóðû . . . . .
1.1.1. Îòîáðàæàåìûå àñïåêòû . . . . . . . . . .
1.1.2. Èíòåðôåéñ îáúåêòà ïðîåêòà . . . . . . . .
1.1.3. Îïèñàíèå ñòðóêòóðû îáúåêòà ïðîåêòà . . .
1.1.4. Ñâÿçü èìåí êîìïîíåíòîâ è îáúåêòà ïðîåêòà .
1.1.5. Ïîâåäåíèå îáúåêòà ïðîåêòà . . . . . . . .
1.1.6. Paçíîîáðàçèå ñòèëåé îïèñàíèé àðõèòåêòóð .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15
15
16
17
19
20
21
1.2. HDL — âçãëÿä ïðîãðàììèñòà. . . . .
1.2.1. Ëåêñè÷åñêèå ýëåìåíòû HDL . .
1.2.2. Äàííûå (îáúåêòû): òèïû è âèäû
1.2.3. Îïåðàöèè è âûðàæåíèÿ . . . .
1.2.4. Îïåðàòîðû . . . . . . . . . .
1.2.5. Ìåõàíèçì ðàñøèðåíèÿ ÿçûêà .
1.2.6. Îáëàñòü âèäèìîñòè äàííûõ . .
1.2.7. Ìîäóëè è áèáëèîòåêè ïðîåêòà .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
24
25
28
31
34
39
40
42
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ãëàâà 2. Áàçîâûå ïîíÿòèÿ HDL — ïðîöåññû, çàäåðæêè, àëôàâèò . . . 44
2.1. Ïàðàëëåëüíûå ïðîöåññû . . . . . . . . . . . . . . .
2.1.1. Ïàðàëëåëüíûå îïåðàòîðû HDL . . . . . . . . .
2.1.2. Îïåðàòîð ïðîöåññà . . . . . . . . . . . . . .
2.1.3. Êðàòêèå ôîðìû çàïèñè ïðîöåññîâ . . . . . . .
2.1.4. Ïðèñâàèâàíèå ñ äåëüòà-çàäåðæêîé . . . . . . .
2.1.5. Ìåõàíèçì âîñïðîèçâåäåíèÿ ìîäåëüíîãî âðåìåíè
Âîïðîñû è óïðàæíåíèÿ . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
44
44
45
49
50
51
53
2.2. Çàäåðæêè ñèãíàëîâ . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.2.1. Èíåðöèîííàÿ è òðàíñïîðòíàÿ çàäåðæêà . . . . . . . . . . . . . 53
2.2.2. Ðåçåêöèÿ è íåîïðåäåëåííîñòü êîðîòêèõ ñèãíàëîâ . . . . . . . . 56
2.3. Âåêòîðíûå îïåðàöèè è êîìïàêòíîñòü îïèñàíèé ñèñòåì . . . . . . . . . 57
2.3.1. Âåêòîðû . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.3.2. Îïåðàòîð ãåíåðàöèè . . . . . . . . . . . . . . . . . . . . . 58
2.4. Àëôàâèò ìîäåëèðîâàíèÿ. . . . . . .
2.4.1. ×åòûðåõçíà÷íûé àëôàâèò . . .
2.4.2. Äåâÿòèçíà÷íûé àëôàâèò VHDL
2.4.3. X-ïåññèìèçì è îïòèìèçì . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
59
60
61
63
308
Ñîäåðæàíèå
2.5. Îïèñàíèå ìîíòàæíûõ È (ÈËÈ) è îáùåé øèíû . . . . . . . . . . . . . 64
2.5.1. Îáùàÿ øèíà . . . . . . . . . . . . . . . . . . . . . . . . . 64
2.5.2. Ìîíòàæíîå È, ÈËÈ . . . . . . . . . . . . . . . . . . . . . 65
2.6. Àòðèáóòû îáúåêòîâ è êîíòðîëü çàïðåùåííûõ ñèòóàöèé . . . . . . . . . 66
2.6.1. Êîíòðîëü çàïðåùåííûõ ñèòóàöèé. . . . . . . . . . . . . . . . 66
2.6.2. Àòðèáóòû VHDL-ñèãíàëîâ . . . . . . . . . . . . . . . . . . . 66
Ãëàâà 3. Ñïîñîáû HDL-îïèñàíèé ïðîñòûõ óçëîâ . . . . . . . . . . . 69
3.1. Êîìáèíàöèîííàÿ ñõåìà F . . . . . . . . . . . . .
3.1.1. Îïèñàíèå èíòåðôåéñà . . . . . . . . . . . .
3.1.2. Ïðîöåññíàÿ ôîðìà îïèñàíèÿ ïîâåäåíèÿ . . . .
3.1.3. Ïîòîêîâîå îïèñàíèå ïîâåäåíèÿ . . . . . . .
3.1.4. Ñòðóêòóðíîå îïèñàíèå . . . . . . . . . . .
3.1.5. Îáúÿâëåíèå êîíôèãóðàöèè . . . . . . . . .
3.1.6. Êîíòðîëü âðåìåííûõ ñîîòíîøåíèé . . . . . .
3.1.7. VERILOG-îïèñàíèå, èñïîëüçóþùåå ïðèìèòèâû
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
69
70
71
74
75
76
77
3.2. Ñõåìû ñ ïàìÿòüþ . . . . . . . . . . . . . . . .
3.2.1. D-òðèããåð . . . . . . . . . . . . . . . .
3.2.2. D-òðèããåð ñî ñáðîñîì . . . . . . . . . . .
3.3.3. Ñõåìà D-òðèããåðà íà âåíòèëÿõ ÈÍÅ . . . .
3.2.4. D-òðèããåð êàê ïðèìèòèâ VERILOG . . . . .
3.2.5. Ìîäåëü RS-òðèããåðà-çàùåëêè . . . . . . .
3.2.6. Ìîäåëü Ò-òðèããåðà . . . . . . . . . . . .
3.2.7. VHDL — îïåðàòîð áëîêà â ìîäåëè òðèããåðà
òèïà «çàùåëêà» . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
78
78
79
79
80
80
81
.
.
.
.
.
.
.
. . . . . . . . . . 84
3.3. Ìîäåëü áëîêà cèíõðîííîé ïàìÿòè . . . . . . . . . . . . . . . . . . 84
3.3.1. VHDL-ìîäåëü. . . . . . . . . . . . . . . . . . . . . . . . . 84
3.3.2. VERILOG-ìîäåëü . . . . . . . . . . . . . . . . . . . . . . . 85
3.3.3. VERILOG — ìîäåëü ïàìÿòè c ó÷åòîì çàäåðæåê è êîíòðîëåì âðåìåíûõ ïàðàìåòðîâ ñèãíàëîâ â áëîêå specify . . . . . . . . . . . . . . . 86
3.3.4. VHDL — ìîäåëü ïàìÿòè ñ îáùèì ðåãèñòðîì âõîäíûõ-âûõîäíûõ äàíûõ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Ãëàâà 4. Ôóíêöèîíàëüíàÿ âåðèôèêàöèÿ HDL-îïèñàíèé . . . . . . . . 88
4.1. Ïðèìåð âåðèôèêàöèè îïèñàíèÿ ïðîñòîãî îáúåêòà ïðîåêòà F . . . . . . . 89
4.2. Ñòðàòåãèÿ ôóíêöèîíàëüíîé âåðèôèêàöèè . . . . . . . . . . . . . . . 93
4.2.1. Òèïû òåñòîâ . . . . . . . . . . . . . . . . . . . . . . . . . 93
4.2.2. Ïîëíîòà òåñòà . . . . . . . . . . . . . . . . . . . . . . . . 93
4.3. Îöåíêà ïîëíîòû ôóíêöèîíàëüíûõ òåñòîâ
4.3.1. Ýâðèñòè÷åñêèå ìåòðèêè . . . . .
4.3.2. Ïðîãðàììíûå ìåòðèêè . . . . .
4.3.3. Àâòîìàòíî-ìåòðè÷åñêèé ïîäõîä .
4.3.4. Ìîäåëèðîâàíèå íåèñïðàâíîñòåé .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
93
93
94
95
95
Ñîäåðæàíèå
309
4.3.5. Ìîíèòîðèíã ñîáûòèé è ïðîâåðêà êîíòðîëüíûõ
ñîîòíîøåíèé â ìîäåëè . . . . . . . . . . . . . . . . . . . . . . . 96
4.4. Êîìïîíåíòû òåñòèðóþùåé ïðîãðàììû . . .
4.4.1. Òàêòîâûé ãåíåðàòîð . . . . . . . . .
4.4.2. Ãåíåðàòîð ñèãíàëà ñáðîñà . . . . . .
4.4.3. Âõîäíûå âåêòîðû . . . . . . . . . .
4.4.4. Cðàâíåíèå âûõîäîâ ìîäåëè ñ ýòàëîíîì
. . . . . .
. . . . . .
. . . . . .
. . . . . .
(VERILOG)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
97
98
98
98
99
4.5. Áûñòðîäåéñòâèå è ðàñõîä ïàìÿòè èíñòðóìåíòàëüíîé ÝÂÌ . . . . . . . 100
4.5.1. Ðàñõîä ïàìÿòè. . . . . . . . . . . . . . . . . . . . . . . . 100
4.5.2. Áûñòðîäåéñòâèå òåñòèðóþùåé ïðîãðàììû . . . . . . . . . . . 100
4.6. Îòëàäêà òåñòèðóþùåé ïðîãðàììû . . . . . . . . . . . . . . . . . . 102
4.6.1. Ïîðÿäîê îòëàäêè . . . . . . . . . . . . . . . . . . . . . . 102
4.6.2. Îáùèå ðåêîìåíäàöèè . . . . . . . . . . . . . . . . . . . . 104
4.7. Àâòîìàòèçàöèÿ ïîñòðîåíèÿ òåñòèðóþùèõ ïðîãðàìì . . . . . . . . . . 104
4.8. Còðóêòóðèðîâàííûé òåñò îáúåêòà ïðîåêòà F . . . .
4.8.1. Ãåíåðàòîð ñèãíàëîâ GEN . . . . . . . . . .
4.8.2. Ðåãèñòðàòîð ñèãíàëîâ WRITER . . . . . . .
4.8.3. Àðõèòåêòóðà òåñòà — ñòðóêòóðíîå îïèñàíèå .
4.9. Ìîäåëüíûé ýêñïåðèìåíò c ñàìîïðîâåðêîé . .
4.9.1. VHDL-âàðèàíò. . . . . . . . . . . .
4.9.2. VERILOG-âàðèàíò . . . . . . . . . .
4.9.3. Ìîäåëüíûé ýêñïåðèìåíò ñî ñðàâíåíèåì
äâóõ ìîäåëåé F . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
106
106
107
108
. . . . . . . . . . . . 110
. . . . . . . . . . . . 110
. . . . . . . . . . . . 111
. . . . . . . . . . . . 112
4.10. VHDL-ìîäåëü è ïðîñòîé òåñò ìèêðîñõåìû ïàìÿòè . .
4.10.1. Ìèêðîñõåìà Ê134ÐÓ6. . . . . . . . . . . .
4.10.2. Îïèñàíèå èíòåðôåéñà ìèêðîñõåìû . . . . . .
4.10.3. Àðõèòåêòóðà îáúåêòà SK134RU6 . . . . . . .
4.10.4. Ìîäåëüíûé ýêñïåðèìåíò ñ ìèêðîñõåìîé ÎÇÓ .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
113
113
114
115
116
Ãëàâà 5. Cèíòåçàáåëüíîñòü HDL-îïèñàíèé . . . . . . . . . . . . . . 119
5.1. Îáùèå ïðèíöèïû ïîñòðîåíèÿ ñèíòåçàáåëüíûõ îïèñàíèé .
5.1.1. Ïîâòîðíîïðèãîäíîñòü ïðîåêòîâ . . . . . . . . .
5.1.2. Òâåðäûå è ìÿãêèå ìàêðîñû . . . . . . . . . . .
5.1.3. ×òî òàêîå «õîðîøèé ïðîåêò ìàêðîñà» . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
123
123
124
124
5.2. Ðåêîìåíäàöèè ïî ñòèëþ êîäèðîâàíèÿ HDL-îïèñàíèé . . .
5.2.1. Ðåêîìåíäàöèè îáùåãî ïëàíà . . . . . . . . . . .
5.2.2. Ðåêîìåíäóåìàÿ ñòðóêòóðà è ïðèìåðû èìåí ñèãíàëîâ
5.2.3. Îðãàíèçàöèÿ áàçû äàííûõ ïðîåêòà . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
125
125
126
127
5.3. ×òî òàêîå «õîðîøèå» ìîäóëè-ìàêðîñû . . . . . . . . . . . . . . . . 128
5.3.1. Oáùèå ðåêîìåíäàöèè . . . . . . . . . . . . . . . . . . . . 128
5.3.2. Äîïîëíèòåëüíûå çàìå÷àíèÿ. . . . . . . . . . . . . . . . . . 130
310
Ñîäåðæàíèå
5.4. RTL-îïèñàíèå . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
5.5. Ñèíòåçàáåëüíîå ïîäìíîæåñòâî HDL . . . . . . .
5.5.1. Îñíîâíûå ñèíòåçàáåëüíûå êîíñòðóêöèè . .
5.5.2. Ñèíòåçàáåëüíûå áèáëèîòåêè òèïîâûõ óçëîâ
5.5.3. Ñèíòåçàáåëüíûå îáðàçû óçëîâ . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
132
133
135
136
5.6. Ñèíòåçàáåëüíûå îïèñàíèÿ êîìáèíàöèîííûõ óçëîâ . . . . .
5.6.1. Ìóëüòèïëåêñîðû . . . . . . . . . . . . . . . . .
5.6.2. Äåøèôðàòîðû (äåìóëüòèïëåêñîðû) . . . . . . . . .
5.6.3. Òðèñòàáèëüíûé áóôåð-êëþ÷. . . . . . . . . . . . .
5.6.4. n-ðàçðÿäíûé êîìïàðàòîð . . . . . . . . . . . . . .
5.6.5. Òèïè÷íûå îøèáêè â îïèñàíèè êîìáèíàöèîííûõ óçëîâ
5.6.6. Ðåçóëüòàòû ñèíòåçà îäíîðàçðÿäíîãî ñóììàòîðà . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
137
137
140
142
142
143
146
5.7. Òðèããåðû è ðåãèñòðû . . . . . . . . . . . . .
Îáùàÿ ñòðóêòóðà îïèñàíèé . . . . . . . . .
5.7.1. D-òðèããåð-àñèíõðîííûé ñáðîñ-óñòàíîâêà .
5.7.2. Òðèããåð-ñèíõðîííûé ñáðîñ è óñòàíîâêà .
5.7.3. Ðåãèñòðû ñ ðàçðåøàþùèì âõîäîì . . . .
5.7.4. Çàùåëêè . . . . . . . . . . . . . . .
5.7.5. Ñäâèãàòåëè . . . . . . . . . . . . . .
5.7.6. C÷åò÷èêè . . . . . . . . . . . . . . .
5.7.7. Ðåãèñòðîâûå ôàéëû è áëîêè ïàìÿòè . . .
5.7.8. Òèïè÷íûå îøèáêè â îïèñàíèÿõ òðèããåðîâ
5.7.9. Ïðèìåð ñèíòåçà c÷åò÷èêà . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
151
151
153
153
154
155
155
155
156
157
158
5.8. HDL-îïèñàíèÿ àâòîìàòîâ . . . . . . . . . . . . . . . . . . . . .
5.8.1. Àâòîìàòû Ìèëè è Ìóðà . . . . . . . . . . . . . . . . . .
5.8.2. VERILOG — îïèñàíèå è òåñò àâòîìàòà óïðàâëåíèÿ ñâåòîôîðîì
5.8.3. VHDL-îïèñàíèå è òåñò àâòîìàòà óïðàâëåíèÿ ñâåòîôîðîì . . .
5.8.4. Ñèíòåç VERILOG-îïèñàíèÿ àâòîìàòà óïðàâëåíèÿ
ñâåòîôîðîì . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
162
162
162
164
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
è ðåãèñòðîâ
. . . . . .
. 166
Ãëàâà 6. Ðåàëèçàöèÿ øèôðîàëãîðèòìà RC4 íà ÏËÈÑ. . . . . . . . . 174
6.1. Øèôðîàëãîðèòì RC4. . . . . . . . . . . . . . . . . . . . . . . . 174
6.2. HDL-ñïåöèôèêàöèÿ àëãîðèòìà RC4 . . . . . . . . . . . . . . . . . 176
6.2.1. Verilog . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
6.2.2. VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
6.3. ÏËÈÑ ñåìåéñòâà Virtex . . . . . . . . . . . . . . . . . . . . . . 181
6.3.1. Âîçìîæíîñòè . . . . . . . . . . . . . . . . . . . . . . . . 181
6.3.2. Àðõèòåêòóðà ñåìåéñòâà Virtex . . . . . . . . . . . . . . . . 182
6.4. VHDL-âàðèàíò ðåàëèçàöèè àâòîìàòà RC4. . . . . . . . . . . . . . . 186
6.4.1. Áëîê ïàìÿòè . . . . . . . . . . . . . . . . . . . . . . . . 186
6.4.2. Ðàñïðåäåëåíèå ìèêðîîïåðàöèé
àëãîðèòìà ïî òàêòàì. . . . . . . . . . . . . . . . . . . . . . . . 187
Ñîäåðæàíèå
6.4.3.
6.4.4.
6.4.5.
6.4.6.
311
VHDL-oïèñàíèå àâòîìàòà RC4 . . . . . . . . . . .
VHDL-òåñò àâòîìàòà RC4. . . . . . . . . . . . . .
Ðåçóëüòàòû ñèíòåçà c ïàìÿòüþ íà òðèããåðàõ . . . . .
Ðåçóëüòàòû ñèíòåçà c èñïîëüçîâàíèåì áëî÷íîé ïàìÿòè
6.5. VERILOG-îïèñàíèå àâòîìàòà RC4 .
6.5.1. Îïèñàíèå àâòîìàòà . . . .
6.5.2. Òåñò . . . . . . . . . . .
6.5.3. Peçóëüòàòû ñèíòåçà . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
188
193
195
198
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
200
200
203
204
Ãëàâà 7. Ôóíêöèîíàëüíàÿ ìîäåëü ìèêðîñõåìû äâóõïîðòîâîé
ñèíõðîííîé ïàìÿòè . . . . . . . . . . . . . . . . . . . . . . . . . 206
7.1. Cîñòîÿíèå âîïðîñà. . . . . . . . . . . . . . . . . . . . . . . . . 206
7.2. Íåêîòîðûå ñâîéñòâà ìîäåëåé RAM . . . . . . . . . . . . . . . . . 208
7.3. Äâóõïîðòîâàÿ ñèíõðîííàÿ ïàìÿòü . . . . . . . . . . . . . . . . . . 211
7.4. VHDL-ìîäåëü áëîêà ïàìÿòè. . . . . . . . . . . .
7.4.1. Èíòåðôåéñ . . . . . . . . . . . . . . . .
7.4.2. Àðõèòåêòóðà . . . . . . . . . . . . . . .
7.4.3. Ïàêåò ñî çíà÷åíèÿìè âðåìåííûõ ïàðàìåòðîâ .
7.4.4. Ìîäóëü êîíòðîëÿ âðåìåííûõ ïàðàìåòðîâ . .
7.4.5. Ïàêåò ôóíêöèé ïðåîáðàçîâàíèÿ òèïîâ äàííûõ
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
215
215
216
223
224
228
7.5. VERILOG-ìîäåëü áëîêà ïàìÿòè . . .
7.5.1. Èíòåðôåéñ ìèêðîñõåìû . . .
7.5.2. Òåëî ìîäóëÿ. . . . . . . . .
7.5.3. Çàäàíèå è êîíòðîëü âðåìåííûõ
7.5.4. Ôóíêöèîíàëüíàÿ ÷àñòü . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
232
232
233
234
235
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
239
239
241
245
251
. . . . . .
. . . . . .
. . . . . .
ïàðàìåòðîâ
. . . . . .
7.6. Òåñòèðóþùàÿ ïðîãðàììà . . . . . . . . .
7.6.1. Ïåðåìåííûå è êîíñòàíòû. . . . . .
7.6.2. Ïðîöåäóðû ÇÀÏÈÑÈ-×ÒÅÍÈß . . .
7.6.3. Ïîäà÷à òåñòîâûõ âåêòîðîâ . . . . .
7.6.4. Âðåìåííûå ïàðàìåòðû ñèãíàëîâ òåñòà
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ïðèëîæåíèå 1. Êðàòêèé ñïðàâî÷íèê ïî ÿçûêó VHDL . . . . . . . . . 253
1. Îñíîâû VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
2. Îñíîâíûå ðàçëè÷èÿ âåðñèé VHDL-93 è VHDL-87 . . . . . . . . . . . . 264
3. Cèíòåçàáåëüíîå ïîäìíîæåñòâî ÿçûêà VHDL . . . . . . . . . . . . . . 267
4.Ïðåäîïðåäåëåííîå îêðóæåíèå ÿçûêà VHDL.
4.1. Ïàêåò STANDARD . . . . . . . .
4.2. Ïàêåò TEXTIO . . . . . . . . . .
4.3. Ïðåäîïðåäåëåííûå àòðèáóòû . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
268
268
270
271
5. Ìíîãîçíà÷íàÿ ëîãèêà — IEEE ïàêåòû è ôóíêöèè ïðåîáðàçîâàíèÿ òèïîâ. . 272
1. Ïàêåò IEEE STD_LOGIC_1164 . . . . . . . . . . . . . . . . . . 272
312
Ñîäåðæàíèå
2.
3.
4.
5.
Ïàêåò
Ïàêåò
Ïàêåò
Ïàêåò
IEEE NUMERIC_STD . . . .
IEEE NUMERIC_BIT . . . .
Synopsys STD_LOGIC_ARITH
STD_LOGIC_UNSIGNED . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ïðèëîæåíèå 2. VERILOG — êðàòêèé ñïðàâî÷íèê
1. Ëåêñè÷åñêèå ýëåìåíòû. . . . . .
1.1. Ñèìâîëû . . . . . . . . .
1.2. Êîììåíòàðèè è àòòðèáóòû .
1.3. Ñèìâîëû îïåðàöèé è ñêîáîê
1.4. Èìåíà . . . . . . . . . .
1.5. Ëîãè÷åñêèå çíà÷åíèÿ . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
273
274
275
275
. . . . . . . . . . 276
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
276
276
276
276
277
279
2. Ëèòåðàëû . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
2.1. Öåëûå . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
2.2. Âåùåñòâåííûå (ðåàëüíûå — real) ëèòåðàëû . . . . . . . . . . . 280
3. Òèïû è âèäû äàííûõ . . . . . . . .
3.1. Âèä ïåðåìåííàÿ . . . . . . .
3.2. Âèä ñîåäèíåíèå (öåïü, ñâÿçü).
3.3. Äðóãèå âèäû è òèïû äàííûõ .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
280
280
281
281
4. Îáúÿâëåíèå äàííûõ è îáëàñòü âèäèìîñòè . . . . . . . . . . . . . . . 282
4.1. Îáüÿâëåíèå äàííûõ . . . . . . . . . . . . . . . . . . . . . . 282
4.2. Îáëàñòü âèäèìîñòè îáüÿâëåíèé äàííûõ . . . . . . . . . . . . . 283
5. Îïåðàöèè . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
6. Âûðàæåíèÿ . . . . . . . . . . . . .
6.1. Îáû÷íûå âûðàæåíèÿ . . . . .
6.2. Âûðàæåíèÿ ñ ïîëÿìè âåêòîðîâ è
6.3. Çàäåðæàííûå âûðàæåíèÿ . . .
6.4. Óñëîâíûå âûðàæåíèÿ . . . . .
6.5. Âûäåëåíèå ðàçðÿäîâ è ïîëåé . .
6.6. Âûäåëåíèå ýëåìåíòîâ ìàññèâîâ.
. . . . .
. . . . .
ìàññèâîâ
. . . . .
. . . . .
. . . . .
. . . . .
7. Ïîñëåäîâàòåëüíûå îïåðàòîðû (ïðîöåäóðíûå).
7.1. Îïåðàòîð îæèäàíèÿ (çàäåðæêè) . . .
7.2. Îïåðàòîð ïðèñâàèâàíèÿ ïåðåìåííîé .
7.3. Óñëîâíûé îïåðàòîð . . . . . . . . .
7.4. Îïåðàòîð âûáîðà . . . . . . . . . .
7.5. Îïåðàòîð öèêëà . . . . . . . . . . .
7.6. Îïåðàòîð âûõîäà èç ãðóïïû . . . . .
7.7. Ïðèìåðû ïîñëåäîâàòåëüíûõ îïåðàòîðîâ
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
286
286
286
286
286
286
286
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
287
287
287
287
287
288
288
288
8. Ïðîöåäóðíûå áëîêè . . . . . . . . . . . . . . . . . . . . . . . . . 289
9. Ãðóïïû îïåðàòîðîâ . . . . . . . . . . . . . . . . . . . . . . . . . 290
10. Ïðîöåäóðû è ôóíêöèè . . . . . . . . . . . . . . . . . . . . . . . 290
Ñîäåðæàíèå
313
10.1. Ïðîöåäóðû task . . . . . . . . . . . . . . . . . . . . . . . 290
10.2. Ôóíêöèè function . . . . . . . . . . . . . . . . . . . . . . 291
11. Ïàðàëëåëüíûå îïåðàòîðû è áëîêè . . . . . . . . . . . . . . . . . . 291
12. Ìîäóëü ïðîåêòà . . . . . . . . . . . . . . . . . . . . . . . . . . 292
12.1. Ñòèëü îïèñàíèÿ VERILOG-95 . . . . . . . . . . . . . . . . . 292
12.2. Còèëü VERILOG-2000 (ANSI-C) . . . . . . . . . . . . . . . . 292
13. Êîíêðåòèçàöèÿ — âûçîâ ýêçåìïëÿðîâ ìîäóëåé . . . . . . . . . . . . 293
13.1. VERILOG-95 . . . . . . . . . . . . . . . . . . . . . . . . . 293
13.2. VERILOG-2000 . . . . . . . . . . . . . . . . . . . . . . . . 293
14. Ñèñòåìíûå îïåðàòîðû è ôóíêöèè . . . . . . . . . . . . . . . . . . 294
14.1. Ôîðìàòèðóåìûé ââîä-âûâîä . . . . . . . . . . . . . . . . . . 294
14.2. Ðàáîòà ñ ôàéëàìè . . . . . . . . . . . . . . . . . . . . . . 295
15. Áëîê ñïåöèôèêàöèé âðåìåííûõ ñîîòíîøåíèé-specify
(íåñèíòåçàáåëüíàÿ êîíñòðóêöèÿ) . . . . . . . . . . .
15.1. Îáüÿâëåíèå ñïåöïàðàìåòðîâ. . . . . . . . .
15.2. Ñðåäñòâà ïðîâåðêè âðåìåííûõ ñîîòíîøåíèé .
15.3. Çàäåðæêè ïóòåé ðàñïðîñòðàíåíèÿ ñèãíàëîâ . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
296
296
296
297
16. Ñèíòåçàáåëüíûå êîíñòðóêöèè . . . . . . . . . . . . . . . . . . . . 298
17. Äèðåêòèâû êîìïèëÿöèè (ïåðå÷èñëåíû òîëüêî îñíîâíûå) . . . . . . . . 299
Èñïîëüçóåìûå ñîêðàùåíèÿ . . . . . . . . . . . . . . . . . . . . . 302
Èíòåðíåò-ðåñóðñû . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Ñïèñîê ëèòåðàòóðû . . . . . . . . . . . . . . . . . . . . . . . . . 305
Ãëàâà 1
HDL — âçãëÿä ñõåìîòåõíèêà è âçãëÿä
ïðîãðàììèñòà
1.1. HDL — âçãëÿä ðàçðàáîò÷èêà àïïàðàòóðû
1.1.1. Îòîáðàæàåìûå àñïåêòû
 HDL-îïèñàíèè, êàê è â ëþáîé ìîäåëè, îòðàæàþòñÿ òîëüêî íåêîòîðûå àñïåêòû (õàðàêòåðèñòèêè) ðåàëüíîé ñèñòåìû.
Öèôðîâóþ àïïàðàòóðó õàðàêòåðèçóþò, íàïðèìåð, òàêèå àñïåêòû, êàê ôóíêöèîíàëüíûé (ðåàëèçóåìàÿ ôóíêöèÿ, àëãîðèòì); âðåìåííîé (çàäåðæêè, ïðîèçâîäèòåëüíîñòü, âðåìÿ îòêëèêà); ñòðóêòóðíûé (òèïû è ñâÿçè êîìïîíåíò); ðåñóðñíûé (÷èñëî âåíòèëåé, ïëîùàäü êðèñòàëëà); íàäåæíîñòíûé (âðåìÿ íàðàáîòêè íà îòêàç);
êîíñòðóêòèâíûé (âåñ, ãàáàðèòû); ñòîèìîñòíîé è ò. ä.
HDL ñîäåðæèò ñðåäñòâà, ïîçâîëÿþùèå îòîáðàçèòü â îñíîâíîì ïåðâûå òðè àñïåêòà: ôóíêöèîíàëüíûé, âðåìåííîé è ñòðóêòóðíûé (ðèñ. 1.1).
Êàê óæå îòìå÷àëîñü, ôóíêöèÿ (ïîâåäåíèå) àïïàðàòóðû ìîæåò äåòàëèçèðîâàòüñÿ
îò óðîâíÿ ñèñòåìû êîìàíä è àëãîðèòìîâ óñòðîéñòâ äî áóëåâñêèõ ôóíêöèé; ñòðóêòóðà — îò óðîâíÿ óñòðîéñòâ òèïà ïðîöåññîð — ïàìÿòü äî óðîâíÿ âåíòèëåé è ïåðåêëþ÷àþùèõ ýëåìåíòîâ; âðåìÿ — îò çàäåðæåê ôðîíòîâ ñèãíàëîâ (íàíî — ns è ôåìòîñåêóíäû — fs) äî òàêòîâ è çàäåðæåê ýëåêòðîìåõàíè÷åñêèõ óñòðîéñòâ (ñåêóíäû è ÷àñû).
Ñòåïåíü äåòàëèçàöèè àñïåêòîâ, îòîáðàæàåìûõ â îïèñàíèÿõ àïïàðàòóðû, îïðåäåëÿåòñÿ êîíêðåòíûìè çàäà÷àìè. Íàïðèìåð, îïèñàíèå íåêîòîðîé ìèêðîïðîöåññîðíîé ñèñòåìû ìîæåò ñòðîèòüñÿ êàê îïèñàíèå ñòðóêòóðû, ñîñòîÿùåé èç ìèêðîñõåì ÁÈÑ è ÑÈÑ, à îïèñàíèå ñàìèõ ìèêðîñõåì ñòðîèòñÿ êàê ïîâåäåí÷åñêîå, åñëè
èõ îïèñàíèå íà âåíòèëüíîì óðîâíå ëèáî îòñóòñòâóåò, ëèáî ñëèøêîì ãðîìîçäêî.
 HDL âñòðîåí ðÿä ïîíÿòèé, îáû÷íî èñïîëüçóåìûõ ïðîåêòèðîâùèêàìè àïïàðàòóðû. Íèæå ïðè èçëîæåíèè ýòèõ ïîíÿòèé â ñêîáêàõ ïðèâîäÿòñÿ àíãëèéñêèå òåðìèíû, èñïîëüçóåìûå â HDL êàê êëþ÷åâûå, çàðåçåðâèðîâàííûå ñëîâà.
Ðèñ. 1.1. Âîçìîæíîñòè HDL â îáëàñòè îòîáðàæåíèÿ îñíîâíûõ õàðàêòåðèñòèê (ñòðóêòóðíûé, âðåìåííîé, ôóíêöèîíàëüíûé àñïåêò) àïïàðàòóðû
16
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
1.1.2. Èíòåðôåéñ îáúåêòà ïðîåêòà
Ïîëíîå HDL-îïèñàíèå êàæäîãî îáúåêòà ïðîåêòà (â äàëüíåéøåì äëÿ êðàòêîñòè — îáúåêòà — entity, ìîäóëÿ — module) ñîñòîèò èç äâóõ ÷àñòåé: îïèñàíèÿ èíòåðôåéñà îáúåêòà è îïèñàíèÿ òåëà îáúåêòà (îïèñàíèå àðõèòåêòóðû — architecture â
òåðìèíîëîãèè VHDL).
Èíòåðôåéñ îáúåêòà ïðîåêòà (module, entity) îïðåäåëÿåò åãî èìÿ, âõîäû-âûõîäû è ïàðàìåòðû. Âõîäû-âûõîäû — ýòî ñîñòàâ ïîðòîâ (port), èõ èìåíà, íàïðàâëåííîñòü (âõîäû — in, input, âûõîäû — out, output, äâóíàïðàâëåííûå — inout), ðàçðÿäíîñòü (îäèí áèò — bit èëè âåêòîð — bit_vector), aëôàâèò êîäèðîâàíèÿ (0, 1 —
îäèí èç ñòàíäàðòîâ äëÿ VHDL èëè 0, 1, Z, X — ñòàíäàðò äëÿ VERILOG) ñèãíàëîâ,
ñïîñîá ïðåäñòàâëåíèÿ èõ çíà÷åíèé (öåëûé — integer, âåùåñòâåííûé — real) è ò. ä.
Íàïðèìåð, ó îáúåêòà ïðîåêòà ïî èìåíè SM (ðèñ. 1.2) òðè âõîäíûõ (input, in)
ïîðòà: A, B, C è îäèí âûõîä (output, out): S, íà êîòîðûå ìîãóò ïîñòóïàòü ñèãíàëû,
èìåþùèå äâîè÷íûå (bit) çíà÷åíèÿ 0 èëè 1.
Ðèñ. 1.2. Èíòåðôåéñ îáúåêòà ïðîåêòà SM
Îäíîòèïíûå îáúåêòû ïðîåêòà ìîãóò ðàçëè÷àòüñÿ ïàðàìåòðàìè íàñòðîéêè (generic, parameter), íàðèìåð ðàçðÿäíîñòüþ èëè çàäåðæêîé. TZ — ïàðàìåòð, õàðàêòåðèçóþùèé çàäåðæêó SM.
Íèæå ïðèâåäåíû HDL-îïèñàíèÿ èíòåðôåéñà îáúåêòà ïðîåêòà SM.
VHDL
entity SM is
generic(TZ: time:=0 ns);
port (A, B, C: in bit;
S: out bit);
end SM;
VERILOG
`timescale 1 ns/100 ps
module SM (A, B, C, S);
parameter TZ=0;
input A, B, C;
output S;
Ïîñëåäíÿÿ âåðñèÿ ÿçûêà VERILOG (VERILOG-2000) ïîçâîëÿåò îïèñûâàòü
ïîðòû îáúåêòà ïðîåêòà â ôîðìå, áîëåå áëèçêîé ê ïðèíÿòîé â ÿçûêå VHDL.
module SM (input wire A,B,C, output wire S);
Ïîðòû îáúåêòà ïðîåêòà, êàê óæå îòìå÷àëîñü, õàðàêòåðèçóþòñÿ íàïðàâëåíèåì
ïîòîêà èíôîðìàöèè.
Îíè ìîãóò áûòü âõîäíûìè (â VHDL çàðåçåðâèðîâàííîå ñëîâî in, â VERILOG — input), âûõîäíûìè (VHDL — out, VERILOG — output), äâóíàïðàâëåííûìè (inout). Êðîìå òîãî, â VHDL ìîãóò áûòü îäíîíàïðàâëåííûìè áóôåðíûìè (buffer) (ñ ïîðòà òèïà buffer âûõîäíîé ñèãíàë îáúåêòà ìîæíî ñ÷èòûâàòü â òîì æå îáúåêòå, ÷òî íåëüçÿ äåëàòü ñ ïîðòîì òèïà out) è ñâÿçíûìè — linkage.
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
17
Ïîðòû òàêæå èìåþò òèï, õàðàêòåðèçóþùèé òèï çíà÷åíèÿ ïîñòóïàþùèõ íà
íèõ ñèãíàëîâ.
 VHDL — ýòî, íàïðèìåð, ñòàíäàðòíûé (âñòðîåííûé) òèï bit èëè n-áèòîâûé âåêòîð — bit_vector, — êàæäûé ðàçðÿä êîòîðîãî äâóçíà÷íûé (ïðèíèìàåò çíà÷åíèå 0 èëè 1).
 VERILOG — ýòî îáû÷íî îäíîðàçðÿäíûé èëè n-áèòîâûé âåêòîð, ðàçðÿä êîòîðîãî èìååò ÷åòûðåõçíà÷íûé òèï (ïî óìîë÷àíèþ) ñî çíà÷åíèÿìè 0, 1, z — âûñîêèé èìïåäàíñ, x — íåîïðåäåëåííî. Ïîäðîáíåå îá àëôàâèòå ïðåäñòàâëåíèÿ ñèãíàëîâ ñìîòðèòå íèæå è â ãëàâå 2.
1.1.3. Îïèñàíèå ñòðóêòóðû îáúåêòà ïðîåêòà
Òåëî îáúåêòà ïðîåêòà ñïåöèôèöèðóåò åãî ñòðóêòóðó è ôóíêöèþ (ïîâåäåíèå,
àëãîðèòì). Åãî îïèñàíèå â HDL VERILOG ñëåäóåò çà îïèñàíèåì èíòåðôåéñà ìîäóëÿ, à â ÿçûêå VHDL âûäåëÿåòñÿ â îòäåëüíóþ ÷àñòü è ñîäåðæèòñÿ â îïèñàíèè àðõèòåêòóðû îáúåêòà (architecture) (ðèñ. 1.3).
Ðèñ. 1.3. Ïðèìåð ñîîòâåòñòâèÿ ìíîæåñòâà àðõèòåêòóð îäíîìó èíòåðôåéñó â VHDL
Åñëè ïðîåêòèðîâùèê ïðåäñòàâèë ôóíêöèþ óñòðîéñòâà êàê ñõåìó (ñòðóêòóðó)
èç ýëåìåíòîâ íèçøåãî óðîâíÿ ñëîæíîñòè, òî HDL äëÿ íåãî â ïåðâîì ïðèáëèæåíèè ýòî ôîðìà êîäèðîâàíèÿ ñõåì.
Ñðåäñòâà HDL äëÿ îòîáðàæåíèÿ ñòðóêòóð öèôðîâûõ ñèñòåì áàçèðóþòñÿ íà
ïðåäñòàâëåíèè î òîì, ÷òî îïèñûâàåìûé îáúåêò ïðîåêòà (entity, module) ïðåäñòàâëÿåò
ñîáîé ñòðóêòóðó èç áîëåå ïðîñòûõ îáúåêòîâ-êîìïîíåíòîâ (component), ñîåäèíÿåìûõ
äðóã ñ äðóãîì ëèíèÿìè ñâÿçè (ïðîâîäàìè — wire (VERILOG) èëè ñèãíàëàìè — signal
(VHDL). Êàæäûé êîìïîíåíò, â ñâîþ î÷åðåäü, ÿâëÿåòñÿ îáúåêòîì è ìîæåò ñîñòîÿòü
èç êîìïîíåíò íèçøåãî óðîâíÿ (èåðàðõèÿ îáúåêòîâ). Âçàèìîäåéñòâóþò îáúåêòû ïóòåì ïåðåäà÷è ñèãíàëîâ (signal) ïî ëèíèÿì ñâÿçè. Ëèíèè ñâÿçè (wire — â VERILOG)
èëè îòîæäåñòâëÿåìûå ñ íèìè ñèãíàëû (signal — â VHDL) ïîäêëþ÷àþòñÿ ê âõîäíûì
(in, input) è âûõîäíûì (out, output) ïîðòàì (port) ñâÿçûâàåìûõ êîìïîíåíòîâ.
Íàïðèìåð, êîìïîíåíò Ì2 (ðèñ. 1.4) îáúåêòà SM èìååò äâà âõîäíûõ ïîðòà —
Õ1, Õ2 è îäèí âûõîäíîé — Y.
Ýêçåìïëÿðû îäíîòèïíûõ êîìïîíåíò, êàê óæå îòìå÷àëîñü, ìîãóò ðàçëè÷àòüñÿ
ïàðàìåòðàìè íàñòðîéêè (generic â VHDL, parameter â VERILOG), íàïðèìåð çàäåðæêîé ñèãíàëîâ.
Íà ðèñ. 1.4 ïðåäñòàâëåíà ñòðóêòóðà îáúåêòà ïðîåêòà SM, ñîñòîÿùåãî èç äâóõ ýêçåìïëÿðîâ êîìïîíåíòîâ òèïà Ì2, ñ èìåíàìè ýêçåìïëÿðîâ Ê1 è Ê2 è çàäåðæêàìè
15 ns è 10 ns.
18
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Ðèñ. 1.4. Ñòðóêòóðíûé àñïåêò îáúåêòà ïðîåêòà SM, ñîñòîÿùåãî èç äâóõ ýêçåìïëÿðîâ
êîìïîíåíòîâ òèïà Ì2 (ñõåìà îáúåêòà SM)
 HDL-îïèñàíèè ñõåìû èìåíà âõîäíûõ ñèãíàëîâ (ïîðòîâ) îáúåêòà ïðîåêòà
SM è èìåíà èäóùèõ îò íèõ ëèíèé ñâÿçè ñîâïàäàþò (îíè îòîæäåñòâëÿþòñÿ). Äëÿ
âíóòðåííèõ ñèãíàëîâ (ëèíèé ñâÿçè, öåïåé ñîåäèíåíèé), ñâÿçûâàþùèõ êîìïîíåíòû äðóã ñ äðóãîì, íåîáõîäèìî ââîäèòü èíäèâèäóàëüíûå èìåíà. Íàïðèìåð, ëèíèÿ
S_TMP (ñèãíàë S_TMP íà ðèñ. 1.4) îáúåäèíÿåò êîìïîíåíòû Ê1 è Ê2.
Ñòðóêòóðíîå îïèñàíèå îáúåêòà ïðîåêòà SM ñòðîèòñÿ êàê îïèñàíèå ñâÿçåé ýêçåìïëÿðîâ (êîíêðåòèçàöèé — instance) êîìïîíåíòîâ, êàæäûé èç êîòîðûõ èìååò
ïåðñîíàëüíîå èìÿ (èìÿ êîíêðåòèçàöèè), òèï, çíà÷åíèå ïàðàìåòðîâ è ñâÿçè ñ âõîäíûìè è âûõîäíûìè ñèãíàëàìè (ñïèñîê êîíêðåòèçàöèè).
 ïðîñòûõ ñëó÷àÿõ èñïîëüçóåòñÿ ïîçèöèîííûé ïðèíöèï ñîïîñòàâëåíèÿ ïîðòîâ êîìïîíåíòîâ ïîñòóïàþùèì íà íèõ ñèãíàëàì (ïîçèöèîííàÿ êàðòà ïîðòîâ — port map).
Òî åñòü ïåðâûé ñèãíàë â êàðòå ïîðòîâ (ñïèñêå êîíêðåòèçàöèè) ñîïîñòàâëÿåòñÿ
ïåðâîìó ïîðòó êîìïîíåíòà, âòîðîé — âòîðîìó è ò. ï. (ñìîòðè ïðèìåð êîíêðåòèçàöèè Ê1).
 ñëîæíûõ ñëó÷àÿõ ïðè áîëüøîì êîëè÷åñòâå ïîðòîâ êîìïîíåíòîâ è ïðîèçâîëüíîì
ïîðÿäêå èõ ïåðå÷èñëåíèÿ â êàðòå ïîðòîâ èñïîëüçóåòñÿ êëþ÷åâîé ïðèíöèï (ÿâíûé —
explicit): ñïèñîê êîíêðåòèçàöèè îáðàçóþò ïàðû èìÿ ïîðòà êîìïîíåíòà — èìÿ ïîäñîåäèíåííîãî ê íåìó ñèãíàëà (ñìîòðè ïðèìåð êîíêðåòèçàöèè Ê2).
Íàïðèìåð, îïèñàíèå ñâÿçåé êîìïîíåíòîâ îáúåêòà ïðîåêòà SM, ïðåäñòàâëåííîãî íà ðèñ. 1.4, âûãëÿäèò ñëåäóþùèì îáðàçîì (ïîñëå ñèìâîëîâ -- â VHDL è // â
VERILOG è äî êîíöà ñòðîêè ñëåäóåò êîììåíòàðèé):
--VHDL
architecture STRUCTURA of SM is
signal S_TMP: bit;-- ïðîìåæóòî÷íûé
begin -- äëÿ Ê1 ïîçèöèîííîå
Ê1: entity M2 generic map (15 ns)
port map (A, B, S_TMP);
-- äëÿ Ê2 - êëþ÷åâîå
-- ñîîòâåòñòâèå
K2: entity M2 port map
(X1=>S_TMP,
Y=> S,
X2=> C);
end STRUCTURA;
VERILOG
// îïèñàíèå èíòåðôåéñà SM áûëî
// âûøå
wire S_TMP;//ïðîìåæóòî÷íûé
//äëÿ Ê1 ïîçèöèîííîå ñîîòâåòñòâèå
M2 #(15)
K1 (A,B,S_TMP);
//äëÿ Ê2 - êëþ÷åâîå
//ñîîòâåòñòâèå è ïîðÿäîê ïàð
//ïîðò-ñèãíàë ïðîèçâîëüíûé
M2 K2 (.X1(S_TMP),
.Y(S),
.X2(C));
endmodule //SM
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
19
Êàê óæå îòìå÷àëîñü, â îïèñàíèè ñâÿçåé êîìïîíåíòîâ îáúåêòà ïðîåêòà SM èñïîëüçîâàíû ñëåäóþùèå îáîçíà÷åíèÿ:
— K1, K2 — èìåíà ýêçåìïëÿðîâ êîìïîíåíòà Ì2;
— M2 — òèï êîìïîíåíòà;
— 15 ns çàäåðæêà äëÿ êîíêðåòèçàöèè Ê1; êîíêðåòèçàöèÿ Ê2 èìååò çàäåðæêó
10 ns ïî óìîë÷àíèþ, VERILOG — îïèñàíèå SM ïðåäïîëàãàåò ìàñøòàá âðåìåíè 1
ns (timescale — ñì. íèæå òàêæå îïèñàíèå îáúåêòà ïðîåêòà Ì2) c òî÷íîñòüþ 100 ps;
— A, B, C, S — èìåíà âíåøíèõ ñèãíàëîâ, ñâÿçàííûõ ñ ïîðòàìè;
— S_TMP — èìÿ ïðîìåæóòî÷íîãî ñèãíàëà.
Åñëè êàêîé-òî ïîðò íå ñîåäèíåí ñ ñèãíàëîì, â VHDL ýòî îáîçíà÷àåòñÿ êëþ÷åâûì ñëîâîì open, â VERILOG — ïðè ïîçèöèîííîì ñïîñîáå ýòî ìåñòî îáîçíà÷àåòñÿ çàïÿòîé.
Êëþ÷åâîé ñïîñîá ìîæåò ïðèìåíÿòüñÿ è ïðè óêàçàíèè ôàêòè÷åñêèõ çíà÷åíèé
ïàðàìåòðîâ íàñòðîéêè.
 íàøåì ñëó÷àå äëÿ êîíêðåòèçàöèè Ê1 ïðè íåçàäåéñòâîâàííîì ïîðòå X2 è
êëþ÷åâîì ñïîñîáå óêàçàíèÿ çíà÷åíèÿ ïàðàìåòðà íàñòðîéêè TDEL ìû èìåëè áû:
VHDL
K1: entity M2
generic map(TDEL=>15 ns);
port map (A, open, S_TMP);
VERILOG
M2 K1 (A, ,S_TMP);
defparam K1.TDEL= 15;
VERILOG-2000 äîïóñêàåò áîëåå ïîõîæóþ íà VHDL ôîðìó ïåðåäà÷è ïàðàìåòðîâ íàñòðîéêè : Ì2 #(.TDEL(15)) K1(A, ,S_TMP);
1.1.4. Ñâÿçü èìåí êîìïîíåíòîâ è îáúåêòà ïðîåêòà
Îñòàåòñÿ âîïðîñ î ñâÿçûâàíèè èìåíè êîìïîíåíòà ñ èìåíåì ñîîòâåòñòâóþùåãî
îáúåêòà ïðîåêòà. VERILOG ïðåäïîëàãàåò ïîëíîå ñîîòâåòñòâèå ýòèõ èìåí. VHDL
áîëåå ãèáîê, äîïóñêàÿ ðàçëè÷èå èìåíè êîìïîíåíòà è èìåíè ñîîòâåòñòâóþùåãî îáúåêòà ïðîåêòà. Ïðè ñîâïàäåíèè èìåí êîìïîíåíòà è îáúåêòà ïðîåêòà ìîæíî ïðèìåíÿòü ïðÿìîå ñîçäàíèå ýêçåìïëÿðà êîìïîíåíòà, êàê ýòî áûëî ñäåëàíî âûøå. Ìîæíî
òàêæå îáúÿâèòü VHDL-êîìïîíåíò è èñïîëüçîâàòü ñâÿçûâàíèå ïî óìîë÷àíèþ, êîãäà
ñèñòåìà èùåò â ðàáî÷åé áèáëèîòåêå ïðîåêòà ïîñëåäíåå èç îòêîìïèëèðîâàííûõ
îïèñàíèé îáúåêòîâ ñ òàêèì æå èìåíåì. Ñâÿçûâàíèå (êîíôèãóðèðîâàíèå — ñonfiguration) ýòèõ èìåí îñóùåñòâëÿåòñÿ ëèáî òàê íàçûâàåìûì îáúÿâëåíèåì êîíôèãóðàöèè
ëèáî ñïåöèôèêàöèåé êîíôèãóðàöèè. B íàøåì VHDL-ïðèìåðå èñïîëüçîâàíèå îïèñàíèÿ êîìïîíåíòà è ñïåöèôèêàöèÿ êîíôèãóðàöèè âûãëÿäåëè áû òàê:
architecture STRUCTURA_COMP of SM is
signal S_TMP;--ïðîìåæóòî÷íûé
component M2
-- êîìïîíåíò M2
-- â VERILOG ðàçäåë îïèñàíèé
generic TDEL=10 ns;-- çàäåðæêà
-- êîìïîíåíò îòñóòñòâóåò, íî
port(X1,X2:in bit; -- âõîäû
-- ãäå-òî âîâíå â áèáëèîòåêå
-- ïðîåêòà äîëæíî áûòü
Y :out bit);
-- îïèñàíèå ñîîòâåòñòâóþùèõ
end component M2;
-- îáúåêòîâ ñ òàêèìè æå èìåíàìè
for all:M2 use entity work.M2(BEH);
-- ñïåöèôèêàöèÿ êîíôèãóðàöèè
begin
-- äëÿ íàøåãî VHDL ïðèìåðà èçëèøíÿÿ
-- ìîæíî áûëî èñïîëüçîâàòü ñâÿçûâàíèå ïî óìîë÷àíèþ
20
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Ê1: M2 generic map (15 ns) port map (A, B, S_TMP);
K2: M2 port map (S_TMP, C,S);
end STRUCTURA_COMP;
 âåðñèþ VERILOG-2000 âêëþ÷åí ïîäîáíûé ìåõàíèçì, òàê íàçûâàåìûé áëîê
êîíôèãóðàöèè. Èñïîëüçîâàíèå ýòîé êîíñòðóêöèè ïîçâîëÿåò çàôèêñèðîâàòü â êîäå
VERILOG-îïèñàíèÿ èìåíà è ðàçìåùåíèå áèáëèîòåê ñ îïèñàíèÿìè îáúåêòîâ ïðîåêòà, ñîïîñòàâëåííûõ êîìïîíåíòàì.
VERILOG
config CONF_SM //èìÿ êîíôèãóðàöèè äëÿ ïðèìåðà CONF_SM
design ADDER_LIB.TOP //Óñòàíàâëèâàåò ïîðÿäîê ïîèñêà îáúåêòîâ ïðîåêòà,
//ñîïîñòàâëåííûõ êîìïîíåíòàì - â ïðèìåðå
// â âèðòóàëüíîé áèáëèîòåêå ADDER_LIB
library ADDER_LIB "./*.v"; //îïðåäåëÿåò ìåñòî âèðòóàëüíîé áèáëèîòåêè // â ïðèìåðå òåêóùàÿ äèðåêòîðèÿ è ôàéëû ñ ðàñøèðåíèåì .v
endconfig
1.1.5. Ïîâåäåíèå îáúåêòà ïðîåêòà
Èç ïðèâåäåííûõ ïðèìåðîâ âèäíî, ÷òî, íåñìîòðÿ íà ñóùåñòâåííóþ ðàçíèöó â
ñèíòàêñèñå ÿçûêîâ, îáùíîñòü ñòðóêòóðíûõ îïèñàíèé ñõåì î÷åâèäíà. Ñòðóêòóðíîå
ïðåäñòàâëåíèå îòîáðàæàåò òèïû è ñâÿçè êîìïîíåíòîâ, íî èõ ïîâåäåíèå â ÿâíîì
âèäå â íåì íå îïèñûâàåòñÿ, è ÷òî äåëàåò, íàïðèìåð, êîìïîíåíò Ì2 ñ âõîäíûìè
ñèãíàëàìè, èç íåãî íå ÿñíî.
Êîìïîíåíò ïðåäñòàâëÿåò îáúåêò ïðîåêòà íèçøåãî ðàíãà, ôóíêöèÿ êîòîðîãî
ìîæåò áûòü ðàñêðûòà, èëè îí ìîæåò áûòü, â ñâîþ î÷åðåäü, îïèñàí ñòðóêòóðíî.
Òàê, îïèñàíèå ôóíêöèè îáúåêòà ïðîåêòà Ì2 â ñëó÷àå, åñëè îí ðåàëèçóåò îïåðàöèþ
ñëîæåíèÿ ïî ìîäóëþ 2 (xor — èñêëþ÷àþùåå ÈËÈ), ìîæåò áûòü òàêèì:
VHDL
entity M2 is
generic (TDEL: time:=10 ns);
port (X1,X2 : in bit;
Y : out bit);
end;
architecture BEH of M2 is
begin
Y<= (X1 xor X2) after TDEL;
end;
VERILOG
`timescale 1 ns /100 ps
module M2 (X1,X2,Y);
parameter TDEL=10;
input X1,X2;
output Y;
// êîíåö èíòåðôåéñà
//íèæå òåëî ìîäóëÿ M2
assign #(TDEL) Y= (X1 ^ X2);
endmodule
Åñëè â òåêñòîâûé ôàéë ñ îïèñàíèåì îáúåêòà ïðîåêòà SM âêëþ÷èòü îïèñàíèå
îáúåêòà M2, íàïðèìåð âñòàâèâ åãî â íà÷àëî ôàéëà, òî ìû ïîëó÷èì ïîëíîå îïèñàíèå ïðîåêòà SM, â êîòîðîì ðàñêðûòî ïîâåäåíèå êîìïîíåíòà M2.
Êîãäà ôóíêöèÿ îáúåêòà Ì2 ðåàëèçîâàíà â îïåðàöèÿõ êëàññè÷åñêîãî áàçèñà È,
ÈËÈ, ÍE è ïîëüçîâàòåëü õî÷åò ýòî îòðàçèòü, òî ôóíêöèÿ Ì2 â ýòèõ êëàññè÷åñêèõ
îïåðàöèÿõ ìîãëà áû âûãëÿäåòü òàê:
VHDL
Y<= ((X1 and not X2) or
(not X1 and X2)) after TDEL;
VERILOG
assign #(TDEL) Y= (X1 & ~X2)|
(~X1 & X2);
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
21
×èòàòåëþ â êà÷åñòâå óïðàæíåíèÿ ïðåäëàãàåòñÿ ñàìîñòîÿòåëüíî ðàçðàáîòàòü
ñòðóêòóðíîå îïèñàíèå îáúåêòà ïðîåêòà Ì2, ñîñòîÿùåãî èç êîìïîíåíòîâ AND2,
OR2, NOT1 è ñîñòàâèòü îïèñàíèÿ îáúåêòîâ ïðîåêòà AND2, OR2, NOT1.
ßçûê VERILOG, â îòëè÷èå îò VHDL, âêëþ÷àåò âñòðîåííûå ïðèìèòèâû n-ðàçðÿäíûõ âåíòèëåé íà ïðîèçâîëüíîå ÷èñëî âõîäîâ: and, or, nand, xor, xnor, îäíîâõîäîâûå ïðèìèòèâû not, buf è äð.  íàøåì ïðîñòåéøåì ñëó÷àå ñòðóêòóðíîå VERILOG-îïèñàíèå îáúåêòà ïðîåêòà SM ìîãëî áû áûòü òàêèì:
//VERILOG
`timescale 1 ns/100 ps
module SM_FROM_PRIMITIVES (A, B, C, S);
input A, B, C; output S;wire S_TMP;
xor #15 K1 (S_TMP ,A,B); //â ïðèìèòèâå xor
//- âûõîä - ïåðâûé â ñïèñêå ïàðàìåòðîâ
xor #10 K2 (S, S_TMP,C);
endmodule
1.1.6. Paçíîîáðàçèå ñòèëåé îïèñàíèé àðõèòåêòóð
HDL äîïóñêàåò áîëüøîå ðàçíîîáðàçèå ñòèëåé îïèñàíèé îáúåêòîâ ïðîåêòà, è,
íàïðèìåð, îáúåêò ïðîåêòà SM ìîæåò áûòü ïðåäñòàâëåí ÷èñòî ïîâåäåí÷åñêèì ñïîñîáîì (êàê «÷åðíûé ÿùèê»).
VHDL
entity SM_BEH is
generic (TDEL: time:=25 ns);
port (A, B, C: in bit;
S: out bit);
end SM_BEH ;--êîíåö èíòåðôåéñà
arhitecture BEHAVIOUR of SM_BEH is
begin
S<= (A xor B xor C) after TDEL ;
end;
VERILOG
`timescale 1 ns/100 ps
module SM_BEH (A, B, C ,S);
input A, B, C;
output S;
parameter TDEL=25;
assign #(TDEL) S= (A ^ B ^ C);
endmodule // SM_BEH
Îñòàòîê ýòîãî ïàðàãðàôà ñîäåðæèò ïðèìåðû, èëëþñòðèðóþùèå äðóãèå, áîëåå
áëèçêèå ê âîçìîæíîñòÿì îáû÷íûõ ÿçûêîâ ïðîãðàììèðîâàíèÿ ñðåäñòâà HDL â
ñôåðå îïèñàíèÿ ôóíêöèîíèðîâàíèÿ îáúåêòîâ. Äåòàëüíî ýòè ñðåäñòâà áóäóò ðàññìîòðåíû ïîçæå, è ÷èòàòåëü, ÷óâñòâóþùèé çàòðóäíåíèÿ, ìîæåò áåç óùåðáà ïðîïóñòèòü ýòîò ìàòåðèàë äî íà÷àëà ñëåäóþùåãî ðàçäåëà.
Îäíîðàçðÿäíûé ñóììàòîð. Äàäèì ïðèìåð èñïîëüçîâàíèÿ îáúåêòà ïðîåêòà
SM-ïîëóñóììàòîðà êàê êîìïîíåíòà îäíîðàçðÿäíîãî ñóììàòîðà adder, êîòîðûé ïîìèìî ñóììû sum ôîðìèðóåò ïåðåíîñ cout. Èëëþñòðèðóåòñÿ ñìåøàííûé ñòðóêòóðíûé — äëÿ ñóììû — sum è ïîòîêîâûé (âõîä ðåãèñòðà, ïðåîáðàçóÿñü, ïðîõîäèò íà
åãî âûõîä) äëÿ ïåðåíîñà — cout ñòèëü îïèñàíèÿ îáúåêòà adder.
VHDL
entity adder is
generic(T_SM: time:=25 ns);
port (a : in bit;
b : in bit;
VERILOG
`timescale 1ns/10 ps
module adder
(a,b,cin,sum,cout);
input a,b,cin;
22
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
cin : in bit;
sum : out bit;
cout : out bit);
end adder;
architecture mix of adder is
begin
summa: entity SM port map
(a,b,cin,sum);
cout <= (a and b) or
(cin and a) or
(cin and b)after T_SM;
end;
output sum,cout;
parameter T_SM= 25;
SM summa
(a,b,cin,sum);
assign #(T_SM)cout = (a & b)|
( cin & a) |
(cin & b);
endmodule
n-ðàçðÿäíûé ñóììàòîð ñ ïîñëåäîâàòåëüíûì ïåðåíîñîì. Ïðèâåäåì ïðèìåð ïîâåäåí÷åñêîãî îïèñàíèÿ n-ðàçðÿäíîãî ñóììàòîðà (adderN) áåç çàäåðæåê (ñóììàòîð ñ
ïîñëåäîâàòåëüíûì ïåðåíîñîì).
VHDL
entity adderN is
generic (n:integer:=10);
port (a,b: in bit_vector
(n downto 1);
sin : in bit; sum : out
bit_vector(n downto 1);
cout :out bit);
end;
architecture beh of adderN is
begin
p1: process(a, b, cin)
variable vsum :
bit_vector(N downto 1);
variable carry : bit;
begin
carry := cin;
for i in 1 to n loop
vsum(i) := (a(i)
xor b(i)) xor carry;
carry := (a(i) and
b(i)) or (carry and
(a(i) or b(i)));
end loop;
sum <= vsum;
cout <= carry;
end process p1;
end beh;
VERILOG
module adderN
(a,b,cin,sum,cout);
parameter n=10;
input [n:1]a,b; input cin;
output[n:1]sum;
output cout;
integer i;
reg [n :1] vsum;
reg carry;
always @ (a or b or cin)
begin
carry = cin;
for(i=1;i<=n;i=i+1) begin
vsum[i] =(a[i]
^ b[i]) ^ carry;
carry = (a[i] & b[i]) |
(carry &
(a[i] | b[i]));
end //for
end
assign sum = vsum;
assign cout = carry;
endmodule //adderN
n-ðàçðÿäíûé ñóììàòîð. Äàëåå ïðèâåäåí ïðèìåð åùå áîëåå àáñòðàêòíîãî óðîâíÿ
îïèñàíèÿ n-ðàçðÿäíîãî ñóììàòîðà adder N_B (íå ÿñíî, êàêîé ïåðåíîñ — ïàðàëëåëüíûé èëè ïîñëåäîâàòåëüíûé).
VHDL-ìîäåëü èñïîëüçóåò ïîäêëþ÷åíèå ïàêåòîâ, â êîòîðûõ îïðåäåëåí òèï
STD_LOGIC_VECTOR è àðèôìåòè÷åñêèå îïåðàöèè íàä íèì (äëÿ BIT_VECTOR
îíè íå îïðåäåëåíû). Â îáîèõ îïèñàíèÿõ ïðèìåíåíà îïåðàöèÿ êîíêàòåíàöèè
(ñöåïëåíèÿ) — cèìâîë & â VHDL è ñèìâîëû{,} â VERILOG.
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
23
 VHDL ñèãíàë vsum èìååò äîïîëíèòåëüíûé ðàçðÿä ñëåâà, ÷òîáû õðàíèòü ïåðåíîñ, êîòîðûé çàòåì ïðèñâàèâàåòñÿ â cout, â VERILOG ýòî äåëàåòñÿ â ñîñòàâå
êîíêàòåíàöèè {cout,sum} â ëåâîé ÷àñòè ïðèñâàèâàíèÿ.
VHDL
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.std_logic_unsigned.all;
entity adderN_B is
generic (n:integer:=10);
port (a,b:
in std_logic_vector
(n downto 1);
cin : in std_logic;
sum : out
std_logic_vector(n downto 1);
cout :out std_logic);
end adderN;
architecture beh of adderN_B is
begin process
variable
vsum,a1:
std_logic_vector(n+1 downto 1);
begin wait on a,b,cin
a1:= '0'& a;
vsum := a1+b+ cin;
sum <=vsum (n downto 1);
cout <=vsum(n+1);
end process;
end beh;
VERILOG
`timescale 1 ns/100 ps
module adderN_B
(a,b,cin,sum,cout);
parameter n=10;
input [n:1]a,b;input cin;
output[n:1]sum;;
output cout;
reg [n :1] sum;
reg cout;
always @ (a or b or cin)
begin
{cout,sum}= a+b+cin;
end
endmodule //adderN_B
Òåñòèðóþùàÿ ïðîãðàììà. Çäåñü ïðèâåäåí ïðèìåð ïðîãðàììû, òåñòèðóþùåé
îäíîðàçðÿäíûé ñóììàòîð ïóòåì ïîäà÷è äâóõ âõîäíûõ íàáîðîâ: a, b, c = 000,111.
VHDL
entity adder_tb is end;
architecture BEH of adder_tb is
component adder
port(
a, b, cin : in bit;
sum : out bit;
cout : out bit);
end component;
-- Stimulus signals
signal a : bit;
signal b : bit;
signal c : bit;
-- Observed signals
signal sum : bit;
signal cout : bit;
begin
-- íèæå òåñòîâûå âåêòîðû
VERILOG
`timescale 1 ns/100 ps
module adder_tb;
reg a;
reg b;
reg c;
wire sum;
wire cout;
24
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
process begin
a<='0';b<='0';c<='0';
wait for 100 ns;
a<='1';b<='1';c<='1';
wait for 100 ns;
end process;
-- Unit Under Test port map
UUT : adder
port map (
a => a,
b => b,
cin => c,
sum => sum,
cout => cout
);
end BEH;
initial begin
a<=0;b<=0;c<=0;
#100;
a<=1;b<=1;c<=1;
#100; $finish;
end
//òåñòèðóåòñÿ adder
adder UUT
(
.a(a),
.b(b),
.cin(c),
.sum(sum),
.cout(cout)
);
endmodule //adder_tb
Èç ïðèâåäåííûõ ïðèìåðîâ âèäíî, ÷òî ïðè îïèñàíèè ïîâåäåíèÿ ñëîæíûõ îáúåêòîâ ïðèõîäèòñÿ èñïîëüçîâàòü ðàçíîîáðàçíûå îáùåàëãîðèòìè÷åñêèå è ñïåöèàëüíûå ñðåäñòâà HDL, ÷àñòè÷íî ðàññìîòðåííûå íèæå.
1.2. HDL — âçãëÿä ïðîãðàììèñòà
Åñëè ïîñìîòðåòü íà HDL ãëàçàìè ïðîãðàììèñòà, òî ìîæíî ñêàçàòü, ÷òî îí ñîñòîèò êàê áû èç äâóõ êîìïîíåíòîâ — îáùåàëãîðèòìè÷åñêîãî è ïðîáëåìíî-îðèåíòèðîâàííîãî (ðèñ. 1.5).
Ðèñ. 1.5. Äâà êîìïîíåíòà HDL: îáùåàëãîðèòìè÷åñêèé è ïðîáëåìíî-îðèåíòèðîâàííûé
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
25
Îáùåàëãîðèòìè÷åñêèé êîìïîíåíò VHDL — ýòî ÿçûê, áëèçêèé ïî ñèíòàêñèñó
è ñåìàíòèêå ê ÿçûêàì ïðîãðàììèðîâàíèÿ òèïà ÏÀÑÊÀËÜ, ÀÄÀ (ñì. ïðèëîæåíèå
1, ãäå ïðèâåäåíî íåïîëíîå êðàòêîå èçëîæåíèå ñèíòàêñèñà è ñåìàíòèêè ÿçûêà
VHDL).
Îáùåàëãîðèòìè÷åñêèé êîìïîíåíò VERILOG — ýòî ÿçûê, áëèçêèé ïî ñèíòàêñèñó è ñåìàíòèêå ê ÿçûêàì ïðîãðàììèðîâàíèÿ òèïà C, C++ (cì. ïðèëîæåíèå 2).
Íèæå ïðèâåäåíû íåêîòîðûå êîíñòðóêöèè, îáùèå äëÿ HDL è ñòàíäàðòíûõ
ÿçûêîâ ïðîãðàììèðîâàíèÿ îáùåàëãîðèòìè÷åñêàÿ êîìïîíåíòà HDL.
 êà÷åñòâå ïåðâîãî ïðîñòîãî ïðèìåðà ðàññìîòðèì ïðîãðàììó ïå÷àòè ïðèâåòñòâèÿ (íàïðèìåð, Hello, HDL!), îáû÷íî èñïîëüçóåìóþ â ïîñîáèÿõ äëÿ íà÷èíàþùèõ èçó÷àòü ÿçûêè ïðîãðàììèðîâàíèÿ.
VHDL
VERILOG
entity Privet1 is
end Privet1;
architecture Simple of Privet1 is
begin
process
begin
module Privet1 ();
always
begin
$display
("Hello, HDL!");
$finish;//îñòàíîâ
end
endmodule
report "Hello, HDL!";
wait;--îñòàíîâ
end prosess;
end Simple;
1.2.1. Ëåêñè÷åñêèå ýëåìåíòû HDL
Êîììåíòàðèé
Êîììåíòàðèé â VHDL — ýòî òåêñò, íà÷èíàþùèéñÿ ñ ñèìâîëîâ «--» è äî êîíöà ñòðîêè, â VERILOG — ýòî òåêñò, íà÷èíàþùèéñÿ ñ ñèìâîëîâ «//» è äî êîíöà
ñòðîêè.
 VERILOG, êàê è â C++, äîïóñêàåòñÿ ìíîãîñòðî÷íûé êîììåíòàðèé, íà÷èíàþùèéñÿ ñ ñèìâîëîâ «/*» è êîí÷àþùèéñÿ ñèìâîëàìè «*/».
Èìåíà
Èìåíà (èäåíòèôèêàòîðû) — ýòî ïîñëåäîâàòåëüíîñòü áóêâ è öèôð, íà÷èíàþùàÿñÿ ñ áóêâû.  ÷èñëî ðàçðåøåííûõ âíóòðè èäåíòèôèêàòîðà âêëþ÷åí ñèìâîë
«_».  VERILOG â ÷èñëî ðàçðåøåííûõ âêëþ÷åí òàêæå ñèìâîë «$», è èìÿ ìîæåò
íà÷èíàòüñÿ ñ ñèìâîëà «_» è çàêàí÷èâàòüñÿ èì.
 VHDL, â îòëè÷èå îò VERILOG, ñòðî÷íûå è ïðîïèñíûå áóêâû íå ðàçëè÷àþòñÿ.
Ïðèìåðû ïðàâèëüíûõ èìåí:
VHDL
VERILOG
Abba_11
ABBA_11
Abba_11
ABBA_11
—
$A
Ïðèìå÷àíèÿ
 VHDL ïåðâîå è âòîðîå èìÿ — ýòî îäèíàêîâûå
èìåíà. Â VERILOG — ýòî ðàçíûå èìåíà
Òîëüêî â VERILOG â èìåíè äîïóñêàåòñÿ ñèìâîë «$»
26
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Ïðèìåðû çàïðåùåííûõ èäåíòèôèêàòîðîâ:
VHDL
VERILOG
2a
_å1
Ó2__Ó;
Ð_
2a
73M
+ab
E2++E4
if
if
Ïðèìå÷àíèÿ
Èìÿ íà÷èíàåòñÿ ñ çàïðåùåííîãî â íà÷àëå ñèìâîëà
VHDL — äâà __ ïîäðÿä çàïðåùåíû
Èìÿ if çàðåçåðâèðîâàíî (êëþ÷åâîå ñëîâî)
Íåêîòîðûå èìåíà çàðåçåðâèðîâàíû — ýòî êëþ÷åâûå ñëîâà ÿçûêà. Ìíîãèå èç
íèõ îáùåïðèíÿòû â ÿçûêàõ ïðîãðàììèðîâàíèÿ.
Ïðèìåðû: begin, end, if, else, for, while è ò. ï.
Ñïèñîê êëþ÷åâûõ ñëîâ VHDL ïðèâåäåí â ïðèëîæåíèè 1, VERILOG — â ïðèëîæåíèè 2.
×àñòî âñòðå÷àþùàÿñÿ îøèáêà â èìåíàõ-ïðè ïîäãîòîâêå òåêñòîâ ïðîãðàìì ïåðåïóòûâàþòñÿ âíåøíå îäèíàêîâûå ñèìâîëû ëàòèíèöû è êèðèëëèöû è áëèçêèå ïî
èçîáðàæåíèþ ñèìâîëû áóêâ è öèôð O è 0, l è 1 è ò. ï. Íàïðèìåð èìÿ ÀÑ1, íàáèòîå â ëàòèíñêîì àëôàâèòå, îòëè÷àåòñÿ îò èìåíè ÀÑ1, íàáèòîãî â ðóññêîì.
Ðàñøèðåííûå èìåíà
Ðàñøèðåííûå èìåíà ìîãóò âêëþ÷àòü ëþáûå ïå÷àòíûå ñèìâîëû êîäà ASCII.
Îíè íà÷èíàþòñÿ â VERILOG ñ ñèìâîëà «\» è çàêàí÷èâàþòñÿ ïðîáåëîì.
 VHDL oíè îãðàíè÷åíû ñèìâîëîì «\».
Ðàñøèðåííûå èìåíà ïîçâîëÿþò óâåëè÷èòü äèàïàçîí äîïóñòèìûõ èìåí.
Ïðèìåð:
VHDL
VERILOG
\f+bxo_xo\
\f+bxo_xo
Ñîñòàâíûå èìåíà
Ñîñòàâíûå èìåíà — ýòî ïîñëåäîâàòåëüíîñòü èìåí, ðàçäåëåííûõ òî÷êàìè (ñ èõ
ïîìîùüþ îñóùåñòâëÿåòñÿ äîñòóï ê ýëåìåíòàì ñòðóêòóð è äðóãèì îáúåêòàì — íàïðèìåð, ïàêåòàì VHDL, âíóòðåííèì ïåðåìåííûì êîìïîíåíò (ýêçåìïëÿðà ìîäóëÿ) VERILOG è ò. ï.).
Ïðèìåð: VS.DD.E1
Êîíñòàíòíûå çíà÷åíèÿ (ëèòåðàëû)
Êîíñòàíòíûå ÷èñëîâûå çíà÷åíèÿ (ëèòåðàëû) ìîãóò áûòü ïðåäñòàâëåíû â äâîè÷íîé, âîñüìåðè÷íîé, äåñÿòè÷íîé ôîðìå. Ñèìâîë «_» âíóòðè êîíñòàíòû ïîâûøàåò íàãëÿäíîñòü çàïèñè çíà÷åíèé.
Ïðèìåðû ÷èñåë:
VHDL
VERILOG
127
127
Ïðèìå÷àíèÿ
16#7F#
7'h7F
2#111_1111#
7'b111_1111
0.5
0.5
Âåùåñòâåííîå ÷èñëî 0.5
—
1'b1
Îäíîðàçðÿäíîå ÷èñëî 1
Öåëîå ÷èñëî 127 â äåñÿòè÷íîé ñèñòåìå
×èñëî 127 â øåñòíàäöàòåðè÷íîé ñèñòåìå
×èñëî 127 â äâîè÷íîé ñèñòåìå
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
27
Ñèìâîëüíûå è ñòðîêîâûå ëèòåðàëû
Ïðèìåðû:
VHDL
VERILOG
'0'
"0"
Ñèìâîë 0
Ïðèìå÷àíèÿ
'A'
"A"
Ñèìâîë A
"10N1"
"10N1"
×åòûðåõñèìâîëüíàÿ ñòðîêà
Áèòîâî-ñòðîêîâûå ëèòåðàëû
Ïðèìåðû:
VHDL
VERILOG
Ïðèìå÷àíèÿ
B"1110"
4'b1110
X"E"
4'he
Øåñòíàäöàòåðè÷íûé êîä 1110
O"16"
6'o16
Âîñüìåðè÷íûé êîä 001110
Áèòîâàÿ ñòðîêà 1110
Ïîèìåíîâàííûå êîíñòàíòû
Îïèñàíèå ïðîåêòà äîëæíî ëåãêî ìîäèôèöèðîâàòüñÿ è âìåñòî êîíñòàíòíûõ
çíà÷åíèé â òåêñòå ëó÷øå èñïîëüçîâàòü èõ èìåíà.
Ïðèìåðû îáúÿâëåíèé êîíñòàíò (ïåðâûé ïðèìåð äîïóñêàåò èçìåíåíèå çíà÷åíèÿ êîíñòàíòû S1 èç âíåøíåãî ìîäóëÿ, òàê êàê îíà îáúÿâëåíà êàê ïàðàìåòð, âòîðîé ïðèìåð äëÿ êîíñòàíòû ONE — íå äîïóñêàåò):
VHDL
generic (S1:integer:=20);
constant ONE :bit:='1';
VERILOG
Ïðèìå÷àíèÿ
parameter S1= 20;
`define ONE 1'b1;
Âåðñèÿ VERILOG-2000 ðàñøèðÿåò âîçìîæíîñòè ÿâíîãî îïèñàíèÿ êîíñòàíò,
îáúÿâëÿÿ èõ â áëîêå specify ëîêàëüíûìè ïàðàìåòðàìè, íå èçìåíÿåìûìè èç âíåøíåãî ìîäóëÿ. Ïðèìåð: localparam BB= 33; // VERILOG-2000.
Íèæå ïðèâåäåí ïðèìåð ïðîãðàììû ïå÷àòè ïðèâåòñòâèÿ Hello, Vasia ñ èñïîëüçîâàíèåì êîíñòàíò.
VHDL
entity Privet2 is
end Privet2;
architecture Simple of Privet2 is
constant s1:string
:="Hello, Vasia!";
begin
process
begin
report s1;
wait;
end process;
end Simple;
VERILOG
module Privet2 ();
parameter s1=
"Hello, Vasia!";
always
begin
$display ("%s",s1);
$finish;
end
endmodule
28
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
1.2.2. Äàííûå (îáúåêòû): òèïû è âèäû
Èìåíà äàííûõ (îáúåêòîâ ïî òåðìèíîëîãèè VHDL), èñïîëüçóåìûõ â ìîäóëå,
äîëæíû áûòü îáúÿâëåíû. Ïðè îïèñàíèè óêàçûâàþòñÿ:
— òèï îáúåêòà, çàäàþùèé äèàïàçîí âîçìîæíûõ çíà÷åíèé è îïåðàöèé (íàïðèìåð,
äàííûå öåëîãî òèïà — integer, âåùåñòâåííîãî — real);
— âèä èëè êëàññ îáúåêòà, çàäàþùèé äîïîëíèòåëüíûå ñâîéñòâà, íàïðèìåð ñîñòàâ ïðèìåíèìûõ ê îáúåêòó îïåðàòîðîâ ïðèñâàèâàíèÿ (íàïðèìåð, â VHDL — ýòî
âèäû: êîíñòàíòà, ñèãíàë è ïåðåìåííàÿ — constant, signal, variable; â VERILOG — ýòî
ïàðàìåòð, ïåðåìåííàÿ è ñîåäèíåíèå — parameter, reg, wire). Çäåñü ïåðå÷èñëåíû òèïû
è âèäû îáúåêòîâ (äàííûõ) VHDL è VERILOG.
VHDL
Òèïû
Ñêàëÿðíûå òèïû:
ïåðå÷èñëèìûé
(enumerated)
öåëûé (integer)
ôèçè÷åñêèé
ïëàâàþùèé
(float)
ôàéë (file)
ññûëî÷íûé
(access)
Àãðåãàòíûå òèïû:
Èíäåêñèðóåìûé
(array)
ñòðóêòóðíûé
(record)
VERILOG
Âèäû
Òèïû
Âèäû
ïåðåìåííàÿ
(variable)
ñèãíàëi
(signal)
êîíñòàíòà
(constant)
reg
ïåðåìåííàÿ
nteger
time
real
realtime
Ïîäâèäû
wire, wand
wor, triand
trior
tri0,tri1
supply0,
suppló
cîáûòèå
(event)
integer,real
ASCII ñòðîêà
reg,time
ñîåäèíåíèå
(íåò)
ñîáûòèå
ïàðàìåòð
(parameter)
Èç âûøåïðèâåäåííîãî ñëåäóåò ÷òî åñëè, íàïðèìåð, â VHDL öåëûå (integer)
ìîãóò áûòü êàê ïåðåìåííûìè (variable), òàê è ñèãíàëàìè (signal), òî â VERILOG
öåëûìè ìîãóò áûòü òîëüêî ïåðåìåííûå. Çàòî ñîåäèíåíèÿ (öåïè) VERILOG ìîãóò
áûòü íåñêîëüêèõ ïîäâèäîâ — îáû÷íûå (wire), ñõåìíîå È (Wand), ñõåìíîå ÈËÈ
(Wor) è äð., íî íå ìîãóò áûòü âåùåñòâåííîãî òèïà (real).
VHDL èìååò òðè êëàññà òèïîâ äàííûõ: ñêàëÿðíûå òèïû (÷èñëîâûå (öåëûå, ïëàâàþùèå), ôèçè÷åñêèå, ïåðå÷èñëèìûå); ñîñòàâíûå (àãðåãàòíûå) òèïû (èíäåêñèðóåìûå è
ñòðóêòóðíûå); ññûëî÷íûå òèïû è ôàéëîâûå òèïû. Ïðèìåðû îáúÿâëåíèé òèïîâ VHDL:
TYPE BYTE is range 0 to 255; — öåëûé òèï ñ äèàïàçîíîì çíà÷åíèé îò 0 äî 255
TYPE A is ('0', '1'); -- ïåðå÷èñëèìûé òèï ñî çíà÷åíèÿìè '0' è '1'
VHDL âêëþ÷àåò ïðåäîïðåäåëåííûå (îáúÿâëåííûå â ïàêåòå STANDARD (ñì.
ïðèëîæåíèå 1), ïîäêëþ÷åííîì ïî óìîë÷àíèþ) ïåðå÷èñëèìûå òèïû: bit, character,
boolean, severyty_level, file_open_kind, file_open_status; öåëûé òèï integer, ïëàâàþùèé òèï real è ôèçè÷åñêèé òèï — time, èíäåêñèðóåìûå — string è bit_vector; ïîäòèïû öåëîãî òèïà: positive (>0) è natural (>=0). Ïðè ïîäêëþ÷åíèè ïàêåòà
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
29
STD_LOGIC_1164 ïîëüçîâàòåëþ ñòàíîâÿòñÿ äîñòóïíûìè ìíîãîçíà÷íûå òèïû
std_logic è std_logic_vector, ÿâëÿþùèåñÿ ðàñøèðåíèÿìè äâóçíà÷íîãî bit-(«0»,«1») â
äåâÿòèçíà÷íûé àëôàâèò, ðàññìàòðèâàåìûé â ñëåäóþùåé ãëàâå.
VERILOG äàííûå âèäà ïåðåìåííûå è ñîåäèíåíèÿ, â ÷àñòíîñòè, äîïóñêàþò ñêàëÿðû è âåêòîðû (îäíîìåðíûå ìàññèâû) ìíîãîçíà÷íîãî òèïà (çíà÷åíèÿ ðàçðÿäa 0, 1,
x, z). Íàä âèäîì ïåðåìåííûå (òèïû reg, integer è ò. ï.) îïðåäåëåí, â ÷àñòíîñòè, îïåðàòîð ïðîöåäóðíîãî ïðèñâàèâàíèÿ (Procedural Assignment): áëîêèðóþùèé (blocking assignment) èìååò ñèìâîë = è íåáëîêèðóþùèé (Non blocking assignment) ñèìâîë <= .
Íàä îáúåêòîì âèäà ñîåäèíåíèå (câÿçü — wire, wor è ò. ä.) îïðåäåëåí îïåðàòîð
íåïðåðûâíîãî ïðèñâàèâàíèÿ (Continuous Assignment). Ïîäâèäû ñîåäèíåíèé, êàê
óæå îòìå÷àëîñü, ñîîòâåòñòâóþò òèïè÷íûì ñõåìîòåõíè÷åñêèì ýëåìåíòàì: ìîíòàæíîå È (wand), ÈËÈ (wor), èñòî÷íèê ïèòàíèÿ (supply1, supply0) è ò. ä. Êðîìå òîãî,
öåïÿì ìîæåò çàäàâàòüñÿ ðàçëè÷íàÿ ñèëà ñèãíàëà (ñì. ïðèëîæåíèå 2).
Ïðèìåð wire A,B; assign A=B;
Ïðèìåðû îáúÿâëåíèé äàííû:
VHDL
VERILOG
signal E1,E2: bit;
variable M2:bit;
signal E13,E23:bit_vector(1 to 3);
signal AII_2: integer;
wire E1,E2;
reg M2;
reg [1:3 ] E13,E23;
integer AII_2;
Ïðèìå÷àíèÿ
ñèãíàëû E1,E2
ïåðåìåííàÿ M2
òðåõáèòîâûe E13, E23
öåëûé AII_2
Äàííûå (îáúåêòû) âèäà ïåðåìåííàÿ — variable â VHDL àíàëîãè÷íû îáû÷íûì
ïåðåìåííûì ÿçûêîâ ïðîãðàììèðîâàíèÿ. Îíè îïèñûâàþòñÿ è ëîêàëèçîâàíû â ïðåäåëàõ îïèñàíèé ïîäïðîãðàìì è áëîêîâ ïðîöåññîâ (ïîíÿòèå, ðàññìàòðèâàåìîå
íèæå). Èì ìîæíî ñîïîñòàâèòü äàííûå ñîîòâåòñòâóþùåãî âèäà ÿçûêà VERILOG
(äàííûå òèïîâ reg, integer, real, time ìîãóò áûòü â íåì òîëüêî ïåðåìåííûìè).
Äàííûå âèäà ñîåäèíåíèå — (VERILOG) è âèäà ñèãíàë — signal (VHDL), êàê
óæå îòìå÷àëîñü, ìîæíî ñîïîñòàâèòü ïðîâîäàì-ñèãíàëàì â ìîäåëè.
Ìàññèâû äàííûõ:
VHDL
VERILOG
type MA is array (0 to 10) of bit;
signal A: MA;
type MB is array (1 to 5) of
bit_vector (2 to 6);
variable B : MB;
Ïðèìå÷àíèÿ
reg A[0:10];
îäíîðàçðÿäíûé ìàññèâ À
(âåêòîð)
reg [2:6] B [1:5];
ìàññèâ ïÿòè áèòîâûõ
âåêòîðîâ B
Verilog-1995 äîïóñêàë òîëüêî îäíîìåðíûå ìàññèâû è òîëüêî äëÿ ïåðåìåííûõ
(reg, integer, real, time) è èñêëþ÷àë ïðÿìîå îáðàùåíèå ê ðàçðÿäàì è ïîëÿì îòäåëüíûõ ñëîâ ìàññèâîâ — ïðèõîäèëîñü êîïèðîâàòü âñå ñëîâî ìàññèâà âî âñïîìîãàòåëüíóþ ïåðåìåííóþ, à çàòåì èç íåå èçâëåêàòü íóæíûé áèò èëè ïîëå. Verilog-2000 íå
èìååò ýòîãî îãðàíè÷åíèÿ.
Ïðèìåð Verilog-2000:
reg [31:0] arr2 [0:25][0:15];// îáúÿâëåí äâóìåðíûé ìàññèâ arr2
wire [7:0] out2 = arr2[100][7][31:24]; // èç ìàññèâà arr2 èçâëåêàåòñÿ ïîëå 31:24
VERILOG ïîçâîëÿåò èñïîëüçîâàòü âåêòîðíûå äàííûå ñî çíàêîì, îáúÿâëÿÿ èõ
ñ äîïîëíåíèåì signed. Àðèôìåòè÷åñêèå îïåðàöèè ó÷èòûâàþò ýòî.
Ïðèìåð Verilog-2000:
reg signed [6:0] F1; wire signed [8:7] B2 [0:10];
input signed [1:0] a;function signed [12:0] XX;
30
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
VHDL äîïóñêàåò àðèôìåòè÷åñêèå îïåðàöèè íàä äâîè÷íûìè è áóëåâñêèìè
âåêòîðàìè òîëüêî ïðè ïîäêëþ÷åíèè ñïåöèàëüíûõ ïàêåòîâ (ñì. ïðèëîæåíèå 1).
Îáúÿâëåíèÿ äàííûõ — îáëàñòü ðàñïîëîæåíèÿ
Êàê ïðàâèëî, îáúÿâëåíèÿ äàííûõ äîëæíû ïðåäøåñòâîâàòü èõ èñïîëüçîâàíèþ.
 VHDL îáúÿâëåíèÿ ðàñïîëàãàþòñÿ ìåæäó çàãîëîâêîì áëîêà (architecture,
process, block, function, procedure, package) è êëþ÷åâûì ñëîâîì begin.
 VERILOG ìåñòîïîëîæåíèå îïèñàíèé êîíòðîëèðóåòñÿ íå òàê ñòðîãî, íî
îïèñàíèÿ äîëæíû ïðåäøåñòâîâàòü èñïîëüçîâàíèþ äàííûõ.
Hà÷àëüíûå çíà÷åíèÿ äàííûõ
Ïåðå÷èñëèìûå òèïû äàííûõ VHDL ïî óìîë÷àíèþ ïðèíèìàþò ïåðâîå èç óêàçàííûõ â îïèñàíèè òèïà çíà÷åíèé.
VHDL
VERILOG
boolean- FALSE,bit-'0',
std_logic-'U'
reg è wire- 1'bx
Oäíàêî ìîæíî ÿâíî óêàçàòü íà÷àëüíîå çíà÷åíèå â îïèñàíèè äàííûõ:
signal A: bit :='1';
reg A=1'b1;// VERILOG-2000
Ïðåîáðàçîâàíèå òèïîâ äàííûõ
 VHDL äëÿ ñòàíäàðòíûõ ÷èñëîâûõ òèïîâ integer, real ýòî äîñòèãàåòñÿ óêàçàíèåì òèïà ïåðåä àðãóìåíòîì â ñêîáêàõ, äëÿ ñòðîêîâîãî òèïà — óêàçàíèåì òèïà è
àòðèáóòà «image» èëè «value», ïðè ïîäêëþ÷åíèè ïàêåòîâ — óêàçàíèåì âêëþ÷åííûõ
â íèõ ôóíêöèé ïðåîáðàçîâàíèÿ (ñì. ãëàâó 2 è ïðèëîæåíèå 1). Äëÿ îñòàëüíûõ ïðåîáðàçîâàíèé íåîáõîäèìî èñïîëüçîâàòü ñïåöèàëüíûå ôóíêöèè, ñì., íàïðèìåð,
îïèñàíèå ïàìÿòè â ãëàâå 3.
Ïðèìåð: ïðåîáðàçîâàíèe ñòðîêè â öåëûé — integer'value("314") — äàåò 314;
ïðåîáðàçîâàíèe öåëîãî â ñòðîêó — integer'image(314) — äàåò "314";
ïðåîáðàçîâàíèe âåùåñòâåííîãî â öåëîå — integer(3.14) — äàåò 3;
 VERILOG ïðåîáðàçîâàíèÿ îñóùåñòâëÿþòñÿ ôóíêöèÿìè §realtobits(x) — âåùåñòâåííîå â âåêòîð è §bitstoreal(x) — íàîáîðîò.
Äàííûå, îáúÿâëÿåìûå ïî óìîë÷àíèþ
VHDL, êàê ñòðîãî òèïèçèðîâàííûé ÿçûê, ïîäðàçóìåâàåò, ÷òî âñå äàííûå äîëæíû áûòü îáúÿâëåíû. Ëèøü íåîáúÿâëåííûé ïàðàìåòð öèêëà âîñïðèíèìàåòñÿ êàê
integer.
VERILOG íå ñòîëü ñòðîã. Íàïðèìåð, â VERILOG íåîáúÿâëåííûé èäåíòèôèêàòîð â ëåâîé ÷àñòè îïåðàòîðà íåïðåðûâíîãî ïðèñâàèâàíèÿ â ðÿäå ñëó÷àåâ ïîäðàçóìåâàåòñÿ îáúÿâëåííûì êàê wire ñ äëèíîé, ðàâíîé äëèíå ïðàâîé ÷àñòè. Ýòî ìîæåò ïðèâîäèòü ê íåîæèäàííûì îøèáêàì.
Òèïû è ïîäòèïû äàííûõ, îïðåäåëÿåìûõ ïîëüçîâàòåëåì (VHDL)
ßçûê VHDL ïîçâîëÿåò ââîäèòü íîâûå òèïû äàííûõ.
Ïðèìåð îáúÿâëåíèÿ è èñïîëüçîâàíèÿ íîâîãî òèïà:
TYPE mem IS ARRAY (0 TO 1023) OF BIT_VECTOR(31 DOWNTO 0);
(ìàññèâ 1024 32-áèòîâûõ âåêòîðîâ)
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
31
Ïðèìåð åãî èñïîëüçîâàíèÿ: variable RAM: mem;
Ïðèìåð îáúÿâëåíèÿ òèïà BIT_VECTOR — âåêòîð íåîïðåäåëåííîé äëèíû,
âçÿòûé èç ñòàíäàðòíîãî ïàêåòà STANDARD (cì. ïðèëîæåíèå 1).
type bit_vector is array(NATURAL range <>) of BIT; -- èíäåêñû îò 0 è âûøå
Ïîäòèï (subtype) ïîçâîëÿåò ââîäèòü îáúåêòû, îáëàñòü çíà÷åíèé êîòîðûõ ÿâëÿåòñÿ ïîäìíîæåñòâîì áàçîâîãî òèïà è êîòîðûå ìîãóò èìåòü àññîöèèðîâàííóþ ñ
íèìè ðàçðåøàþùóþ ôóíêöèþ (ñì. ãë. 2 è ïðèëîæåíèå 1).
Ïðèìåð:
subtype byte is bit_vector(7 downto 0);signal A:byte;
1.2.3. Îïåðàöèè è âûðàæåíèÿ
1.2.3.1. Îïåðàöèè
Ïîìèìî îáùåïðèíÿòûõ àðèôìåòè÷åñêèõ îïåðàöèé (+, -, *,/) è îïåðàöèé îòíîøåíèÿ, â HDL ââåäåíî áîëüøîå ÷èñëî ëîãè÷åñêèõ îïåðàöèé. Íèæå ïðèâåäåíû
ïðèìåðû òîëüêî ðÿäà èç íèõ.
Îñîáåííîñòè îïåðàöèé â ìíîãîçíà÷íîì àëôàâèòå ïîÿñíÿþòñÿ â ñëåäóþùåé
ãëàâå. Ðåçóëüòàò VERILOG-îïåðàöèé èíîãäà ïðèâîäèòñÿ â òîé æå ñòðîêå òàáëèöû
â ñêîáêàõ.
Ïðèìåðû:
Îïåðàöèÿ
Ïðèìåð
VHDL
VERILOG
Ðåçóëüòàò
Àðèôìåòè÷åñêèå îïåðàöèè (íàä öåëûìè è âåùåñòâåííûìè — VHDL, âñåìè òèïàìè — VERILOG)
Ñëîæåíèå
2+3
2+3
5
Âû÷èòàíèå
2-3
2-3
-1
Óìíîæåíèå
2*3
2*3
6
Äåëåíèå öåë.
2/3
2/3
0
Ìîäóëü
2 mod 3
2%3
2
Îñòàòîê
-2 rem 3
—
-2
Àáñîëþòíîå
abs (-1)
Ñòåïåíü (VERILOG-2000)
2 ** 3
1
—
8
Óíàðíûå àðèôìåòè÷åñêèå
Ïëþñ
+1
+1
1
Ìèíóñ
-1
-1
-1
- 4'b1011
4'b0101
Ìèíóñ
Ïðè ðàáîòå ñ VERILOG ñëåäóåò îáðàòèòü âíèìàíèå íà ñïîñîá ïðåäñòàâëåíèÿ
îòðèöàòåëüíûõ ÷èñåë: èñïîëüçóåòñÿ äîïîëíèòåëüíûé êîä (äîïîëíåíèå äî 2). Íàïðèìåð, â integer i;initial i=-12; çíà÷åíèå -12 ïðåäñòàâëåíî êàê fffffff4 â øåñòíàäöàòåðè÷íîì êîäå (äîïîëíèòåëüíûé êîä), è åñëè ïðèñâîèòü i, íàïðèìåð, â 16-ðàçðÿäíóþ ïåðåìåííóþ reg [15:0] D; D=i; òî â D áóäåò øåñòíàäöàòåðè÷íûé êîä fff4.
32
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Ïðèìåð
Îïåðàöèÿ
VHDL
VERILOG
Ðåçóëüòàò
Ëîãè÷åñêèå îïåðàöèè íàä áóëåâñêèìè (Boolean) (VHDL)
È
ÈËÈ
HE
ÒRUE AND FALSE
—
FALSE
ÒRUE OR FALSE
—
TRUE
NOT TRUE
—
FALSE
Ïîðàçðÿäíûå ëîãè÷åñêèå îïåðàöèè íàä äâîè÷íûìè (bit) è (bit_vector) âåêòîðàìè VHDL
è ðàçëè÷íûìè òèïàìè ïåðåìåííûõ è öåïåé VERILOG
Ïîðàçðÿäíîå È
Ïîðàçðÿäíîå ÈËÈ
Îòðèöàíèå
Èñêëþ÷àþùåå ÈËÈ
Ïîðàçðÿäíàÿ èíâåðñèÿ
B"1011" AND B"0010"
4'b1011 & 4'b0010
B"0010"(4'b0010)
B"1011" OR B"0010"
4'b1011 | 4'b0010
B"1011"(4'b1011)
not B"1011"
~ 4'b1011
B"0100"(4'b0100)
B"1011" XOR B"0010"
4'b1011 ^ 4'b0010
B"1001"(4'b1001)
NOT B"0010"
~4b0010
B"1101"(4'b1101)
Ëîãè÷åñêèå îïåðàöèè (VERILOG) äàþò 1-áèòîâûé ðåçóëüòàò
Ëîãè÷åñêîå È
—
4'b1011 && 4'b0010
1'b1 && 1'b0
1'b1
Ëîãè÷åñêîå ÈËÈ
—
4'b1011 || 4'b0010
1'b1 || 1'b0
1'b1
Ëîãè÷åñêîå îòðèöàíèå
—
! 4'b1011
1'b0
Íåêîòîðûå èç óíàðíûõ îïåðàöèé ðåäóêöèè íàä n-ðàçðÿäíûìè äàííûìè (VERILOG)
È âñåõ ðàçðÿäîâ
—
&4'b1101
1'b0
ÈËÈ âñåõ ðàçðÿäîâ
—
| 4'b1101
1'b1
Îïåðàöèè îòíîøåíèÿ (íàä ÷èñëàìè è ñòðîêàìè)
Ðàâåíñòâî
Ðàâåíñòâî ÷èñåë
B"1011" = "0010"
4'b1011 == 4'b0010
FALSE (1'b0)
5=6
5 == 6
FALSE
Íåðàâåíñòâî
B"1011" /= B"0010"
4'b1011 != 4'b0010
TRUE (1'b1)
Áîëüøå
B"1011" > B"0010"
4'b1011 > 4'b0010
TRUE (1'b1)
Ìåíüøå
B"1011" < B"0010"
4'b1011 < 4'b0010
FALSE (1'b0)
Áîëüøå-ðàâíî
B"1011" >= B"0010"
4'b1011 >= 4'b0010
TRUE (1'b1)
Ìåíüøå-ðàâíî
5 <= 5
5 <= 5
TRUE (1'b1)
Èäåíòè÷íîñòü (VERILOG)
Èäåíòè÷íîñòü
—
4'b1011 === 4'b0010
1'b0 (FALSE)
Íåèäåíòè÷íîñòü
—
4'b1011 !== 4'b0010
1'b1 (TRUE)
Ðàçëè÷èå VERILOG-îïåðàöèé îòíîøåíèÿ è èäåíòè÷íîñòè çàìåòíî â ìíîãîçíà÷íîì àëôàâèòå. Ïðèìåð:
Îïåðàöèÿ 4'd1xx0 != 4'd1011 äàåò ðåçóëüòàò 1'bx, ÷òî, íàïðèìåð, îçíà÷àåò FALSE äëÿ óñëîâèÿ â îïåðàòîðå if, à îïåðàöèÿ 4'd1xx0 !== 4'd1011 äàåò ðåçóëüòàò 1'b1,
ò. å. TRUE.
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Îïåðàöèÿ
33
Ïðèìåð
VHDL
VERILOG
Ðåçóëüòàò
Ëîãè÷åñêèå ñäâèãè (â ïðèìåðàõ íà 2)
Ñäâèã âëåâî
B"1011" SLL 2
4'b1011 << 2
"0010" (4'b1100)
Ñäâèã âïðàâî
B"1011" SRL 2
4'b1011 >> 2
"0010" (4'b0010)
Àðèôìåòè÷åñêèå ñäâèãè (VHDL)
Ñäâèã âëåâî
B"1011" SLA 2
—
"1111"
Ñäâèã âïðàâî
B"1011" SRA 2
—
"1110"
Öèêëè÷åñêèå ñäâèãè (VHDL)
Ñäâèã âëåâî
B"1011" ROL 2
—
"1110"
Ñäâèã âïðàâî
B"1011" ROR 2
—
"1110"
"100" &"11"
{3'b100,2'b11}
"10011" (5'b10011)
—
{2{2'b01}}
6'b010101
Ðàçíûå îïåðàöèè
Êîíêàòåíàöèÿ (ñöåïëåíèå)
Ðåïëèêà-ïîâòîð
Ïðèîðèòåò îïåðàöèé — êàê è â îáû÷íûõ ÿçûêàõ ïðîãðàììèðîâàíèÿ — íàèáîëüøèé ó óíàðíûõ, íî âî èçáåæàíèå îøèáîê ëó÷øå ïîëüçîâàòüñÿ ñêîáêàìè äëÿ óêàçàíèÿ
ïîðÿäêà âû÷èñëåíèé.
Ïðèìåð: ( ( (à+b)*c )> (m-n)).
1.2.3.2. Âûðàæåíèÿ
Îáû÷íûå âûðàæåíèÿ ñòðîÿòñÿ èç êîíñòàíò, èìåí, îïåðàöèé è ñêîáîê.
Ïðèìåð:
VHDL
(F+H)* (C-D)
VERILOG
(F+H)* (C-D)
VHDL ñòðîãî êîíòðîëèðóåò òèïû äàííûõ, îïåðàöèé è äëèíû îïåðàíäîâ (âåêòîðîâ) â âûðàæåíèÿõ, íàïðèìåð çàïðåùåíî ñëîæåíèå 2+'1', åñëè íå ïîäêëþ÷åí ñîîòâåòñòâóþùèé ïàêåò (ñì. ïðèëîæåíèå 1). VERILOG íå ñòîëü ñòðîã, äîïóñêàÿ âûðàæåíèÿ âðîäå 2+1'b1+"A".
Âûðàæåíèÿ ñ ïîëÿìè âåêòîðîâ è ìàññèâîâ.
VERILOG íå äîïóñêàåò ðàáîòó ñ ïîëÿìè ïåðåìåííîé äëèíû. Îäíàêî åãî âåðñèÿ VERILOG-2000 ïîçâîëÿåò èñïîëüçîâàòü ïåðåìåííûå èíäåêñû ïîëåé ôèêñèðîâàííîé äëèíû.
Ïðèìåð:
VHDL
VERILOG
variable A:bit_vector(32 downto 0);
reg [32:0] A;
variable B,k,nI,j:integer
reg [3:0] B;
variable C bit_vector(7 downto 0)
wire [7:0] C;
C<=A((B+1)*8 downto B*8);
assign Ñ=A[B*8 +: 8];//VER-2000
Ñ(K downto N)<=A(I downto J); -- ýòî âîçìîæíî â VHDL, à VERILOG
ïîäîáíîå ïîëå ïåðåìåííîé äëèíû íå äîïóñêàåò.
Ïîìèìî îáû÷íûõ âûðàæåíèé äîïóñêàþòñÿ çàäåðæàííûå.
Çàäåðæàííîå âûðàæåíèå èñïîëüçóåòñÿ â îïåðàòîðàõ ïðèñâàèâàíèÿ (â VHDL —
ýòî îïåðàòîð íàçíà÷åíèÿ ñèãíàëó, VERILOG — ïðèñâàèâàíèÿ ïåðåìåííîé) è ÿâëÿåòñÿ åãî ÷àñòüþ. Ñíà÷àëà îíî âû÷èñëÿåòñÿ è ÷åðåç âðåìÿ çàäåðæêè ïðèñâàèâàåòñÿ).
34
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
Ïðèìåð:
VHDL
VERILOG
S<= A+B after TD;
S<=#(TD) A+B;
Ïîäðîáíåå âîïðîñû çàäåðæåê ðàññìîòðåíû â ãëàâå 2.
VHDL ïîçâîëÿåò íàçíà÷àòü âðåìåííûå äèàãðàììû ñèãíàëîâ.
Ïðèìåð: S<= 10 after 2 ns, 40 after 10 ns, 2 after 20 ns;
VERILOG äîïóñêàåò òàêæå óñëîâíûå âûðàæåíèÿ — èõ çíà÷åíèå îïðåäåëÿåòñÿ
óñëîâèåì, íàïðèìåð, âûðàæåíèå (A>B) ? 3'b100:3'b111 äàåò ðåçóëüòàò 3'b100, åñëè
A > B èñòèííî, ò. å. ðàâíî 1'b1.
Ïðèìåð âëîæåííûõ óñëîâíûõ âûðàæåíèé: x=(a>b)? c: (v && L)?d-1: 0;
1.2.4. Îïåðàòîðû
HDL îáåñïå÷èâàåò âîçìîæíîñòü îïèñàíèÿ îáû÷íûõ ïîñëåäîâàòåëüíûõ àëãîðèòìîâ.
Ïîñëåäîâàòåëüíî âûïîëíÿåìûå (ïîñëåäîâàòåëüíûå) îïåðàòîðû HDL ìîãóò èñïîëüçîâàòüñÿ â îïèñàíèÿõ ïðîöåññîâ, ïðîöåäóð è ôóíêöèé. Èõ ñîñòàâ âêëþ÷àåò
(ñì. ïðèëîæåíèÿ 1, 2) ñëåäóþùèå îïåðàòîðû:
Îïåðàòîð
Ïðèìåð
VHDL
Ïðèìåð VERILOG
1. Îæèäàíèÿ
óñëîâèÿ
çàäåðæêè
ñîáûòèÿ
wait until À1=Â1;
wait for 10 ns;
wait on A,B;
wait À1==B1;
#10;
@( A or B);
HDL ñîäåðæèò ñðåäñòâà îïèñàíèÿ îæèäàíèÿ ïðîöåññàìè îïðåäåëåííîãî òèïà
ñîáûòèé — ôðîíòîâ ñèãíàëîâ:
îæèäàíèå ôðîíòà Ñ:
îæèäàíèå ñðåçà Ñ:
wait until C'event and C='1';
wait until C'event and C='0';
@posedge(Ñ) ;
@negedge(C);
Èõ èñïîëüçîâàíèå áóäåò ðàññìîòðåíî â äðóãèõ ãëàâàõ.
VHDL-îïåðàòîð îæèäàíèÿ ïîçâîëÿåò îáúåäèíÿòü âñå òðè òèïà óñëîâèé.
Ïðèìåð: wait on a until d>f for 19 ns;--ïîñëå ñîáûòèÿ â à æäàòü ïîêà ñòàíåò èñòèííî d>f è ïîòîì åùå 19 ns.
VERILOG äîïóñêàåò îòñóòñòâèå ñèìâîëà «;» ïîñëå îïåðàòîðà îæèäàíèÿ — òîãäà îí ñòàíîâèòñÿ óñëîâèåì çàïóñêà ñëåäóþùåãî îïåðàòîðà.
Ïðèìåð: @(a) wait( d>f); #19;//òàê âûãëÿäèò ïðåäûäóùèé ïðèìåð
2. Îïåðàòîð ïðèñâàèâàíèÿ
ïåðåìåííîé (VHDL),
ïðîöåäóðíîãî
áëîêèðóþùåãî ïðèñâàèâàíèÿ
(VERILOG) ïåðåìåííîé
3. Ïîñëåäîâàòåëüíûé îïåðàòîð
íàçíà÷åíèÿ ñèãíàëà (VHDL)
ïðîöåäóðíîãî íåáëîêèðóþùåãî
ïðèñâàèâàíèÿ (VERILOG)
ïåðåìåííîé
V := V1+V2;
--variable V
V = V1+V2;
// reg V
--signal S
S1<=S2;
//reg S
S1<=S2;
Ãëàâà 1. HDL — âçãëÿä ñõåìîòåõíèêà è ïðîãðàììèñòà
35
4. Óñëîâíûé îïåðàòîð
if A=B then
S1<=S2;
end if;
if (A==B)
S1<=S2;
5. Îïåðàòîð âûáîðà
case S is
when A => B:=Y;
when D=>B:=notY;
when others=>B:='1';
end case;
case (S)
A: B=Y;
D: B=~Y
default:B=1;
endcase
6. Îïåðàòîð öèêëà
for i in 1 to 4 loop
M(i):=0;
end loop;
while A<B loop
A:=A+1;
end loop;
for (i=1;i<=4;i=i+1)
M[i]=0;
while A<B
A=A+1;
7. Îïåðàòîð âîçâðàòà
return F;
8. Îïåðàòîð
âûçîâà ïðîöåäóðû
//íåò àíàëîãà
P(X1,X2);
9. Îïåðàòîð âûõîäà
èç öèêëà (VHDL), èç
ãðóïïû
îïåðàòîðîâ (VERILOG)
P(X1,X2);
exit;
10. Îïåðàòîð ïåðåõîäà ê
ñëåäóþùåé èòåðàöèè â öèêëå
disable GG;
next;
//íåò àíàëîãà
11. Îïåðàòîð âûâîäà
report "A=B";
$display ("A=B");
12. Ïóñòîé îïåðàòîð
null;
//íåò àíàëîãà
13. Ïîñëåäîâàòåëüíûé îïåðàòîð
óòâåðæäåíèÿ
assert A=B
report "XOXO";
//íåò àíàëîãà
Íèæå äåòàëüíåå ðàññìîòðåíû òîëüêî íåêîòîðûå èç íèõ (ïîäðîáíåå ñì. ïðèëîæåíèÿ 1, 2).
1. Îáû÷íîå äëÿ ÿçûêîâ ïðîãðàììèðîâàíèÿ ïðèñâàèâàíèå
VHDL
VERILOG
îïåðàòîð ïðèñâàèâàíèÿ
ïåðåìåííîé
îïåðàòîð áëîêèðóþùåãî
ïðîöåäóðíîãî
ïðèñâàèâàíèÿ ïåðåìåííîé =
:=
Ïðèìåðû:
VHDL
variable X1,X2: bit;
X1 := '1';
X2 := X1;
VERILOG
reg X1,X2;
X1 = 1'b1;
X2 = X1;
Ïðèìå÷àíèÿ
X1 ïðèñâàèâàåòñÿ 1
ïîñëå ýòîãî â X2
ïðèñâàèâàåòñÿ 1;