AHDL入門
ver1.003b　2009.05.23

更新履歴
2007.12.1　新規作成
2007.12.9　Ver1.001 追加
2007.12.16　Ver1.002 追加
2007.12.22　Ver1.003 追加

参考文献
　DESIGN　WAVE　BOOKS　３　ハードウエア記述言語（Altera-HDL)を使いながら学ぶパソコンによるプログラマブル・ロジックの設計　CQ出版社

【はじめに】
AHDLは、単純です｡難しい事はないのが特長です｡ここでは、私の知っている範囲で(勘違いもあるし完全ではないということです）、実際の回路を設計しながら、まとめてゆきたいと思います｡

参考文献にはAHDLの文法がBNF文法でかかれています｡また、レキシカル構文要素もかかれています｡ですから、これを手直ししてLEX,とYACCを通せば、AHDLコンパイラができることになります｡
冗談はさておいて、この本が手に入れば、この「AHDL入門」は、多分不要です｡


第一章　4bit-12進カウンタをつくる

第一節　真理値表から作る

カウンタを作る方法は、いくつかあります｡たとえば、真理値表を用いるものです｡

図ー１　4bit-12進カウンタの真理値表

12進カウンタなのに、1100-1111は不要ではないかと仰るでしょうが、念のためこういうこともありえないこともないので、こうなったら0000にするようにします｡
D-FFをつかって作りますので、この表は、

図ー２　4bit-12進カウンタの真理値表

となります｡


図ー３　カウンタの回路ブロック図

上にブロック図を示します｡

では、設計します｡

【設計手順】

なお、ここでは見やすくするために全角文字を使っていますが、全て半角文字で書きます。予約語は太字で書いてあります。

まずはじめに、回路名を書きます｡
SUBDESIGN　4bit_12counter

SUBDESIGNは、回路記述の始まりです。次に名前がきます｡　4bit_12counter　ですね。

その次に入力出力を書きます｡
SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3..0]　　：OUTPUT；
）

と書きます｡（と）で挟まれているところに書きます。
入力信号名前　：　INPUT；
あるいは
出力信号名前　：　OUTPUT；
です。
文末には；を書きます｡

CLOCKはクロック、CLEARNは非同期クリア（ローアクティブ）、PRESETNは非同期セット（ローアクティブ）、出力はQ3,Q2,Q1,Q0です。
Q3,Q2,Q1,Q0をQ[3．．0]と書くと3から0の連番ですよということです。

その次にD-FFを用意します｡
SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3．．0]　：　DFF；

VARIABLEは、内部変数やプリミティブ（あらかじめ用意されている部品）、自分で作った機能ブロックの名前との一致を宣言を以下に書きます｡
ここでは、D-FFのプリミティブDFFを宣言しています｡

図-4　DFFプリミティブの端子

さて、以上で手続きは終わりました｡

SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3．．0]　：　DFF；
BEGIN

回路記述分

END；

これで、大まかな記述をしめします｡

さて、回路記述部分は、ブロック図に従い、
Q[]．clk=CLOCK；　　　　Q[3．．0]と書いてもいいのですが、Q[]と書くと全部ということになります。
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；

Q3．clk　これは、Q3のclkという意味になります。Q3．qはQ3の出力、Q3．dはQ3のD入力をさします｡　．は「の」と覚えればいいでしょう。
Q3．ｃｌｋは日本語では「Ｑ３のclk」というわけです。
ここまで問題ないと思います。

真理値表は、ありがたいことに真理値表のまま書くことが出来ます。
そのためには、TABLEと書きます。

TABLE　真理値表の最初に書きます｡
　Q3．q，Q2．q，Q1．q，Q0．q　=>　Q3．d，Q2．d，Q1．d，Q0.d；　　表の対応関係を書きます｡
　０　 　， ０　　，　　　０，　　　０ =>　０　　，　　　０，　　　０，　　１；
　０　 　， ０　　，　　　０，　　　１ =>　０　　，　　　０，　　　１，　　０；
　０　 　， ０　　，　　　１，　　　０ =>　０　　，　　　０，　　　１，　　１；
　０　 　， ０　　，　　　１，　　　１ =>　０　　，　　　１，　　　０，　　０；
　０　 　， １　　，　　　０，　　　０ =>　０　　，　　　１，　　　０，　　１；
　０　 　， １　　，　　　０，　　　１ =>　０　　，　　　１，　　　１，　　０；
　０　 　， １　　，　　　１，　　　０ =>　０　　，　　　１，　　　１，　　１；
　０　 　， １　　，　　　１，　　　１ =>　１　　，　　　０，　　　０，　　０；
　１　 　， ０　　，　　　０，　　　０ =>　１　　，　　　０，　　　０，　　１；
　１　 　， ０　　，　　　０，　　　１ =>　１　　，　　　０，　　　１，　　０；
　１　 　， ０　　，　　　１，　　　０ =>　１　　，　　　０，　　　１，　　１；
　１　 　， ０　　，　　　１，　　　１ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　０，　　　０ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　０，　　　１ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　１，　　　０ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　１，　　　１ =>　０　　，　　　０，　　　０，　　０；
END　TABLE；　　　　真理値表の終わりに書きます｡

さて、
　１　 　， １　　，　　　０，　　　０ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　０，　　　１ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　１，　　　０ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　１，　　　１ =>　０　　，　　　０，　　　０，　　０；

この部分は,Q3．qとQ2．ｑがともに１で、Q1,Q0は全ての組合せがあるので，
　１　 　， １　　，　　　X，　　　X =>　０　　，　　　０，　　　０，　　０；　Xは１でも０でもいいよという意味です。別の言い方をすれば関係ないよということです｡
と簡略化できます。

以上によって，
SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3．．0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；
TABLE
　Q3．q，Q2．q，Q1．q，Q0．q　=>　Q3．d，Q2．d，Q1．d，Q0.d；
　０　 　， ０　　，　　　０，　　　０ =>　０　　，　　　０，　　　０，　　１；
　０　 　， ０　　，　　　０，　　　１ =>　０　　，　　　０，　　　１，　　０；
　０　 　， ０　　，　　　１，　　　０ =>　０　　，　　　０，　　　１，　　１；
　０　 　， ０　　，　　　１，　　　１ =>　０　　，　　　１，　　　０，　　０；
　０　 　， １　　，　　　０，　　　０ =>　０　　，　　　１，　　　０，　　１；
　０　 　， １　　，　　　０，　　　１ =>　０　　，　　　１，　　　１，　　０；
　０　 　， １　　，　　　１，　　　０ =>　０　　，　　　１，　　　１，　　１；
　０　 　， １　　，　　　１，　　　１ =>　１　　，　　　０，　　　０，　　０；
　１　 　， ０　　，　　　０，　　　０ =>　１　　，　　　０，　　　０，　　１；
　１　 　， ０　　，　　　０，　　　１ =>　１　　，　　　０，　　　１，　　０；
　１　 　， ０　　，　　　１，　　　０ =>　１　　，　　　０，　　　１，　　１；
　１　 　， ０　　，　　　１，　　　１ =>　０　　，　　　０，　　　０，　　０；
　１　 　， １　　，　　　X，　　　X =>　０　　，　　　０，　　　０，　　０；
END　TABLE；
END；

と完成しました｡



図ー５　シミュレーション結果

しかし、ビット列ではなく
TABLE
Q[].q　=>　Q[],d；
H"0" =>　H"1"；　　H”１２３４５６７８９”と書くと16進数で表記していることを表します｡B"0011"は2進数、O”１２３４５６７”は８進数、デフォルトは
H"１" =>　H"２"；　　１０進数です。
H"２" =>　H"３"；
H"３" =>　H"４"；
H"４" =>　H"５"；
H"５" =>　H"６"；
H"６" =>　H"７"；
H"７" =>　H"８"；
H"８" =>　H"９"；
H"９" =>　H"A"；
H"A" =>　H"B"；
H"B" =>　H"０"；
H"C" =>　H"０"；
H"D" =>　H"０"；
H"E" =>　H"０"；
H"F" =>　H"０"；
END　TABLE；
と書いてもいいわけです｡


【アイデアメモ】

さて、ちょっと考えてください｡表で,対応させているわけだから、1の次が２である必要もないわけです｡11,10,9,8,7,6,....という表を作れば,ダウンカウンタになりますし,1,11,2,10,3,9,...という順でもできるわけです｡真理値表を使うとこのようにメリットがあります｡

また、カウンタは０からはじめる必要もありません｡２から１3までの12値でも良い訳です。

第二節　CASEを使う

真理値表を書くのもいいでしょう。でもCASEをつかっても同じことです。

CASE　Q[]．q　IS
　WHEN　H"0"　=>　　「Q[]．q=H"0"のときは，」の意味
　　　Q[]．ｄ＝Ｈ”１”；　「Q[]．d=H"1"にせよ」の意味
　WHEN　H"１"　=>
　　　Q[]．ｄ＝Ｈ”２”；
　WHEN　H"２"　=>
　　　Q[]．ｄ＝Ｈ”３”；
　WHEN　H"３"　=>
　　　Q[]．ｄ＝Ｈ”４”；
　WHEN　H"４"　=>
　　　Q[]．ｄ＝Ｈ”５”；
　WHEN　H"５"　=>
　　　Q[]．ｄ＝Ｈ”６”；
　WHEN　H"６"　=>
　　　Q[]．ｄ＝Ｈ”７”；
　WHEN　H"７"　=>
　　　Q[]．ｄ＝Ｈ”８”；
　WHEN　H"８"　=>
　　　Q[]．ｄ＝Ｈ”９”；
　WHEN　H"９"　=>
　　　Q[]．ｄ＝Ｈ”Ａ”；
　WHEN　H"Ａ"　=>
　　　Q[]．ｄ＝Ｈ”Ｂ”；
　WHEN　H"Ｂ"　=>
　　　Q[]．ｄ＝Ｈ”０”；
　WHEN OTHERS=>　「それら以外では」ということ
　　　Q[]．ｄ＝Ｈ”０”；
　END CASE；

となるわけです。

SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3..0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；
CASE　Q[]．q　IS
　WHEN　H"0"　=>
　　　Q[]．ｄ＝Ｈ”１”；
　WHEN　H"１"　=>
　　　Q[]．ｄ＝Ｈ”２”；
　WHEN　H"２"　=>
　　　Q[]．ｄ＝Ｈ”３”；
　WHEN　H"３"　=>
　　　Q[]．ｄ＝Ｈ”４”；
　WHEN　H"４"　=>
　　　Q[]．ｄ＝Ｈ”５”；
　WHEN　H"５"　=>
　　　Q[]．ｄ＝Ｈ”６”；
　WHEN　H"６"　=>
　　　Q[]．ｄ＝Ｈ”７”；
　WHEN　H"７"　=>
　　　Q[]．ｄ＝Ｈ”８”；
　WHEN　H"８"　=>
　　　Q[]．ｄ＝Ｈ”９”；
　WHEN　H"９"　=>
　　　Q[]．ｄ＝Ｈ”Ａ”；
　WHEN　H"Ａ"　=>
　　　Q[]．ｄ＝Ｈ”Ｂ”；
　WHEN　H"Ｂ"　=>
　　　Q[]．ｄ＝Ｈ”０”；
　WHEN OTHERS =>
　　　Q[]．ｄ＝Ｈ”０”；
　END CASE；
END；
と完成します｡

図５−A　合成された回路

このように回路が合成されました｡


【アイデアメモ】

このままでは、０からじゃなくて３からにしようとなると全部書き換えです｡
そこで，
CASE　Q[］．q　IS
　WHEN　zero　=>
　　　Q[]．ｄ＝one；
　WHEN　one　=>
　　　Q[]．ｄ＝two；
　WHEN　two　=>
　　　Q[]．ｄ＝three；
・・・・以下省略・・・・
　ＥＮＤ　ＣＡＳＥ；

とかいて，おくと　CONSTANTをつかって、定数宣言すると
CONSTANT　zero　=H"0"；
CONSTANT　one　=H"１"；
CONSTANT　two　=H"２"；
以下省略
とすれば，カウンタは0,1,2となりますが
CONSTANT　zero　=H"11"；
CONSTANT　one　=H"10"；
CONSTANT　two　=H"9"；
以下省略
と書き換えることでCASE文以降を書き換えることなく、ダウンカウンタに出来ます｡

CONSTANT　zero　=H"0"；
CONSTANT　one　=H"１"；
CONSTANT　two　=H"２"；

SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3．．0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；
CASE　Q[].q　IS
・・・・以下省略・・・・・
というように、定数宣言はSUBDESIGNの前に書きます｡

第三節　式を使う

1の次は2、5の次は6、したがって,
Ｑ［］．d=Q[]．q＋１；
と出来ます｡

でも、このままでは、12,13,14,15と行ってしまいます｡
そこで、
IF　Q[]．q　>=H"B"　THEN　　もし、１1以上なら
Q[]．d=H"0"；　　　　　　　　　次は０にする
ELSE　　　　　　　　　　　　　　そうでないなら
Ｑ［］．d=Q[]．q＋１；　　　　　次は＋１
END　IF；　　　　　　　　　　　IFのおわり
と制限をかけます。

よって、以下のように完成します｡

SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3..0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；
IF　Q[]．q　>=H"B"　THEN
Q[]．d=H"0"；
ELSE
Ｑ［］．d=Q[]．q＋１；
END　IF；

【アイデアメモ】

IFの構文にはELSIFというのがあります。

IF　A　THEN　　　　　　もしAなら　　つまりBとCは無視されます。　ということは　（A=True）　
　何とかかんとか
ELSIF　B　THEN　　　もしAでなくてBなら　つまりCは無視されます｡　ということは（A=False）＆（B=True)
　どうたらこうたら
ELSIF　C　THEN　　　もしAでもBでもなくてCなら　　ということは（A=False）　＆　（B=False）　＆　（C=True)
　うんたらかんたら
ELSE　　　　　　　　　　もしどれでもないなら　　ということは（A=False）　＆　（B=False）　＆　（C=False)
　そんなんじゃないなら
END　IF；

優先順位がついてしまいます｡まあ、あいまいさがないということですね。
たとえば、以下のようなアップダウンカウンタを設計するとUPとDOWNが同時にきたらUPが優先されます｡

SUBDESIGN　4bit_12up_down_counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
UP　：INPUT；　　　　　　カウントアップ指示
DOWN　：INPUT；　　　　カウントダウン指示
Q[3．．0]　　：OUTPUT；
CARY　：OUTPUT；　　　桁上がり出力
BROW　：OUTPUT；　　　桁借り出力
）
VARIABLE
Q[3．．0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
Q[]．prn=PRESETN；
IF　UP　THEN　　　　　　　　UPならカウントアップ
　　IF　Q[]．q>=H"B"　THEN　　１１の次は０に
　　　Q[].d= H"0"；
　　　CARY=VCC；
　　ELSE　　　　　　　　　　　　　そうでなければ＋１
　　　Ｑ［］．d=Q[]．q＋１；
　　　CARY=GND；
　　END　IF;
ELSIF　DOWN　THEN　　　　UPでなくてDOWNならカウントダウン
　　IF　((Q[]．q　==　H"0") OR (Q[]．q > H"B"))　THEN　　０の次は１１へ または11を超えていると次は１１へ
　　　Q[].d=H"B"；
　　　BROW=VCC；
　　ELSE　　　　　　　　　　　　　そうでなければー１
　　　Ｑ［］．d=Q[]．q-１；
　　　BROW=GND；
　　END　IF;
ELSE　　　　　　　　　　　　　　UPでもDOWNでもなければホールド
Ｑ［］．d=Q[]．q；
END　IF；
END；




第四節　ここまでの文法のまとめ

【コメント】
　％から始まって％までをコメントします｡行を超えられません｡

【定数】
ＶＣＣ　　　論理　１、真　をいみします。
ＧＮＤ　　論理　０、偽　を意味します｡
X　　　　　0でもあり１でもある。論理的に意味を持たない、つまり関係なしということです。
CONSTANT　PORT1＝H”BCF0”　定数を宣言します｡ここではPORT1がH”BCF0”であることを決めています。

【グループ表記】

並びをあらわすには、
Q[8．．2]．d=（A，B，C，Q[5．．2]．ｑ)　これはQ8．ｄ＝A，Q7．d=B，・・・・Q2．d=Q2.q
あるいは、
A[3．．0]＝B[６．．3]
とできます。対応関係が１：１である必要があります｡

【数値の基数】

デフォルト　　　　：１０進数　0から9で構成される文字列
B”１１０１・・・”　：２進数　０，１で構成される文字列　Bで始まり””で数値を挟む｡
O”１１０１・・・”　：８進数　０から７で構成される文字列　Oで始まり””で数値を挟む｡
H”１２３４ABC”　：16進数　０から9とAからFで構成される文字列　Hで始まり””で数値を挟む｡

【論理演算子】

！　　　NOT　　　例　!　(　A　&　B　)　または　NOT（A　＆　B)
& 　　　AND　　　例　A　&　B　　　　　 または　A　AND　B
！＆　 NAND　　例　A　！＆　B　　　または　A　NAND　B
#　　　 OR　　　　例　A　#　B　　　　 　または　A　OR　B
！#　　NOR　　　例　A　！#　B　　　　または　A　NOR　B
$　　 　EXOR　　 例　A　＄　B　　　 　または　A　XOR　B
！$　　EXNOR　 例　A　！＄　B　　　または　A　XNOR　B

【算術演算子】

＋　正　　　　 例　+5
-　　負　　　　例　-4
＋　加算　　　例　A[3．．0]+B[5．．2]
-　　引き算 　例　A[]-B[]

【比較演算子】

【ブール式の優先順位】

【IO端子宣言】

入力端子名　：　INPUT；
出力端子名　：　OUTPUT；
双方向端子名　：　BIDIR　；


【IF文】

IF　A　THEN
　Aが真のときの文の並び
ELSE
　Aが偽の時の文の並び
END　ＩＦ；

ＩＦ　Ａ　ＴＨＥＮ
　Aが真のときの文の並び
ＥＬＳＩＦ　Ｂ　ＴＨＥＮ
　（！A　＆　Ｂ）が(偽) 真の時の文の並び
ＥＬＳＥ
　AもＢも偽の時の文の並び
END　ＩＦ；
　

【ＣＡＳＥ文】

ＣＡＳＥ　式　ＩＳ
　ＷＨＥＮ　値１　=>
　　式が値１の時の文の並び
　ＷＨＥＮ　値２　=>
　　式が値２の時の文の並び
　　　　　　　・
　　　　　　　・
　　　　　　　・
　ＷＨＥＮ　ＯＴＨＥＲＳ＝＞
　　式が上記いずれの値でもないときの文の並び
　ＥＮＤ　ＣＡＳＥ；


第五節　プリミティブおよびファンクション



使用する定義ファンクションは、include文で先頭に宣言します｡
既定義ファンクションは，

図ー６　既定義ファンクション

のMAXPLUS2のディレクトリーにある拡張子が．incでしめされるものです。非常に多数あります｡
たとえば，dff．incには

FUNCTION dff (d, clk, clrn, prn)
RETURNS (q);

と書かれています｡これは，図-4で説明したDFFプリミティブの宣言です｡したがって，本来は
INCLUDE　”ｄｆｆ．ｉｎｃ”
SUBDESIGN　4bit_12counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
Q[3．．0]　：　DFF；
BEGIN
Q[]．clk=CLOCK；
Q[]．clrn=CLEARN；
　　　　　・
　　　　　・
のように文頭で，ＩＮＣＬＵＤＥしなければならないわけですが、これが省略できるものがあります｡

図ー７　プリミティブ

このprimitivesのディレクトリーに含まれるものです｡

図ー８　フリップフロッププリミティブ

これは、フリップフロップのプリミティブです｡名前だけで拡張子は不要です｡
端子など詳細は，maxplus2の同一名称の．incファイルを見ればわかります。

また、自分で作った回路をファンクションとして同様に再利用できます｡

SUBDESIGN　4bit_12up_down_counter
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
UP　：INPUT；　　　　　　カウントアップ指示
DOWN　：INPUT；　　　　カウントダウン指示
Q[3．．0]　　：OUTPUT；
CARY　：OUTPUT；　　　桁上がり出力
BROW　：OUTPUT；　　　桁借り出力
）
これは、すでに説明した回路のはじめの部分ですが、これを呼び出すとき，

FUNCTION　4bit_12up_down_counter　（CLOCK，CLEARN，PRESETN，UP，DOWN）　　入力端子名を（）でくくってならべる
　RETURNS（Q[3．．0],CARY,BROW)；　　　同じく出力端子名をRETRUNSにつづいて（）でくくってならべる
SUBDESIGN　mega
（
CLOCK　：INPUT；
　　　　　・
　　　　　・
）
VARIABLE
C1，C2　：4bit_12up_down_counter；　　C1,C2は4bit_12up_down_counterであることの宣言

このようにすることで,自分の回路をファンクションとして使用できます｡端子は．をつけて指定します｡
C1．UP　=　A　&　B；
といった具合です。

良く使う代表的なプリミティブはDFF、DFFE,TRI、NODE,SOFTくらいな物でしょう｡

NODEは、回路記述の中で使用される出力端子です｡入力出力端子としてには外に出てきません｡コンパイルの論理展開でも消滅しません。
たとえば、
VARIABLE
good　：　NODE；
bad　　：　SOFT；

という風に使います｡SOFTは、仮の端子で回路記述の中で使用されますが、コンパイルの論理展開で消滅してもよい端子です｡

TRIは、スリーステートバッファで

図ー９　TRIプリミティブ
となっています｡今下の回路の場合，

図ー10　TRIバッファの回路


VARIABLE
BUF1,BUF2　：　TRI；
と宣言して
out=BUF1(in1,oe1）；　
out=BUF2(in2,oe2）；　
という回路記述となります｡

DFFはDFFです。DFFEはDFFにenable端子がついたもので,enableが真のときDFFとして機能しますが、enableが偽のときホールドします｡
JKFFはJKFFです。JKFFEはJKFFにenable端子がついたもので,enableが真のときJKFFとして機能しますが、enableが偽のときホールドします｡
SRFFはSRFFです。SRFFEはSRFFにenable端子がついたもので,enableが真のときSRFFとして機能しますが、enableが偽のときホールドします｡
TFFはTFFです。TFFEはTFFにenable端子がついたもので,enableが真のときTFFとして機能しますが、enableが偽のときホールドします｡

以下に示す例はDFFEを使った例です。これは8bitラッチでloadがVCCの間、クロックの立ち上がりでDをラッチします｡loadがGNDならホールドです。
SUBDESIGN　8bit_latch
（
clock 　　 ：　INPUT；
resetn　　 ：　INPUT；
load　 　　 ：　INPUT；
D[7．．0]　：　INPUT；
Q[7．．0］　：　OUTPUT；
）
VARIABLE
Q[7．．0] ： DFFE；
BEGIN
Ｑ［］．ｃｌｋ　=　clock；
Ｑ［］．clrn　=　resetn；
Ｑ［］．d　=　D［］；
Ｑ［］．ｅｎａ　=　load；
END；

これは、非同期リセットで格好が悪いなら,
SUBDESIGN　8bit_latch
（
clock 　　 ：　INPUT；
resetn　　 ：　INPUT；
load　 　　 ：　INPUT；
D[7．．0]　：　INPUT；
Q[7．．0］　：　OUTPUT；
）
VARIABLE
Q[7．．0] ： DFFE；
BEGIN
Ｑ［］．ｃｌｋ=clock；
IF　！resetn　THEN
　　Ｑ［］．ena　=　VCC；
　　Ｑ［］．d　＝　H”00”；
ELSE
　　Q[].ena　=　load；
　　Ｑ［］．d　=　D［］；
END　IF；
END；

とすれば、どうでしょう？

第六節　ステートマシン

カウンタは順序機械ですからステートマシンでもあるわけです。

SUBDESIGN　4bit_12counter_state_machine
（
CLOCK　：INPUT；
CLEARN　：INPUT；
PRESETN　：INPUT；
Q[3．．0]　　：OUTPUT；
）
VARIABLE
　counter：MACHINE　 counterがステートマシンであるという宣言です。
　　　　　　　OF　BITS　（Q[3．．０］）　そのマシンはQ[3．．0]のビットかからなり
　　　　　　　WITH　STATES(　　以下のステートを持っています｡
　　　　　　　　　　　ｚｅｒｏ　=H”0”，ステートの名前と値を決めています｡
　　　　　　　　　　　one　　=H”1”，
　　　　　　　　　　　twｏ　　=H”2”，
　　　　　　　　　　　ｔｈｒｅｅ　=H”3”，
　　　　　　　　　　　ｆｏｕｒ　　=H”4”，
　　　　　　　　　　　ｆｉｖｅ　　 =H”5”，
　　　　　　　　　　　ｓｉｘ　　　=H”6”，
　　　　　　　　　　　ｓｅｖｅｎ　=H”7”，
　　　　　　　　　　　ｅｉｇｈｔ　 =H”8”，
　　　　　　　　　　　ｎｉｎｅ　　=H”9”，
　　　　　　　　　　　ｔｅｎ　　　=H”A”，
　　　　　　　　　　　ｅｌｅｖｅｎ　=H”B”）；
BEGIN
counter．clk=CLOCK；
IF !CLEARN THEN　　　　CLEARNのときcounterをzeroにします｡
　　counter=zero；
ELSIF　!PRESETN　THEN　PRESETNのときcounterをelevenにします｡
　　counter=eleven;
ELSE　　　　　　　　　　　　　　そうでないとき，以下のステートを遷移します｡
　CASE　counter　IS
　　WHEN　zero　=>
　　　 counter = one；
　　WHEN　one　=>
　　　 counter = two；
　　WHEN　two　=>
　　　 counter = three；
　　WHEN　three　=>
　　　 counter = four；
　　WHEN　four　=>
　　　 counter = five；
　　WHEN　five　=>
　　　 counter = six；
　　WHEN　six　=>
　　　 counter = seven；
　　WHEN　seven　=>
　　　 counter = eight；
　　WHEN　eight　=>
　　　 counter = nine；
　　WHEN　nine　=>
　　　 counter = ten；
　　WHEN　ten　=>
　　　 counter = eleven；
　　WHEN　eleven　=>
　　　 counter = zero；
　　WHEN OTHERS =>
　　　counter = zero；
　　END CASE；
　END　IF；
END；

さてここではCASE　文を使いましたがTABLE文でもかけます｡

以上、カウンタを用いてほとんどのコマンドを説明してきました｡




第二章　組合せ回路

第一節　デコーダ

デコーダは、第一章の説明から想像がつくようにTABLEまたはCASE、あるいは比較演算子でかけます｡

比較演算子を使った場合を示します｡
IO_PORT　=　(IO_ADRESS[7．．0] == H"3E")；

では、以下に示される真理値表の設計を復習をかねてTABLEを使ってやって見ましょう｡

図ー１１　　　真理値表


SUBDESIGN　decoder_table
（
G1　：　INPUT；
G2A，G2B　：　INPUT；
A，B，C　：　INPUT；
Y［7．．０］：OUTPUT；
）
BEGIN
TABLE
G1，G2A，G2B，A，B，C　=>　Y[7．．０］；　　　　　こういう風にまとめると
０，　 X，　 X，　 X，X，X　=>　B"１１１１１１１１”；　B"１１１１１１１１”のようにかけます｡
１， 　１，　 X，　 X，X，X　=>　B"１１１１１１１１”；
１，　 ０，　 １，　 X，X，X　=>　B"１１１１１１１１”；
１，　 ０，　 ０，　 ０，０，０　=>　B"１１１１１１１０”；
１，　 ０，　 ０，　 ０，０，１　=>　B"１１１１１１０１”；
１，　 ０，　 ０，　 ０，１，０　=>　B"１１１１１０１１”；
１，　 ０，　 ０，　 ０，１，１　=>　B"１１１１０１１１”；
１，　 ０，　 ０，　 １，０，０　=>　B"１１１０１１１１”；
１，　 ０，　 ０，　 １，０，１　=>　B"１１０１１１１１”；
１，　 ０，　 ０，　 １，１，０　=>　B"１０１１１１１１”；
１，　 ０，　 ０，　 １，１，１　=>　B"０１１１１１１１”；
END　TABLE；
END；

となりますね。もっと楽にはならないでしょうか｡

SUBDESIGN　decoder_table1
（
G1　：　INPUT；
G2A，G2B　：　INPUT；
A，B，C　：　INPUT；
Y［7．．０］：OUTPUT；
）
BEGIN
TABLE
G1，G2A，G2B，（A，B，C）　=>　Y[7．．０］；　　　　　A，B，Cを（A，B，C）にまとめると
０，　 X，　 X，　 B"XXX"　=>　B"１１１１１１１１”；　B"XXX”のようにかけます｡ただし、O"X"と書くことはできません｡
１， 　１，　 X，　 B"XXX"　=>　B"１１１１１１１１”；
１，　 ０，　 １，　 B"XXX"　=>　B"１１１１１１１１”；
１，　 ０，　 ０，　 O"0"　　　=>　B"１１１１１１１０”；　O"0"という風にも出来ます｡
１，　 ０，　 ０，　 O"1"　　　=>　B"１１１１１１０１”；
１，　 ０，　 ０，　 O"2"　　　=>　B"１１１１１０１１”；
１，　 ０，　 ０，　 O"3"　　　=>　B"１１１１０１１１”；
１，　 ０，　 ０，　 O"4"　　　=>　B"１１１０１１１１”；
１，　 ０，　 ０，　 O"5"　　　=>　B"１１０１１１１１”；
１，　 ０，　 ０，　 O"6"　　　=>　B"１０１１１１１１”；
１，　 ０，　 ０，　 O"7"　　　=>　B"０１１１１１１１”；
END　TABLE；
END；


では、CASEを使って書いてみましょう｡すると、Y0からY7まで毎回全部書くことになるのではと思うでしょう｡でもDEFAULTSを使うと楽が出来ます｡
DEFAULTSは、指定しないときはDEFAULTSで指定した値になるというものです｡

SUBDESIGN　decoder_case
（
G1　：　INPUT；
G2A，G2B　：　INPUT；
A，B，C　：　INPUT；
Y［7．．０］：OUTPUT；
）
BEGIN
DEFAULTS
　　Y［７．．０］=VCC；　　Y［７．．０］は断わりがないときはVCCであるという宣言です｡
END　DEFAULTS；
IF　（G1　＆　（！G2A)　＆（！G2B)）　THEN　Y0からY7が０になる条件です｡
　CASE　（A，B，C）　IS
　WHEN　O"0"　=>
　　　Y0=GND；
　WHEN　O"１"　=>
　　　Y1=GND；
　WHEN　O"２"　=>
　　　Y2=GND；
　WHEN　O"３"　=>
　　　Y3=GND；
　WHEN　O"４"　=>
　　　Y4=GND；
　WHEN　O"５"　=>
　　　Y5=GND；
　WHEN　O"６"　=>
　　　Y6=GND；
　WHEN　O"７"　=>
　　　Y7=GND；
　END　CASE；
END　IF；
END；

以上で大概のコマンドを説明してきました｡

第二節　スリーステートバッファ

双方向バスは

SUBDESIGN　bus
（
dir　：　INPUT；
ena　：　INPUT；
I[7．．0]　：　BIDIR；
Y［7．．0］：　BIDIR；
）
BEGIN
Y7 =TRI(I7,ena & dir);　ena & dirが真ならIからYへ　　［］は使えない｡
Y6 =TRI(I6,ena & dir);
Y5 =TRI(I5,ena & dir);
Y4 =TRI(I4,ena & dir);
Y3 =TRI(I3,ena & dir);
Y2 =TRI(I2,ena & dir);
Y1 =TRI(I1,ena & dir);
Y0 =TRI(I0,ena & dir);
I7 = TRI(Y7,ena & !dir);　ena & ！dirが真ならYからIへ　
I6 = TRI(Y6,ena & !dir);
I5 = TRI(Y5,ena & !dir);
I4 = TRI(Y4,ena & !dir);
I3 = TRI(Y3,ena & !dir);
I2 = TRI(Y2,ena & !dir);
I1 = TRI(Y1,ena & !dir);
I0 = TRI(Y0,ena & !dir);
END；


図ー１２　シミュレーション結果


第三節　ランダムロジック

ランダムロジックは、たとえば，
OUT=！A　＆　（B　＃　C)；
という風に書いてゆきます｡

グループ表記のばあい、
a & b[3..0]　→　（a　&　b3 ,　a　&　b2 , a　&　b1 ,　a　&　b0）　と展開されます｡
（a，b)　＆　（ｃ，ｄ）　→　（a　&　c　,　b　&　d)　と展開されます｡
（a , b , c)　&　2　→　（ a , b , c)　&　B"010"　→　（a　&　0 ,　b　&　1 ,　c　&　0)→　（0　,　b　,　0)　となります｡

また、加算器は算術演算子を使い
OUT[3..0]=a[3..0]+b[3..0]；
a[3..0],b[3..0]の加算は、桁上がりが出ますので
OUT[4..0]=(B"0",a[3..0])+(B"0",b[3..0])；とします｡
となります｡

算術比較器は算術比較演算子を使い、
GE_out=（　A[]　>=　B[]　)；
とかけます｡




第三章　プリミティブ（マクロファンクション）の利用

第一節　74シリーズの応用

74,4000シリーズは、ロジックSSI、MSIの標準です｡随分いろいろとありましたが、現在このくらい知っておれば,十分でしょう｡これからはずれると実際手に入りにくいですから....

74シリーズは74XXから始まって、74LSXXとなり、７４HCXXとなりました｡XXが機能を表しています｡XXが同じなら同じ機能です｡たとえば，74163は同期式の16進カウンタです｡

表　　74163　の端子の説明

74163カウンタは,完全同期式ですからクロックの立ち上がりで変化します｡LD,CLRが変化してもクロックが立ち上がらない限り、HでもLでも動作しません｡


図ー１３　10進同期カウンタ

74163は16進カウンタですが、これは、１０進カウンタを構成しています｡動作は0,1,2,3,4,5,6,7,8,9ときて9のときNANDゲートが出力して次にはロードがかかるものです｡ロードされる値は０なので,９の次のロードで0になり、結果として10進カウンタになります｡9になるとRCOがHになり、上位の桁のカウントイネーブルとなります｡

ここでは、ロードで０にしていますが,74163は同期式ですからCLRでも出来ます｡ロードを使っていますから、非同期クリアの74161でも同じです｡

さて、以下のように記述します｡

１行目は使用するマクロファンクション74163をINCLUDEしています｡このままでは何がなんだかわからないので，2,3行にコメントを入れておきました｡
13行目でcounterが74163であることを宣言しています｡
23行目がNANDゲートとldn（ロード端子）との結線で、24行目がANDゲートでRCOを作っています｡後の結線は回路図のままです｡



図ー１４　シミュレーション結果

第二節　ファンクションの利用

自分の作った回路をファンクションとして同じように利用できます｡

そこで、少し手直しして、


図ー１５　カウンタユニット

とします｡これを３つ並べて3桁のカウンタを作ります｡

図ー１６　全体の回路

動作を説明します｡1の位のカウンタが9になると桁上がりが出ます｡
RCOがHになって，10の位のカウンタのenaがHになり10の位のカウンタは次のクロックで一つだけカウントします｡
つまり、09,19,29,39,49,59,69,79,89,99の時にだけカウント許可が出て次のクロックで一つ増えます｡
すると、10,20,30,40,50,60,70,80,90,00となるわけです｡
100の位のカウンタのenaは99,199,299,399,499,599,699,799,899,999の時にHになってカウント許可になり次のクロックで一つ増えます｡
したがって次は100,200,300,400,500,600,700,800,900,000となるわけです｡

1,10,100の位のカウンタは、10進カウンタなので,0から９までしかカウントしません｡
ですから、見かけ上3桁になるようホールドとカウントを繰り返すわけです｡
100の位のカウンタはほとんどホールドばかりですね｡


では、まず、カウンタユニットの設計です。

となります｡


図ー１７　シミュレーション

enaがHでカウントLでホールドしてますね｡

全体は、

です。C1は1の位、C10は１０の位、C100は100の位です｡
ここで、1行目で,先ほどの自作ファンクションを呼び出しています｡
FUNCTIONにつづいて名前、つづいて（と）でくくって入力端子名、RETURNSとかいて（と）でくくって出力端子名を書きます｡入力出力端子名は入力（INPUT)，出力（OUTPUT)と宣言したおいたものだけです。双方向ならBIDIRです。


図ー１８　シミュレーション結果




つづく

メインページに戻る