trafic.map.eqn

使用vhdl语言编写的交通灯控制程序

--NUM_COUNT[13] is NUM_COUNT[13]
--operation mode is arithmetic

NUM_COUNT[13]_carry_eqn = A1L17;
NUM_COUNT[13]_lut_out = NUM_COUNT[13] $ (NUM_COUNT[13]_carry_eqn);
NUM_COUNT[13] = DFFEAS(NUM_COUNT[13]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L37 is NUM_COUNT[13]~472
--operation mode is arithmetic

A1L37 = CARRY(!A1L17 # !NUM_COUNT[13]);


--A1L93 is LessThan~556
--operation mode is normal

A1L93 = NUM_COUNT[10] # NUM_COUNT[11] # NUM_COUNT[12] # NUM_COUNT[13];


--NUM_COUNT[14] is NUM_COUNT[14]
--operation mode is arithmetic

NUM_COUNT[14]_carry_eqn = A1L37;
NUM_COUNT[14]_lut_out = NUM_COUNT[14] $ (!NUM_COUNT[14]_carry_eqn);
NUM_COUNT[14] = DFFEAS(NUM_COUNT[14]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L57 is NUM_COUNT[14]~476
--operation mode is arithmetic

A1L57 = CARRY(NUM_COUNT[14] & (!A1L37));


--NUM_COUNT[15] is NUM_COUNT[15]
--operation mode is arithmetic

NUM_COUNT[15]_carry_eqn = A1L57;
NUM_COUNT[15]_lut_out = NUM_COUNT[15] $ (NUM_COUNT[15]_carry_eqn);
NUM_COUNT[15] = DFFEAS(NUM_COUNT[15]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L77 is NUM_COUNT[15]~480
--operation mode is arithmetic

A1L77 = CARRY(!A1L57 # !NUM_COUNT[15]);


--NUM_COUNT[16] is NUM_COUNT[16]
--operation mode is arithmetic

NUM_COUNT[16]_carry_eqn = A1L77;
NUM_COUNT[16]_lut_out = NUM_COUNT[16] $ (!NUM_COUNT[16]_carry_eqn);
NUM_COUNT[16] = DFFEAS(NUM_COUNT[16]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L97 is NUM_COUNT[16]~484
--operation mode is arithmetic

A1L97 = CARRY(NUM_COUNT[16] & (!A1L77));


--NUM_COUNT[17] is NUM_COUNT[17]
--operation mode is arithmetic

NUM_COUNT[17]_carry_eqn = A1L97;
NUM_COUNT[17]_lut_out = NUM_COUNT[17] $ (NUM_COUNT[17]_carry_eqn);
NUM_COUNT[17] = DFFEAS(NUM_COUNT[17]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L18 is NUM_COUNT[17]~488
--operation mode is arithmetic

A1L18 = CARRY(!A1L97 # !NUM_COUNT[17]);


--A1L04 is LessThan~557
--operation mode is normal

A1L04 = NUM_COUNT[14] # NUM_COUNT[15] # NUM_COUNT[16] # NUM_COUNT[17];


--NUM_COUNT[18] is NUM_COUNT[18]
--operation mode is arithmetic

NUM_COUNT[18]_carry_eqn = A1L18;
NUM_COUNT[18]_lut_out = NUM_COUNT[18] $ (!NUM_COUNT[18]_carry_eqn);
NUM_COUNT[18] = DFFEAS(NUM_COUNT[18]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L38 is NUM_COUNT[18]~492
--operation mode is arithmetic

A1L38 = CARRY(NUM_COUNT[18] & (!A1L18));


--NUM_COUNT[19] is NUM_COUNT[19]
--operation mode is arithmetic

NUM_COUNT[19]_carry_eqn = A1L38;
NUM_COUNT[19]_lut_out = NUM_COUNT[19] $ (NUM_COUNT[19]_carry_eqn);
NUM_COUNT[19] = DFFEAS(NUM_COUNT[19]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L58 is NUM_COUNT[19]~496
--operation mode is arithmetic

A1L58 = CARRY(!A1L38 # !NUM_COUNT[19]);


--NUM_COUNT[20] is NUM_COUNT[20]
--operation mode is arithmetic

NUM_COUNT[20]_carry_eqn = A1L58;
NUM_COUNT[20]_lut_out = NUM_COUNT[20] $ (!NUM_COUNT[20]_carry_eqn);
NUM_COUNT[20] = DFFEAS(NUM_COUNT[20]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L78 is NUM_COUNT[20]~500
--operation mode is arithmetic

A1L78 = CARRY(NUM_COUNT[20] & (!A1L58));


--NUM_COUNT[21] is NUM_COUNT[21]
--operation mode is arithmetic

NUM_COUNT[21]_carry_eqn = A1L78;
NUM_COUNT[21]_lut_out = NUM_COUNT[21] $ (NUM_COUNT[21]_carry_eqn);
NUM_COUNT[21] = DFFEAS(NUM_COUNT[21]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L98 is NUM_COUNT[21]~504
--operation mode is arithmetic

A1L98 = CARRY(!A1L78 # !NUM_COUNT[21]);


--A1L14 is LessThan~558
--operation mode is normal

A1L14 = NUM_COUNT[18] # NUM_COUNT[19] # NUM_COUNT[20] # NUM_COUNT[21];


--A1L24 is LessThan~559
--operation mode is normal

A1L24 = A1L83 # A1L93 # A1L04 # A1L14;


--NUM_COUNT[22] is NUM_COUNT[22]
--operation mode is arithmetic

NUM_COUNT[22]_carry_eqn = A1L98;
NUM_COUNT[22]_lut_out = NUM_COUNT[22] $ (!NUM_COUNT[22]_carry_eqn);
NUM_COUNT[22] = DFFEAS(NUM_COUNT[22]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L19 is NUM_COUNT[22]~508
--operation mode is arithmetic

A1L19 = CARRY(NUM_COUNT[22] & (!A1L98));


--NUM_COUNT[23] is NUM_COUNT[23]
--operation mode is arithmetic

NUM_COUNT[23]_carry_eqn = A1L19;
NUM_COUNT[23]_lut_out = NUM_COUNT[23] $ (NUM_COUNT[23]_carry_eqn);
NUM_COUNT[23] = DFFEAS(NUM_COUNT[23]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L39 is NUM_COUNT[23]~512
--operation mode is arithmetic

A1L39 = CARRY(!A1L19 # !NUM_COUNT[23]);


--NUM_COUNT[24] is NUM_COUNT[24]
--operation mode is arithmetic

NUM_COUNT[24]_carry_eqn = A1L39;
NUM_COUNT[24]_lut_out = NUM_COUNT[24] $ (!NUM_COUNT[24]_carry_eqn);
NUM_COUNT[24] = DFFEAS(NUM_COUNT[24]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L59 is NUM_COUNT[24]~516
--operation mode is arithmetic

A1L59 = CARRY(NUM_COUNT[24] & (!A1L39));


--NUM_COUNT[25] is NUM_COUNT[25]
--operation mode is arithmetic

NUM_COUNT[25]_carry_eqn = A1L59;
NUM_COUNT[25]_lut_out = NUM_COUNT[25] $ (NUM_COUNT[25]_carry_eqn);
NUM_COUNT[25] = DFFEAS(NUM_COUNT[25]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L79 is NUM_COUNT[25]~520
--operation mode is arithmetic

A1L79 = CARRY(!A1L59 # !NUM_COUNT[25]);


--A1L34 is LessThan~560
--operation mode is normal

A1L34 = NUM_COUNT[22] # NUM_COUNT[23] # NUM_COUNT[24] # NUM_COUNT[25];


--A1L44 is LessThan~561
--operation mode is normal

A1L44 = NUM_COUNT[26] # NUM_COUNT[27] # A1L24 # A1L34;


--A1L931 is Select~1333
--operation mode is normal

A1L931 = CUR_STATE.c & SIGNAL_F & SIGNAL_M;


--A1L041 is Select~1334
--operation mode is normal

A1L041 = A1L721 & (A1L931 # CUR_STATE.d & !A1L921) # !A1L721 & (CUR_STATE.d & !A1L921);


--A1L92 is CUR_STATE~323
--operation mode is normal

A1L92 = !SIGNAL_F & (SIGNAL_M # A1L721);


--A1L141 is Select~1335
--operation mode is normal

A1L141 = CUR_STATE.c & (!SIGNAL_M # !SIGNAL_F);


--A1L241 is Select~1337
--operation mode is normal

A1L241 = CUR_STATE.b & (A1L921 # A1L931 & !A1L721) # !CUR_STATE.b & (A1L931 & !A1L721);


--A1L451 is S~583
--operation mode is normal

A1L451 = CUR_STATE.a & (SIGNAL_F $ !SIGNAL_M # !CUR_STATE.c) # !CUR_STATE.a & (SIGNAL_F $ !SIGNAL_M);


--A1L551 is S~584
--operation mode is normal

A1L551 = A1L451 & !\COUNT:CLR & (\COUNT:S[2] $ A1L11);


--A1L651 is S~585
--operation mode is normal

A1L651 = A1L01 & !\COUNT:CLR & (A1L431 # !A1L22);


--A1L32 is COUNT~86
--operation mode is normal

A1L32 = SIGNAL_F & SIGNAL_M;


--A1L031 is reduce_nor~271
--operation mode is normal

A1L031 = A1L9 & A1L451 & !\COUNT:CLR & !A1L91;


--A1L751 is S~587
--operation mode is normal

A1L751 = A1L31 & !\COUNT:CLR & (A1L431 # !A1L22);


--A1L321 is reduce_nor~1
--operation mode is normal

A1L321 = A1L031 & A1L751 & A1L651 & !A1L551;


--A1L421 is reduce_nor~2
--operation mode is normal

A1L421 = A1L031 & A1L551 & !A1L751 & !A1L651;


--A1L341 is Select~1339
--operation mode is normal

A1L341 = A1L431 & (!A1L421) # !A1L431 & A1L32 & !A1L321;


--A1L441 is Select~1340
--operation mode is normal

A1L441 = CUR_STATE.c & (!SIGNAL_M) # !CUR_STATE.c & !CUR_STATE.a & !SIGNAL_F;


--A1L03 is CUR_STATE~324
--operation mode is normal

A1L03 = A1L321 & (!SIGNAL_F & !SIGNAL_M);


--A1L541 is Select~1342
--operation mode is normal

A1L541 = CUR_STATE.c & SIGNAL_M & (!SIGNAL_F) # !CUR_STATE.c & !SIGNAL_M & !CUR_STATE.a & SIGNAL_F;


--A1L641 is Select~1343
--operation mode is normal

A1L641 = A1L741 # A1L321 & (A1L531 # A1L931);


--NUM_COUNT[5] is NUM_COUNT[5]
--operation mode is arithmetic

NUM_COUNT[5]_carry_eqn = A1L55;
NUM_COUNT[5]_lut_out = NUM_COUNT[5] $ (NUM_COUNT[5]_carry_eqn);
NUM_COUNT[5] = DFFEAS(NUM_COUNT[5]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L75 is NUM_COUNT[5]~524
--operation mode is arithmetic

A1L75 = CARRY(!A1L55 # !NUM_COUNT[5]);


--NUM_COUNT[4] is NUM_COUNT[4]
--operation mode is arithmetic

NUM_COUNT[4]_carry_eqn = A1L35;
NUM_COUNT[4]_lut_out = NUM_COUNT[4] $ (!NUM_COUNT[4]_carry_eqn);
NUM_COUNT[4] = DFFEAS(NUM_COUNT[4]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L55 is NUM_COUNT[4]~528
--operation mode is arithmetic

A1L55 = CARRY(NUM_COUNT[4] & (!A1L35));


--NUM_COUNT[3] is NUM_COUNT[3]
--operation mode is arithmetic

NUM_COUNT[3]_carry_eqn = A1L15;
NUM_COUNT[3]_lut_out = NUM_COUNT[3] $ (NUM_COUNT[3]_carry_eqn);
NUM_COUNT[3] = DFFEAS(NUM_COUNT[3]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L35 is NUM_COUNT[3]~532
--operation mode is arithmetic

A1L35 = CARRY(!A1L15 # !NUM_COUNT[3]);


--NUM_COUNT[2] is NUM_COUNT[2]
--operation mode is arithmetic

NUM_COUNT[2]_carry_eqn = A1L94;
NUM_COUNT[2]_lut_out = NUM_COUNT[2] $ (!NUM_COUNT[2]_carry_eqn);
NUM_COUNT[2] = DFFEAS(NUM_COUNT[2]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L15 is NUM_COUNT[2]~536
--operation mode is arithmetic

A1L15 = CARRY(NUM_COUNT[2] & (!A1L94));


--NUM_COUNT[1] is NUM_COUNT[1]
--operation mode is arithmetic

NUM_COUNT[1]_carry_eqn = A1L74;
NUM_COUNT[1]_lut_out = NUM_COUNT[1] $ (NUM_COUNT[1]_carry_eqn);
NUM_COUNT[1] = DFFEAS(NUM_COUNT[1]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L94 is NUM_COUNT[1]~540
--operation mode is arithmetic

A1L94 = CARRY(!A1L74 # !NUM_COUNT[1]);


--NUM_COUNT[0] is NUM_COUNT[0]
--operation mode is arithmetic

NUM_COUNT[0]_lut_out = !NUM_COUNT[0];
NUM_COUNT[0] = DFFEAS(NUM_COUNT[0]_lut_out, CLK, VCC, , , , , A1L44, );

--A1L74 is NUM_COUNT[0]~544
--operation mode is arithmetic

A1L74 = CARRY(NUM_COUNT[0]);


--A1L211 is OUT_L[1]~1516
--operation mode is normal

A1L211 = A1L911 & (SIGNAL_F $ SIGNAL_M # !A1L521) # !A1L911 & (SIGNAL_F $ SIGNAL_M);


--A1L741 is Select~1345
--operation mode is normal

A1L741 = A1L541 # CUR_STATE.a & !CUR_STATE.c & A1L421;


--SIGNAL_F is SIGNAL_F
--operation mode is input

SIGNAL_F = INPUT();


--SIGNAL_M is SIGNAL_M
--operation mode is input

SIGNAL_M = INPUT();


--CLK is CLK
--operation mode is input

CLK = INPUT();


--RM is RM
--operation mode is output

RM = OUTPUT(A1L331Q);


--YM is YM
--operation mode is output

YM = OUTPUT(A1L161Q);


--GM is GM
--operation mode is output

GM = OUTPUT(A1L53Q);


--RF is RF
--operation mode is output

RF = OUTPUT(!A1L331Q);


--YF is YF
--operation mode is output

YF = OUTPUT(A1L951Q);


--GF is GF
--operation mode is output

GF = OUTPUT(A1L33Q);


--OUT_H[0] is OUT_H[0]
--operation mode is output

OUT_H[0] = OUTPUT(A1L301Q);


--OUT_H[1] is OUT_H[1]
--operation mode is output

OUT_H[1] = OUTPUT(A1L501Q);


--OUT_H[2] is OUT_H[2]
--operation mode is output

OUT_H[2] = OUTPUT(GND);


--OUT_H[3] is OUT_H[3]
--operation mode is output

OUT_H[3] = OUTPUT(GND);


--OUT_L[0] is OUT_L[0]
--operation mode is output

OUT_L[0] = OUTPUT(A1L011Q);


--OUT_L[1] is OUT_L[1]
--operation mode is output

OUT_L[1] = OUTPUT(A1L311Q);


--OUT_L[2] is OUT_L[2]
--operation mode is output

OUT_L[2] = OUTPUT(A1L511Q);


--OUT_L[3] is OUT_L[3]
--operation mode is output

OUT_L[3] = OUTPUT(A1L711Q);