From 8fa58608753d33812cb2b8100c17b8aea677503d Mon Sep 17 00:00:00 2001 From: "yu.dongliang" <18588496441@163.com> Date: Fri, 11 Apr 2025 20:07:22 +0800 Subject: [PATCH] add some simple GATE module combined with TTL Nand gate --- cpk/Makefile | 12 +- cpk/ttl_add.cpk | Bin 1959 -> 1955 bytes cpk/ttl_and.cpk | Bin 628 -> 613 bytes cpk/ttl_and2_or.c | 64 ++++ cpk/ttl_and2_or.cpk | Bin 0 -> 944 bytes cpk/ttl_and2_or_test.c | 49 +++ cpk/ttl_if.c | 70 ++++ cpk/ttl_if.cpk | Bin 0 -> 1194 bytes cpk/ttl_if_test.c | 48 +++ cpk/ttl_mla.c | 103 ++++++ cpk/ttl_mla.cpk | Bin 0 -> 2134 bytes cpk/ttl_mla_test.c | 50 +++ cpk/ttl_nand4.c | 104 ++++++ cpk/ttl_nand4.cpk | Bin 0 -> 2109 bytes cpk/ttl_nand4_test.c | 49 +++ cpk/ttl_nand_delay.c | 100 ----- cpk/ttl_nor.cpk | Bin 593 -> 590 bytes cpk/ttl_not.c | 48 +++ cpk/ttl_not.cpk | Bin 0 -> 327 bytes cpk/ttl_or.cpk | Bin 889 -> 860 bytes cpk/ttl_xor.cpk | Bin 1698 -> 1694 bytes main.c | 2 +- scf_eda_pack.c | 182 +++++++++- scf_eda_pack.h | 59 +++ ses_layout.c | 10 +- ses_layout_function.c | 406 ++++++++++++--------- ses_node_analysis.c | 14 +- ses_step_dc_input.c | 8 +- ses_step_draw.c | 804 +++++++++++++++++++---------------------- ses_step_open.c | 6 +- ses_step_topo.c | 47 +-- ses_step_va.c | 8 +- test/Makefile | 4 +- test/fft.c | 2 +- test/main.c | 6 +- 35 files changed, 1480 insertions(+), 775 deletions(-) create mode 100644 cpk/ttl_and2_or.c create mode 100644 cpk/ttl_and2_or.cpk create mode 100644 cpk/ttl_and2_or_test.c create mode 100644 cpk/ttl_if.c create mode 100644 cpk/ttl_if.cpk create mode 100644 cpk/ttl_if_test.c create mode 100644 cpk/ttl_mla.c create mode 100644 cpk/ttl_mla.cpk create mode 100644 cpk/ttl_mla_test.c create mode 100644 cpk/ttl_nand4.c create mode 100644 cpk/ttl_nand4.cpk create mode 100644 cpk/ttl_nand4_test.c delete mode 100644 cpk/ttl_nand_delay.c create mode 100644 cpk/ttl_not.c create mode 100644 cpk/ttl_not.cpk diff --git a/cpk/Makefile b/cpk/Makefile index c91dd6c..fc7f78e 100644 --- a/cpk/Makefile +++ b/cpk/Makefile @@ -1,11 +1,20 @@ -CFILES += ttl_nand.c +#CFILES += ttl_nand.c +#CFILES += ttl_nand4.c #CFILES += ttl_and.c +#CFILES += ttl_and2_or.c #CFILES += ttl_or.c #CFILES += ttl_nor.c +#CFILES += ttl_not.c #CFILES += ttl_xor.c #CFILES += ttl_add.c +#CFILES += ttl_if.c +#CFILES += ttl_mla.c +#CFILES += ttl_mla_test.c +#CFILES += ttl_if_test.c #CFILES += ttl_nand_test.c +#CFILES += ttl_nand4_test.c #CFILES += ttl_and_test.c +#CFILES += ttl_and2_or_test.c #CFILES += ttl_or_test.c #CFILES += ttl_nor_test.c #CFILES += ttl_xor_test.c @@ -17,6 +26,7 @@ CFILES += ttl_nand.c #CFILES += ttl_nand_gate.c #CFILES += ttl_nand_gate2.c #CFILES += rs_gate.c +CFILES += d_gate.c #CFILES += add_gate.c #CFILES += adc_gate.c CFILES += ../scf_eda_pack.c diff --git a/cpk/ttl_add.cpk b/cpk/ttl_add.cpk index e6bbc02d589e7017532b24ae7ba3ee885b059dd6..a7d9303e2f4d9a935809fe6af87cf47e5a0d1312 100644 GIT binary patch literal 1955 zcmZvdziQk-5XMK+6bo6*5LE01VN@LEiYpvf#}&e)3@L&uS55+kgv4M&OhOXK|1_?y za-B!GJ}yF@z>knJm2r{E#UJw1B#W z?D2b*ZJt+OGq1B4#h=j`>LX6Qc@srKLrBc9BZ?DF2b3&dh9_9wN;MWMBs}{0my$*H z`-_^mf0r6Iz!<`*t(qOzs)*#tEe>QX9*gYbXO&fZS@owzVnDI6onT?g>MD&Y;SreZ zsH1A8toG9ml_7Qe&tnA`AL5es=WB;DlBpLwXO6xmgW*1#=GpIaq| zTUCj1Wc1WdV+f`8$H_X==8b03DiV^qhP3-lecWqR%Jv}5U)HLKWP27>`N<<4Bym+~ zA=l~@CaiuXO`U8(POLKy7aguRDbQB9)bAb^12Upu(gU{rW))0&z#3Hq6C~K+)HWi| zJs2z_!8&54Afu_y3-OHlX&X6t;X`euYD7nDpX&0+tIisgvWNZ zvyM`NLBT&RrC=#phHOTdS?3w+BKNyNl|^YKY~T{Nxte2(518|>ao7^oS?bfRFO*LF z#?UXK#kUSZOu=DKK~7%z literal 1959 zcmZvdzfToG5Xa~4CSi+(O!SH+xsWSf%qu96>PfK>6B}b;Y$R#|2GsZ?f{LNFu(IMG zFfp;RlFG_LX>3Uhm5rq(1(n6q@9gc}yW`zLmUry;&3->Kx3lHm-m{JS+uKx7NjVXf zOH76=37#CDCu5v_+d2AvVPoO1zrjQa5fjT2vti4^IXlKb8vQuCdApJ?&j+<3voa@S zt-+_3Z1cIw{I$ft&4SQk89zq1h@;-yUu;xD18B^kql#O8UYVz4@@=?+=`BQuXT^le z;9w#dXTM(s8@IBC4mgG|wN(cjQB^|)c8h_W)nlB!c^PCgng0`+7*uR*Cs^F_N~01U zg2@g$s<`F*%&(^%DnlM_e*`R}SYVpMI^8^vWqPn0RgHzb8j@~u57#3Uva1fQfm@bd zw_t)>Rf%zAbZVzDh62-K(!;b9v{spr)hVX6*TKk9(v-^fFdc41Rn263UaRs&5bZaw zl~!`9P;tXgNnK8{1v#-BDH7V?6w>L_^GL1-sZrHPuBQgO4k% zD|0A?Wm~Wv;1;O*w2#M1mDXu2i$B^pf^dlVKAb5ZTc8TXpjOB?m$*`VC{H!(hLq&S ziCM#Pf%^svK&|F#8H<8nJV?P(vJBV^v9k{c!B-7OrAbj*sZMZ-$6U>^#UV421=! aQ8ku9V&IcC4eP0z)ZVEwBL9H>A^!*UIRM%K diff --git a/cpk/ttl_and.cpk b/cpk/ttl_and.cpk index 4ddd4b3764229442de5f927d18498a62e3d87a9c..79e34d1f4374789b1e14c8e9b36c3505e19cb8a4 100644 GIT binary patch delta 309 zcmeyu@|0zQ3hSor(|<-z)Kp+y4QBYsX>9~C4t2ozK_T$#cJ5)}<49Xg2;A&R5qAMO*7sOb0rDt?2C zKcJwFn01oN@vx#z;vLVW+A3WZfCB^)RD`cJ zsw-E!J!oEKj6&OOa_R;o92lhjNM9u3DO*(M8WbeYP2JfQiAxOLO%D5EWJBZk}VPUNA5+P zQO|2s;Qblh=m=doFrB%!`en(aZe?vVJ0S>YMY5Jri#&Weyex zlouYETh3qz!T?_3Ep}zGejmUXgCQ7rAPppPNHUqZ7(HC1GEwm}{umFZ1j2Ga +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* NAND0; + ScfEcomponent* NAND1; + ScfEcomponent* NAND2; + + ScfEfunction* f = scf_efunction__alloc("ttl_and2_or"); + + EDA_INST_ADD_COMPONENT(f, NAND0, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND1, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND2, SCF_EDA_NAND); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND1, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND2, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND1, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND2, SCF_EDA_NAND_NEG); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_OUT, NAND2, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_OUT, NAND2, SCF_EDA_NAND_IN1); + + NAND0->pins[SCF_EDA_NAND_POS]->flags = SCF_EDA_PIN_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->flags = SCF_EDA_PIN_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + NAND0->pins[SCF_EDA_NAND_IN1]->flags = SCF_EDA_PIN_IN; + NAND1->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN; + NAND1->pins[SCF_EDA_NAND_IN1]->flags = SCF_EDA_PIN_IN; + NAND2->pins[SCF_EDA_NAND_OUT]->flags = SCF_EDA_PIN_OUT; + + NAND0->pins[SCF_EDA_NAND_POS]->ic_lid = SCF_EDA_AND2_OR_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->ic_lid = SCF_EDA_AND2_OR_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_AND2_OR_IN0; + NAND0->pins[SCF_EDA_NAND_IN1]->ic_lid = SCF_EDA_AND2_OR_IN1; + NAND1->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_AND2_OR_IN2; + NAND1->pins[SCF_EDA_NAND_IN1]->ic_lid = SCF_EDA_AND2_OR_IN3; + NAND2->pins[SCF_EDA_NAND_OUT]->ic_lid = SCF_EDA_AND2_OR_OUT; + + int ret = ses_layout_function(f, 100); + if (ret < 0) + return ret; + + ses_draw(f, "ttl_and2_or.png", f->x, f->y, f->w, f->h, 0, -1); + + long len = 0; + uint8_t* buf = NULL; + + ScfEfunction_pack(f, &buf, &len); + ScfEfunction_free(f); + f = NULL; + + FILE* fp = fopen("./ttl_and2_or.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_and2_or.cpk b/cpk/ttl_and2_or.cpk new file mode 100644 index 0000000000000000000000000000000000000000..c47586dee92c4e8ff408ba7459392bb32c9df56f GIT binary patch literal 944 zcmZuwF-yZx5WX}g-0+Y$WJn-{42}-Ai;y9Rqr2cB7Qs<0NPmEXlao{D{tyRo5D^vq z2aZloP91{Zy_eTS+e>NFcVF(l@9xXabb3BMy*L|iqKQA>s>6-r z{UO!YF;PUs#MUwk<7NqL;`w8X8)XhAB-JLWb@iI~>QyoILsTCP9LSJibT_>^zF&P3 z)jw#4j|DjqDfPaMUbiZvs7s)mGM%^+R#Bkn7<3ps{Gl|eY^exRgz(h|-9LL!ki(db z#TBB7_udsz%npV)!=r{1Mn@f_kI<=D)OTL5yIwtVk(e z{z;KFQUWMQK{X-UALw`dPA5gclkGa5#Y}lB$Vw`d;tJ7L0qgB(MM<$x*p|YT zVmik^b~^~(!a>9-_5g3Cw>~|}kX7EA6u3!EMFQ89u%CBQ@RLG}kiiImYZ1;z!A**= z!kQ#Wm~-@U`)ik|`9#=PfX7{4m)CAk^Qnjh5t5vx1XHKhOGcWa+_Dv;KGC-XO;V3@ jbE{O2i>QQ|P)c#213|!{Bp28LK)MJ7#$4YF>aX}0VeM@x literal 0 HcmV?d00001 diff --git a/cpk/ttl_and2_or_test.c b/cpk/ttl_and2_or_test.c new file mode 100644 index 0000000..6ce9508 --- /dev/null +++ b/cpk/ttl_and2_or_test.c @@ -0,0 +1,49 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* B; + ScfEcomponent* R; + ScfEcomponent* AND2_OR; + + ScfEboard* b = scf_eboard__alloc(); + ScfEfunction* f = scf_efunction__alloc("and2_or_test"); + + EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery); + EDA_INST_ADD_COMPONENT(f, R, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, AND2_OR, SCF_EDA_AND2_OR); + + B->pins[SCF_EDA_Battery_POS]->flags = SCF_EDA_PIN_POS; + B->pins[SCF_EDA_Battery_NEG]->flags = SCF_EDA_PIN_NEG; + + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_POS, AND2_OR, SCF_EDA_AND2_OR_POS); + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_NEG, AND2_OR, SCF_EDA_AND2_OR_NEG); + EDA_PIN_ADD_PIN(R, 1, AND2_OR, SCF_EDA_AND2_OR_OUT); + EDA_PIN_ADD_PIN(R, 0, B, SCF_EDA_Battery_NEG); + + AND2_OR->pins[SCF_EDA_AND2_OR_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + AND2_OR->pins[SCF_EDA_AND2_OR_IN1]->flags = SCF_EDA_PIN_IN; + AND2_OR->pins[SCF_EDA_AND2_OR_IN2]->flags = SCF_EDA_PIN_IN; + AND2_OR->pins[SCF_EDA_AND2_OR_IN3]->flags = SCF_EDA_PIN_IN; + AND2_OR->pins[SCF_EDA_AND2_OR_OUT]->flags = SCF_EDA_PIN_OUT; + + scf_eboard__add_function(b, f); + + long len = 0; + uint8_t* buf = NULL; + + ScfEboard_pack(b, &buf, &len); + ScfEboard_free(b); + b = NULL; + + FILE* fp = fopen("./and2_or_test.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_if.c b/cpk/ttl_if.c new file mode 100644 index 0000000..2fbaa0e --- /dev/null +++ b/cpk/ttl_if.c @@ -0,0 +1,70 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* NAND0; + ScfEcomponent* NAND1; + ScfEcomponent* NAND2; + ScfEcomponent* NAND3; + + ScfEfunction* f = scf_efunction__alloc("ttl_if"); + + EDA_INST_ADD_COMPONENT(f, NAND0, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND1, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND2, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND3, SCF_EDA_NAND); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND1, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND2, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND3, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND1, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND2, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND3, SCF_EDA_NAND_NEG); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_OUT, NAND3, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND2, SCF_EDA_NAND_OUT, NAND3, SCF_EDA_NAND_IN1); + + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_IN0, NAND1, SCF_EDA_NAND_IN1); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_IN0, NAND0, SCF_EDA_NAND_IN1); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_OUT, NAND2, SCF_EDA_NAND_IN1); + + NAND0->pins[SCF_EDA_NAND_POS]->flags = SCF_EDA_PIN_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->flags = SCF_EDA_PIN_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + NAND1->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN; + NAND2->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN; + NAND3->pins[SCF_EDA_NAND_OUT]->flags = SCF_EDA_PIN_OUT; + + NAND0->pins[SCF_EDA_NAND_POS]->ic_lid = SCF_EDA_IF_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->ic_lid = SCF_EDA_IF_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_IF_TRUE; + NAND1->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_IF_COND; + NAND2->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_IF_FALSE; + NAND3->pins[SCF_EDA_NAND_OUT]->ic_lid = SCF_EDA_IF_OUT; + + int ret = ses_layout_function(f, 100); + if (ret < 0) + return ret; + + ses_draw(f, "ttl_if.png", f->x, f->y, f->w, f->h, 0, -1); + + long len = 0; + uint8_t* buf = NULL; + + ScfEfunction_pack(f, &buf, &len); + ScfEfunction_free(f); + f = NULL; + + FILE* fp = fopen("./ttl_if.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_if.cpk b/cpk/ttl_if.cpk new file mode 100644 index 0000000000000000000000000000000000000000..3702fea7d523110eacec509f59e7f4b094d39c5e GIT binary patch literal 1194 zcmZvcy^0i35QVF|D=4s#8+6bu&2ocfqYZS!32tC0DE{JzqF^8h1_t{GMn)T%35JII z07gE6k6|Pm7#R$nbMM@l>7BU@Lr?eDRp->tOy}nx-n@S&L89~`5(gC%$JO?%x{Kx4 z@8jEhcO-r4L>dtl4TGwwD=s%E$op&ZY|NmEEp8&B?J&2WlSzNt^rOv?BcZ7|Bd<@* znI3mYo2ej!nA{}}Nj{a3BK$)4xgZa{FGjpT@p(iL9jL;C=>>0XzMHP2< z`eX+jeSEs6swE4G0SMKNthy2i^-F(I3w#_oO~YJjc)~#GbwjPBf=y_VPcuV>qNrti z%@J=FODICmg6>)R^(^ODwwosT0ZSXIT5`;ag!!yoJ;TFgrJ1fgc(klOUQrP}Pt zdxJJEM>%MA3AAjXf9A;OG2K8VM2;nLPq<9+8-8n^GfpLU2&X~!wd_#5D8Si>=d{4b zhOOc9prR^ROD!8y_l5{uI+qYn(V9B#m*7V$!9Y;7-z-W(8!L4CrA z!$;{DE%G!2Cd7?H5)cZK`ZdXVLN<#^ZVDFMGZ)kVAtG~@aJ8@`W6*%KxODuD0ERkN Q>9naMMM@;y()7Fg4`}O*W&i*H literal 0 HcmV?d00001 diff --git a/cpk/ttl_if_test.c b/cpk/ttl_if_test.c new file mode 100644 index 0000000..45473d9 --- /dev/null +++ b/cpk/ttl_if_test.c @@ -0,0 +1,48 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* B; + ScfEcomponent* R; + ScfEcomponent* IF; + + ScfEboard* b = scf_eboard__alloc(); + ScfEfunction* f = scf_efunction__alloc("if_test"); + + EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery); + EDA_INST_ADD_COMPONENT(f, R, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, IF, SCF_EDA_IF); + + B->pins[SCF_EDA_Battery_POS]->flags = SCF_EDA_PIN_POS; + B->pins[SCF_EDA_Battery_NEG]->flags = SCF_EDA_PIN_NEG; + + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_POS, IF, SCF_EDA_IF_POS); + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_NEG, IF, SCF_EDA_IF_NEG); + EDA_PIN_ADD_PIN(R, 1, IF, SCF_EDA_IF_OUT); + EDA_PIN_ADD_PIN(R, 0, B, SCF_EDA_Battery_NEG); + + IF->pins[SCF_EDA_IF_TRUE ]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + IF->pins[SCF_EDA_IF_COND ]->flags = SCF_EDA_PIN_IN; + IF->pins[SCF_EDA_IF_FALSE]->flags = SCF_EDA_PIN_IN; + IF->pins[SCF_EDA_IF_OUT ]->flags = SCF_EDA_PIN_OUT; + + scf_eboard__add_function(b, f); + + long len = 0; + uint8_t* buf = NULL; + + ScfEboard_pack(b, &buf, &len); + ScfEboard_free(b); + b = NULL; + + FILE* fp = fopen("./if_test.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_mla.c b/cpk/ttl_mla.c new file mode 100644 index 0000000..4a984c9 --- /dev/null +++ b/cpk/ttl_mla.c @@ -0,0 +1,103 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* NAND0; + ScfEcomponent* NAND1; + ScfEcomponent* NAND2; + ScfEcomponent* NAND3; + ScfEcomponent* NAND4; + ScfEcomponent* NAND5; + ScfEcomponent* NAND6; +/* +out = (a & b) ^ (c & d) + = [(a & b) | (c & d)] & ~(a & b & c & d) + = ~[((a NAND b) NAND (c NAND d)) NAND NAND4(a, b, c, d)] + +cf = ~NAND4(a, b, c, d) + */ + ScfEfunction* f = scf_efunction__alloc("ttl_mla"); + + EDA_INST_ADD_COMPONENT(f, NAND0, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND1, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND2, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND3, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND4, SCF_EDA_NAND4); + EDA_INST_ADD_COMPONENT(f, NAND5, SCF_EDA_NAND); + EDA_INST_ADD_COMPONENT(f, NAND6, SCF_EDA_NAND); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND1, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND2, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND3, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND4, SCF_EDA_NAND4_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND5, SCF_EDA_NAND_POS); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_POS, NAND6, SCF_EDA_NAND_POS); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND1, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND2, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND3, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND4, SCF_EDA_NAND4_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND5, SCF_EDA_NAND_NEG); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_NEG, NAND6, SCF_EDA_NAND_NEG); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_OUT, NAND2, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_OUT, NAND2, SCF_EDA_NAND_IN1); + + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_IN0, NAND4, SCF_EDA_NAND4_IN0); + EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_IN1, NAND4, SCF_EDA_NAND4_IN1); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_IN0, NAND4, SCF_EDA_NAND4_IN2); + EDA_PIN_ADD_PIN(NAND1, SCF_EDA_NAND_IN1, NAND4, SCF_EDA_NAND4_IN3); + + EDA_PIN_ADD_PIN(NAND2, SCF_EDA_NAND_OUT, NAND3, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND4, SCF_EDA_NAND4_OUT, NAND3, SCF_EDA_NAND_IN1); + + EDA_PIN_ADD_PIN(NAND3, SCF_EDA_NAND_OUT, NAND5, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND3, SCF_EDA_NAND_OUT, NAND5, SCF_EDA_NAND_IN1); + + EDA_PIN_ADD_PIN(NAND4, SCF_EDA_NAND4_OUT, NAND6, SCF_EDA_NAND_IN0); + EDA_PIN_ADD_PIN(NAND4, SCF_EDA_NAND4_OUT, NAND6, SCF_EDA_NAND_IN1); + + NAND0->pins[SCF_EDA_NAND_POS]->flags = SCF_EDA_PIN_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->flags = SCF_EDA_PIN_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + NAND0->pins[SCF_EDA_NAND_IN1]->flags = SCF_EDA_PIN_IN; + NAND1->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN; + NAND1->pins[SCF_EDA_NAND_IN1]->flags = SCF_EDA_PIN_IN; + NAND5->pins[SCF_EDA_NAND_OUT]->flags = SCF_EDA_PIN_OUT; + NAND6->pins[SCF_EDA_NAND_OUT]->flags = SCF_EDA_PIN_CF; + + NAND0->pins[SCF_EDA_NAND_POS]->ic_lid = SCF_EDA_MLA_POS; + NAND0->pins[SCF_EDA_NAND_NEG]->ic_lid = SCF_EDA_MLA_NEG; + + NAND0->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_MLA_IN0; + NAND0->pins[SCF_EDA_NAND_IN1]->ic_lid = SCF_EDA_MLA_IN1; + NAND1->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_MLA_IN2; + NAND1->pins[SCF_EDA_NAND_IN1]->ic_lid = SCF_EDA_MLA_IN3; + NAND5->pins[SCF_EDA_NAND_OUT]->ic_lid = SCF_EDA_MLA_OUT; + NAND6->pins[SCF_EDA_NAND_OUT]->ic_lid = SCF_EDA_MLA_CF; + + int ret = ses_layout_function(f, 100); + if (ret < 0) + return ret; + + ses_draw(f, "ttl_mla.png", f->x, f->y, f->w, f->h, 0, -1); + + long len = 0; + uint8_t* buf = NULL; + + ScfEfunction_pack(f, &buf, &len); + ScfEfunction_free(f); + f = NULL; + + FILE* fp = fopen("./ttl_mla.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_mla.cpk b/cpk/ttl_mla.cpk new file mode 100644 index 0000000000000000000000000000000000000000..6a52c057e238374612a245efdfca2b616a958118 GIT binary patch literal 2134 zcmZvdzityj5XR^1iL}KEjbMunGS(GVQG9K zh|(dGAxnZckN3qjZ@)R%m|feOUZ>2h5hX-SEJJ3)mW3UA#)q=Qyq!*ResewGhRpbq z5rb!iI@wby+i7Pf=!{V~AZ35GkPn8Dj?8Bfly$j@Kz!G+;he{iUTK zt5J**G%T2T`|L#!vfC={!H*&QRH@nBoGMJgx)BjXthnaw;j;jJYGr@g(G$XB#JLdT z$dwarw6c$p5+1^n9X3yx?Y5Ro;Y;=}m@;Y#j#f;4zqf44G?*%>!W80aNb14;a4QV8 z(L!*;IvJ=%0yL?GbEwr8fiz?BQw?H16yy(*RZraujgVDKNP!hgvxll>0YRaV955!i0{>;#@V``kwDRp?UOj;@TfY9V?oq;-4GMLy$+<@ z#4baYtQgvUxnxKh3>B^mL!!F~Td68S_Jg7Kc7?N z468|0Ugd7kNX!1>gcu#;D~HX9vBQ?chlEF{o0WrMbQH18bx`U@A>RXf> zVR0-ymI2O@u4Zv@DkyD*tXP>|293O5qBWh1(?Mx8YgG=kLzTjfLkeT#yyC9rb(U9W zrJb-97imRnbWHFpFVl*9_GeL6?M`8?U{Ef{iJX?52ZS1k_ zvmLM*B37XgX-U^|ge&Q#){58Nluq&9iK=3hI_%TXnL}wp#)YNTZha3gC{UWO*0TeL zd324=6L2B-l^fv9LQTY9_{Et^Y19FyV_haK^U4h|Bes%q!Z6I>AemJv?!441Nt9jX H?A_Xb8(ZZ# literal 0 HcmV?d00001 diff --git a/cpk/ttl_mla_test.c b/cpk/ttl_mla_test.c new file mode 100644 index 0000000..ccdba07 --- /dev/null +++ b/cpk/ttl_mla_test.c @@ -0,0 +1,50 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* B; + ScfEcomponent* R; + ScfEcomponent* MLA; + + ScfEboard* b = scf_eboard__alloc(); + ScfEfunction* f = scf_efunction__alloc("mla_test"); + + EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery); + EDA_INST_ADD_COMPONENT(f, R, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, MLA, SCF_EDA_MLA); + + B->pins[SCF_EDA_Battery_POS]->flags = SCF_EDA_PIN_POS; + B->pins[SCF_EDA_Battery_NEG]->flags = SCF_EDA_PIN_NEG; + + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_POS, MLA, SCF_EDA_MLA_POS); + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_NEG, MLA, SCF_EDA_MLA_NEG); + EDA_PIN_ADD_PIN(R, 1, MLA, SCF_EDA_MLA_OUT); + EDA_PIN_ADD_PIN(R, 0, B, SCF_EDA_Battery_NEG); + + MLA->pins[SCF_EDA_MLA_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + MLA->pins[SCF_EDA_MLA_IN1]->flags = SCF_EDA_PIN_IN; + MLA->pins[SCF_EDA_MLA_IN2]->flags = SCF_EDA_PIN_IN; + MLA->pins[SCF_EDA_MLA_IN3]->flags = SCF_EDA_PIN_IN; + MLA->pins[SCF_EDA_MLA_OUT]->flags = SCF_EDA_PIN_OUT; + MLA->pins[SCF_EDA_MLA_CF]->flags = SCF_EDA_PIN_CF; + + scf_eboard__add_function(b, f); + + long len = 0; + uint8_t* buf = NULL; + + ScfEboard_pack(b, &buf, &len); + ScfEboard_free(b); + b = NULL; + + FILE* fp = fopen("./mla_test.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_nand4.c b/cpk/ttl_nand4.c new file mode 100644 index 0000000..60d613f --- /dev/null +++ b/cpk/ttl_nand4.c @@ -0,0 +1,104 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* R0; + ScfEcomponent* R1; + ScfEcomponent* R2; + ScfEcomponent* R3; + + ScfEcomponent* D4; + ScfEcomponent* D5; + ScfEcomponent* D6; + ScfEcomponent* D7; + ScfEcomponent* D8; + ScfEcomponent* D9; + ScfEcomponent* T10; + ScfEcomponent* T11; + ScfEcomponent* T12; + + ScfEfunction* f = scf_efunction__alloc("ttl_nand4.cpk"); + + EDA_INST_ADD_COMPONENT(f, R0, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, R1, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, R2, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, R3, SCF_EDA_Resistor); + + EDA_INST_ADD_COMPONENT(f, D4, SCF_EDA_Diode); + EDA_INST_ADD_COMPONENT(f, D5, SCF_EDA_Diode); + EDA_INST_ADD_COMPONENT(f, D6, SCF_EDA_Diode); + EDA_INST_ADD_COMPONENT(f, D7, SCF_EDA_Diode); + EDA_INST_ADD_COMPONENT(f, D8, SCF_EDA_Diode); + EDA_INST_ADD_COMPONENT(f, D9, SCF_EDA_Diode); + + EDA_INST_ADD_COMPONENT(f, T10, SCF_EDA_NPN); + EDA_INST_ADD_COMPONENT(f, T11, SCF_EDA_NPN); + EDA_INST_ADD_COMPONENT(f, T12, SCF_EDA_NPN); + + EDA_PIN_ADD_PIN(R0, 1, R1, 1); + EDA_PIN_ADD_PIN(R0, 1, R2, 1); + + EDA_PIN_ADD_PIN(R0, 0, D4, SCF_EDA_Diode_POS); + EDA_PIN_ADD_PIN(R0, 0, D5, SCF_EDA_Diode_POS); + EDA_PIN_ADD_PIN(R0, 0, D6, SCF_EDA_Diode_POS); + EDA_PIN_ADD_PIN(R0, 0, D7, SCF_EDA_Diode_POS); + EDA_PIN_ADD_PIN(R0, 0, D8, SCF_EDA_Diode_POS); + + EDA_PIN_ADD_PIN(D8, SCF_EDA_Diode_NEG, T10, SCF_EDA_NPN_B); + EDA_PIN_ADD_PIN(R1, 0, T10, SCF_EDA_NPN_C); + EDA_PIN_ADD_PIN(R3, 1, T10, SCF_EDA_NPN_E); + EDA_PIN_ADD_PIN(R3, 0, T11, SCF_EDA_NPN_E); + + EDA_PIN_ADD_PIN(R2, 0, T12, SCF_EDA_NPN_C); + EDA_PIN_ADD_PIN(T12, SCF_EDA_NPN_E, D9, SCF_EDA_Diode_POS); + EDA_PIN_ADD_PIN(T11, SCF_EDA_NPN_C, D9, SCF_EDA_Diode_NEG); + EDA_PIN_ADD_PIN(T11, SCF_EDA_NPN_B, T10, SCF_EDA_NPN_E); + EDA_PIN_ADD_PIN(T12, SCF_EDA_NPN_B, T10, SCF_EDA_NPN_C); + + R0->r = 4000; + R1->r = 1600; + R2->r = 130; + R3->r = 10 * 1000; + + R0->pins[1]->flags = SCF_EDA_PIN_POS; + R3->pins[0]->flags = SCF_EDA_PIN_NEG; + + R0->pins[1]->ic_lid = SCF_EDA_NAND_POS; + R3->pins[0]->ic_lid = SCF_EDA_NAND_NEG; + + D4->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + D5->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN; + D6->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN; + D7->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN; + D9->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_OUT; + + D4->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND4_IN0; + D5->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND4_IN1; + D6->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND4_IN2; + D6->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND4_IN3; + D9->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND4_OUT; + + int ret = ses_layout_function(f, 100); + if (ret < 0) + return ret; + + ses_draw(f, "ttl_nand4.png", f->x, f->y, f->w, f->h, 0, -1); + + long len = 0; + uint8_t* buf = NULL; + + ScfEfunction_pack(f, &buf, &len); + ScfEfunction_free(f); + f = NULL; + + FILE* fp = fopen("./ttl_nand4.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_nand4.cpk b/cpk/ttl_nand4.cpk new file mode 100644 index 0000000000000000000000000000000000000000..d39157778d4e35ae33d32ec9f8fa2cb1adec6137 GIT binary patch literal 2109 zcmZ`)ziSjh6rR0%ffrbgDHfcQEw)%>i$TVaLQ^bgV@cYvcOnz$EyC3|ULWgfA`1%wa2IMae&-(PVFe zPcpE+t$UKNkvCki@37cU!m@tF)H}mSgZ%-ee$-i(^tF(%5#t}q!otG2;ecC5%V%K$ zMSa|`a1YB-i#p3Pn%s>vVtr`og4<^z z_TsCsXv8k+t~LXS<+YJWl9+Bi7X+?0=15F^l0+hF1=N>7K{XkS=E5Qmqn1o)vXr1F zU0@0CG-y6qi>alohhzroA@NE5M6=+8#AReMyt-0$-wVlgq|i4~To20}bxw+yeo>ZO zSn`rgDe>+E?9T_4a*_ZY1D5x&%uqdAPLig^3SlWK|+l-V4$5mDXjKhq+s9I{?POz~eaQYx*Q zsxUT17k3M~Y2jrlXmNonZ!DQ$wA24yz|+y_@csm!r^5)Y_Xcghv<(D@45N7arYgp_+rt%qPo2 zi3ZR+cE!+QjVh-pPUgj zaa`|HsV!ZKtE{x3`eLal+Fj9l;`+e=uAmELDIB>r6$f=CLt1kRuz@ow0Tw$$xPd$D nP?ECLE?5*L4thv-RKg0XSu0X#HY7qQPAyPi5LbMypDz6aKnp+f literal 0 HcmV?d00001 diff --git a/cpk/ttl_nand4_test.c b/cpk/ttl_nand4_test.c new file mode 100644 index 0000000..71a7710 --- /dev/null +++ b/cpk/ttl_nand4_test.c @@ -0,0 +1,49 @@ +#include +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* B; + ScfEcomponent* R; + ScfEcomponent* NAND4; + + ScfEboard* b = scf_eboard__alloc(); + ScfEfunction* f = scf_efunction__alloc("nand4_test"); + + EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery); + EDA_INST_ADD_COMPONENT(f, R, SCF_EDA_Resistor); + EDA_INST_ADD_COMPONENT(f, NAND4, SCF_EDA_NAND4); + + B->pins[SCF_EDA_Battery_POS]->flags = SCF_EDA_PIN_POS; + B->pins[SCF_EDA_Battery_NEG]->flags = SCF_EDA_PIN_NEG; + + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_POS, NAND4, SCF_EDA_NAND4_POS); + EDA_PIN_ADD_PIN(B, SCF_EDA_Battery_NEG, NAND4, SCF_EDA_NAND4_NEG); + EDA_PIN_ADD_PIN(R, 1, NAND4, SCF_EDA_NAND4_OUT); + EDA_PIN_ADD_PIN(R, 0, B, SCF_EDA_Battery_NEG); + + NAND4->pins[SCF_EDA_NAND4_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + NAND4->pins[SCF_EDA_NAND4_IN1]->flags = SCF_EDA_PIN_IN; + NAND4->pins[SCF_EDA_NAND4_IN2]->flags = SCF_EDA_PIN_IN; + NAND4->pins[SCF_EDA_NAND4_IN3]->flags = SCF_EDA_PIN_IN; + NAND4->pins[SCF_EDA_NAND4_OUT]->flags = SCF_EDA_PIN_OUT; + + scf_eboard__add_function(b, f); + + long len = 0; + uint8_t* buf = NULL; + + ScfEboard_pack(b, &buf, &len); + ScfEboard_free(b); + b = NULL; + + FILE* fp = fopen("./nand4_test.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_nand_delay.c b/cpk/ttl_nand_delay.c deleted file mode 100644 index 4ccbda6..0000000 --- a/cpk/ttl_nand_delay.c +++ /dev/null @@ -1,100 +0,0 @@ -#include -#include -#include -#include"ses_core.h" - -int main(int argc, char* argv[]) -{ - ScfEcomponent* R1; - ScfEcomponent* R2; - ScfEcomponent* R3; - ScfEcomponent* R4; - - ScfEcomponent* D10; - ScfEcomponent* D11; - ScfEcomponent* D12; - ScfEcomponent* T2; - ScfEcomponent* D3; - ScfEcomponent* T4; - ScfEcomponent* T5; - ScfEcomponent* C5; - - ScfEfunction* f = scf_efunction__alloc("ttl_nand_delay.cpk"); - - EDA_INST_ADD_COMPONENT(f, R1, SCF_EDA_Resistor); - EDA_INST_ADD_COMPONENT(f, R2, SCF_EDA_Resistor); - EDA_INST_ADD_COMPONENT(f, R3, SCF_EDA_Resistor); - EDA_INST_ADD_COMPONENT(f, R4, SCF_EDA_Resistor); - - EDA_INST_ADD_COMPONENT(f, D10, SCF_EDA_Diode); - EDA_INST_ADD_COMPONENT(f, D11, SCF_EDA_Diode); - EDA_INST_ADD_COMPONENT(f, D12, SCF_EDA_Diode); - EDA_INST_ADD_COMPONENT(f, D3, SCF_EDA_Diode); - - EDA_INST_ADD_COMPONENT(f, T2, SCF_EDA_NPN); - EDA_INST_ADD_COMPONENT(f, T4, SCF_EDA_NPN); - EDA_INST_ADD_COMPONENT(f, T5, SCF_EDA_NPN); - EDA_INST_ADD_COMPONENT(f, C5, SCF_EDA_Capacitor); - - EDA_PIN_ADD_PIN(R1, 1, R2, 1); - EDA_PIN_ADD_PIN(R1, 1, R4, 1); - - EDA_PIN_ADD_PIN(R1, 0, D10, SCF_EDA_Diode_POS); - EDA_PIN_ADD_PIN(R1, 0, D11, SCF_EDA_Diode_POS); - EDA_PIN_ADD_PIN(R1, 0, D12, SCF_EDA_Diode_POS); - - EDA_PIN_ADD_PIN(D12, SCF_EDA_Diode_NEG, T2, SCF_EDA_NPN_B); - EDA_PIN_ADD_PIN(R2, 0, T2, SCF_EDA_NPN_C); - EDA_PIN_ADD_PIN(R3, 1, T2, SCF_EDA_NPN_E); - EDA_PIN_ADD_PIN(R3, 0, T5, SCF_EDA_NPN_E); - - EDA_PIN_ADD_PIN(R4, 0, T4, SCF_EDA_NPN_C); - EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_E, D3, SCF_EDA_Diode_POS); - EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_C, D3, SCF_EDA_Diode_NEG); - EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_B, R3, 1); - EDA_PIN_ADD_PIN(T4, SCF_EDA_NPN_B, R2, 0); - - EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_B, C5, 1); - EDA_PIN_ADD_PIN(T5, SCF_EDA_NPN_E, C5, 0); - - R1->r = 4000; - R2->r = 1600; - R3->r = 10 * 1000; - R4->r = 130; - C5->uf = 2e-6; - - R1->pins[1]->flags = SCF_EDA_PIN_POS; - R3->pins[0]->flags = SCF_EDA_PIN_NEG; - - R1->pins[1]->ic_lid = SCF_EDA_NAND_POS; - R3->pins[0]->ic_lid = SCF_EDA_NAND_NEG; - - D10->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; - D11->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_IN; - D3 ->pins[SCF_EDA_Diode_NEG]->flags = SCF_EDA_PIN_OUT; - - D10->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND_IN0; - D11->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND_IN1; - D3 ->pins[SCF_EDA_Diode_NEG]->ic_lid = SCF_EDA_NAND_OUT; - - int ret = ses_layout_function(f, 100); - if (ret < 0) - return ret; - - ses_draw(f, "ttl_nand_delay.png", f->x, f->y, f->w, f->h, 0, -1); - - long len = 0; - uint8_t* buf = NULL; - - ScfEfunction_pack(f, &buf, &len); - ScfEfunction_free(f); - f = NULL; - - FILE* fp = fopen("./ttl_nand_delay.cpk", "wb"); - if (!fp) - return -EINVAL; - - fwrite(buf, len, 1, fp); - fclose(fp); - return 0; -} diff --git a/cpk/ttl_nor.cpk b/cpk/ttl_nor.cpk index 111b68e3c91fb0fe485850d9394ef0dee7f996a7..8bda7ad71a0902dda061fdbd5f5137726c64b390 100644 GIT binary patch literal 590 zcmZWmJ5B>Z4E1JR7{yv#q*)0?djJ|zZZSff0#O7GfQW>03My!*a}>l$H~|%+pon;H zXMc#9(Tp^H_IuB6_WS$Whux!?G_n$r#uWFoKFjLm?E9vz(^nyaqoQG|ct+5%{5Z*= zP2FKktgTEO?+kQsg4RE6204P*#-jb|$=0tuBqYo<@C*oelz7g;O^q1UGh}4+Xe;Ce=EnBsDKP3m jZ}?|WHA@|A5y19i2IwVb0hbDLRL_S5w340{>3Z=CDQZSJ literal 593 zcmZXRJxT;Y5QVE}Dk!jA3fyFqVGdy8h7&X@7>J^Vn< +#include +#include +#include"ses_core.h" + +int main(int argc, char* argv[]) +{ + ScfEcomponent* NAND; + + ScfEfunction* f = scf_efunction__alloc("ttl_not"); + + EDA_INST_ADD_COMPONENT(f, NAND, SCF_EDA_NAND); + + EDA_PIN_ADD_PIN(NAND, SCF_EDA_NAND_IN0, NAND, SCF_EDA_NAND_IN1); + + NAND->pins[SCF_EDA_NAND_POS]->flags = SCF_EDA_PIN_POS; + NAND->pins[SCF_EDA_NAND_NEG]->flags = SCF_EDA_PIN_NEG; + + NAND->pins[SCF_EDA_NAND_IN0]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0; + NAND->pins[SCF_EDA_NAND_OUT]->flags = SCF_EDA_PIN_OUT; + + NAND->pins[SCF_EDA_NAND_POS]->ic_lid = SCF_EDA_NOT_POS; + NAND->pins[SCF_EDA_NAND_NEG]->ic_lid = SCF_EDA_NOT_NEG; + + NAND->pins[SCF_EDA_NAND_IN0]->ic_lid = SCF_EDA_NOT_IN; + NAND->pins[SCF_EDA_NAND_OUT]->ic_lid = SCF_EDA_NOT_OUT; + + int ret = ses_layout_function(f, 100); + if (ret < 0) + return ret; + + ses_draw(f, "ttl_not.png", f->x, f->y, f->w, f->h, 0, -1); + + long len = 0; + uint8_t* buf = NULL; + + ScfEfunction_pack(f, &buf, &len); + ScfEfunction_free(f); + f = NULL; + + FILE* fp = fopen("./ttl_not.cpk", "wb"); + if (!fp) + return -EINVAL; + + fwrite(buf, len, 1, fp); + fclose(fp); + return 0; +} diff --git a/cpk/ttl_not.cpk b/cpk/ttl_not.cpk new file mode 100644 index 0000000000000000000000000000000000000000..df325888971097d9c4dc88da1f9c15318b190ff6 GIT binary patch literal 327 zcmYk1Jr2S!422yvgNLZfz>=lv0a)nhp#vA`1rRXgAWW=q1Qsq(!5ugVQ-_M@CZ%;G z=f~f(U+NeS-SHI3QcW8os)AOYSb;<#QLVs|KuDhgRaMO+@BrilPlP~K z@y*_C+bi8``fq>x&G*ghWW9b~y}Xg9DV0PtRVKmbVYS7>)%EhJsp8j&$PqEIDzh-Y z?6J1ci$pD|1PMtq7V`K!Vty(x^{(j{k3BqMqW$WN)!QCX3IHSwkiJr!IdX@iFw<1^ z&V<;qz*{PPAmFh^{ku8sqacG2-j1Q$%MQv(*dwd=Xi;8m@i_q#zg_&rNxVEG42vHK zrD}1xhm=c%@#O%@)#BsmB#rsJLCcZD@*vE=JevR;N0X5=ae5}FK`(`L*wEJ!GWE_H zn!*UGv7Yf+Z_TDLDhe4qd9_7SX)4%02?B#l93h%unwX1F_`okt#`84rhvR@*pxI&5 zZ7)pBjN7It4tj0II2myD?2dF-$#%WkkZ^g4OK5am&jT_*1&*zUB})LCjCO95e5tJB nEsyuiP%|jyHHVfO%LPP+kWuJ0D5zPEnd{qU5K(*|-OuR{_;FHR literal 889 zcmZvau}T9$5Qb;(rkG-t1+Tb3IMQojQl?lzu(7hV)520vB;Y$};|mCag{3}#RbC;A zisCa^SfvR5Gq-m!noYP1nQv$Qe`dO)(ec5_8F}haK}5a4BzVuyEZ=*-JX$}jrtvW& zazsoV0<$oFwA?HYlNuXzj1rRJs*uO~7xeX}P~36Dn(~O^BbqmzreIuapg<)MDHotr z?mlifa`W4eR86Zp&Bba73a$Q}fYMJBagnu-U_}Uz-_+(yq8dZ&;n{oisyVa#;lrTk zEPmrIzMf%;#V@2v1#ep_Z~;fYSfEnDtt{?me=J34otQXLQ*iXp)YYpg8N1e$EHTwm zjVW|hC@i-2^vP1KWZGLZC8)_^soZy`a+L}akP4sX%<`1!+->)Pn1MRT6rpr%|8y~4 z%t@%cL6B|H)Ud7_j^h%eLF>z_Iy~qgs`@o30T+E3uHt5ig|w|n`=xOobZFRW;sRNs z%^;?EDG&s*wV?$|2{xM8`l%Jj6@i0zwdFlC@)>5nV?8XxN?1oO#n5?RNXV7$XH1>c LWJK{g-|f>6RC99C diff --git a/cpk/ttl_xor.cpk b/cpk/ttl_xor.cpk index 9361bf284bf286480bf2a7fde5cc201c8337f106..77836ea882838aba9820a9031552f1d1d309136b 100644 GIT binary patch literal 1694 zcmZvcv2N5r5QfL+DYjTeQ@HS`=uAnd}uW&($C?bj|Rd@lUL?{IhKt+KLgd!wB z1R+Gr15ltmL8QC{Rg@xCiWC38>vilqJ157t{%_|0W@o25J$?D&_3U?!@b+DW^|8kK`L`7|(>eQ=gq4=7#vd(|Mi{ia$&^mF;9TV>zo_ezS z8)ds^Pak6uF+JYm&+)mvQsUjaBr=&p;^qTUO1PX#cK>5|g5j&Mpag`+kpEt?&j0?T ziRN(9kpadDZhh6wS*uD&f!pJP>vXO2{U1U0cGA3wW%3Frb$$@6P5H1>p@LxY#X!}i zgtq~e6S}>gFs&mNn6|L?KhX(_)?v93tWK4%P**25EUv8r)b#|_r9Uow!# zKj`p;X$q;vzH8c9LZLY@q10Mo;^LffA0kXhSeP2N8_&q52s%exjtYF*bIB;Bp~Q|d zE7Z-@Dz%^tjYCMb50x|Xh7XlAsBlQJ#^zymwh)z7X`zKmeDRoO5F)Tra+?u>n}REw bV@J@qlwlqrKiQX4)HjY7YDAg`+C0<$BxK-A literal 1698 zcmZuxJ&P1U5Urjmu!Fv%zzJqyIVRZP0)zE3H|PVwL=2XTOvFIUggfQnj6~%S@dH;x zE)oumjPwT>h`-=KjQj(J7Z@3=zN+b&o4K9drFTBwR=rnM{i^-_d$%9%KA@5+Du}4s zWbzb9><$moTIP$z+Wh#|#^3lmCvrqgESt=p0}B_7+XhR^{L7;nyfrecCqG*k3c=&5 z1Dn24SiI)0U&d1e4S0=@*Xy*J%<*E25}E+xCp}b3`FS=XclK|v0_A_124j^7md4-= zvdq7|HySUpRvYAa!q!EdK1--ZlqnBbpxvxxK7VJh?JOSFg$fK+>_abDN_oFUp@z^D ziXJMZ{F%j@Sx=Rx2)1{S0CH3oG_A;*KQ|^jc`M5g$ZAoIEY#JL^ouKxE!2e^)m4VU zBPGiq+bg-URh0OWyl&kxrcfX9c*&jD1gg7+4XO!MUC~q>8IkX<)f5Ia$;*UlG=+h& zI(=)PgLbU6lPir%2|u}}of5_ng{>#5PPmrEuPcoL*Bxt=s3;i_wfE}0C>apdq8d?x z>UwNlB709P6o{a@`X&hI>efZ2`uuWASKkP@N#P6By^BlH4qW`x?-f&otRIFgR2IBr zrB^4fjZ5cP6$7$bR3i)Vyz=Q1IeBWKa1cO5--IF5^w3ZrTa*-nQP!HLwainb?d&Qn zr*9N`q-sfCrs^ diff --git a/main.c b/main.c index 0673b72..921607d 100644 --- a/main.c +++ b/main.c @@ -304,7 +304,7 @@ int main(int argc, char* argv[]) f = b->functions[i]; printf("f: %s\n", f->name); - ses_steps_analyse(f, 100LL, 5); + ses_steps_analyse(f, 100LL, 25); } ScfEboard_free(b); diff --git a/scf_eda_pack.c b/scf_eda_pack.c index f236b48..a798e62 100644 --- a/scf_eda_pack.c +++ b/scf_eda_pack.c @@ -20,7 +20,14 @@ static int component_pins[SCF_EDA_Components_NB] = SCF_EDA_AND_NB, SCF_EDA_OR_NB, SCF_EDA_XOR_NB, + SCF_EDA_ADD_NB, + + SCF_EDA_NAND4_NB, + SCF_EDA_AND2_OR_NB, + + SCF_EDA_IF_NB, + SCF_EDA_MLA_NB, }; static int __diode_path_off(ScfEpin* p0, ScfEpin* p1, int flags) @@ -76,7 +83,8 @@ static int __ttl_nand_path_off(ScfEpin* p0, ScfEpin* p1, int flags) return 1; } else { if (p1) { - if (!flags && (SCF_EDA_NAND_IN0 == p0->id || SCF_EDA_NAND_IN1 == p0->id) + if (!flags + && (SCF_EDA_NAND_IN0 == p0->id || SCF_EDA_NAND_IN1 == p0->id) && SCF_EDA_NAND_OUT == p1->id) return 0; @@ -90,9 +98,38 @@ static int __ttl_nand_path_off(ScfEpin* p0, ScfEpin* p1, int flags) static int __ttl_nand_shared(ScfEpin* p, int flags) { if (!flags) { - if (SCF_EDA_NAND_OUT != p->id) + if (SCF_EDA_NAND_OUT == p->id) + return 0; + } + return 1; +} + +static int __ttl_not_path_off(ScfEpin* p0, ScfEpin* p1, int flags) +{ + if (SCF_EDA_NOT_NEG == p0->id) + return 1; + if (flags && SCF_EDA_NOT_IN == p0->id) + return 1; + + if (SCF_EDA_NOT_POS == p0->id) { + if (p1 && SCF_EDA_NOT_IN == p1->id) return 1; - return 0; + } else { + if (p1) { + if (!flags && SCF_EDA_NOT_IN == p0->id && SCF_EDA_NOT_OUT == p1->id) + return 0; + if (SCF_EDA_NOT_NEG != p1->id) + return 1; + } + } + return 0; +} + +static int __ttl_not_shared(ScfEpin* p, int flags) +{ + if (!flags) { + if (SCF_EDA_NOT_OUT == p->id) + return 0; } return 1; } @@ -123,12 +160,108 @@ static int __ttl_add_path_off(ScfEpin* p0, ScfEpin* p1, int flags) static int __ttl_add_shared(ScfEpin* p, int flags) { -// if (SCF_EDA_ADD_NEG == p->id || SCF_EDA_ADD_POS == p->id) -// return 1; if (!flags) { - if (SCF_EDA_ADD_OUT != p->id && SCF_EDA_ADD_CF != p->id) + if (SCF_EDA_ADD_OUT == p->id || SCF_EDA_ADD_CF == p->id) + return 0; + } + return 1; +} + +static int __ttl_nand4_path_off(ScfEpin* p0, ScfEpin* p1, int flags) +{ + if (SCF_EDA_NAND4_NEG == p0->id) + return 1; + if (flags && (SCF_EDA_NAND4_IN0 <= p0->id && p0->id <= SCF_EDA_NAND4_IN3)) + return 1; + + if (SCF_EDA_NAND4_POS == p0->id) { + if (p1 && (SCF_EDA_NAND4_IN0 <= p0->id && p0->id <= SCF_EDA_NAND4_IN3)) return 1; - return 0; + } else { + if (p1) { + if (!flags + && (SCF_EDA_NAND4_IN0 <= p0->id && p0->id <= SCF_EDA_NAND4_IN3) + && SCF_EDA_NAND4_OUT == p1->id) + return 0; + + if (SCF_EDA_NAND4_NEG != p1->id) + return 1; + } + } + return 0; +} + +static int __ttl_nand4_shared(ScfEpin* p, int flags) +{ + if (!flags) { + if (SCF_EDA_NAND4_OUT == p->id) + return 0; + } + return 1; +} + +static int __ttl_if_path_off(ScfEpin* p0, ScfEpin* p1, int flags) +{ + if (SCF_EDA_IF_NEG == p0->id) + return 1; + if (flags && (SCF_EDA_IF_TRUE <= p0->id && p0->id <= SCF_EDA_IF_FALSE)) + return 1; + + if (SCF_EDA_IF_POS == p0->id) { + if (p1 && (SCF_EDA_IF_TRUE <= p0->id && p0->id <= SCF_EDA_IF_FALSE)) + return 1; + } else { + if (p1) { + if (!flags + && (SCF_EDA_IF_TRUE <= p0->id && p0->id <= SCF_EDA_IF_FALSE) + && SCF_EDA_IF_OUT == p1->id) + return 0; + + if (SCF_EDA_IF_NEG != p1->id) + return 1; + } + } + return 0; +} + +static int __ttl_if_shared(ScfEpin* p, int flags) +{ + if (!flags) { + if (SCF_EDA_IF_OUT == p->id) + return 0; + } + return 1; +} + +static int __ttl_mla_path_off(ScfEpin* p0, ScfEpin* p1, int flags) +{ + if (SCF_EDA_MLA_NEG == p0->id) + return 1; + if (flags && (SCF_EDA_MLA_IN0 <= p0->id && p0->id <= SCF_EDA_MLA_IN3)) + return 1; + + if (SCF_EDA_MLA_POS == p0->id) { + if (p1 && (SCF_EDA_MLA_IN0 <= p1->id && p1->id <= SCF_EDA_MLA_IN3)) + return 1; + } else { + if (p1) { + if (!flags + && (SCF_EDA_MLA_IN0 <= p0->id && p0->id <= SCF_EDA_MLA_IN3) + && (SCF_EDA_MLA_OUT == p1->id && p1->id <= SCF_EDA_MLA_CF)) + return 0; + + if (SCF_EDA_MLA_NEG != p1->id) + return 1; + } + } + return 0; +} + +static int __ttl_mla_shared(ScfEpin* p, int flags) +{ + if (!flags) { + if (SCF_EDA_MLA_OUT == p->id && p->id <= SCF_EDA_MLA_CF) + return 0; } return 1; } @@ -163,12 +296,41 @@ static ScfEops __ttl_gate_ops = __ttl_nand_shared, }; +static ScfEops __ttl_not_ops = +{ + __ttl_not_path_off, + __ttl_not_shared, +}; + static ScfEops __ttl_add_ops = { __ttl_add_path_off, __ttl_add_shared, }; +static ScfEops __ttl_nand4_ops = +{ + __ttl_nand4_path_off, + __ttl_nand4_shared, +}; +static ScfEops __ttl_and2_or_ops = +{ + __ttl_nand4_path_off, + __ttl_nand4_shared, +}; + +static ScfEops __ttl_if_ops = +{ + __ttl_if_path_off, + __ttl_if_shared, +}; + +static ScfEops __ttl_mla_ops = +{ + __ttl_mla_path_off, + __ttl_mla_shared, +}; + static ScfEdata component_datas[] = { {SCF_EDA_None, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL}, @@ -183,11 +345,17 @@ static ScfEdata component_datas[] = {SCF_EDA_PNP, 0, 0, 0, 0, 0, 0, 0, 0, &__pnp_ops, NULL, "./cpk/9012.txt"}, {SCF_EDA_NAND, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_nand_ops, "./cpk/ttl_nand.cpk", NULL}, + {SCF_EDA_NOT, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_not_ops, "./cpk/ttl_not.cpk", NULL}, {SCF_EDA_AND, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_gate_ops, "./cpk/ttl_and.cpk", NULL}, {SCF_EDA_OR, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_gate_ops, "./cpk/ttl_or.cpk", NULL}, {SCF_EDA_NOR, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_gate_ops, "./cpk/ttl_nor.cpk", NULL}, {SCF_EDA_XOR, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_gate_ops, "./cpk/ttl_xor.cpk", NULL}, {SCF_EDA_ADD, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_add_ops, "./cpk/ttl_add.cpk", NULL}, + + {SCF_EDA_NAND4, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_nand4_ops, "./cpk/ttl_nand4.cpk", NULL}, + {SCF_EDA_AND2_OR, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_and2_or_ops, "./cpk/ttl_and2_or.cpk", NULL}, + {SCF_EDA_IF, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_if_ops, "./cpk/ttl_if.cpk", NULL}, + {SCF_EDA_MLA, 0, 0, 0, 0, 0, 0, 0, 0, &__ttl_mla_ops, "./cpk/ttl_mla.cpk", NULL}, }; static ScfEdata pin_datas[] = diff --git a/scf_eda_pack.h b/scf_eda_pack.h index 6b4ed2f..6c76b8e 100644 --- a/scf_eda_pack.h +++ b/scf_eda_pack.h @@ -25,6 +25,11 @@ enum { SCF_EDA_ADD, + SCF_EDA_NAND4, + SCF_EDA_AND2_OR, + SCF_EDA_IF, + SCF_EDA_MLA, + SCF_EDA_Components_NB, }; @@ -38,6 +43,7 @@ enum { #define SCF_EDA_PIN_SHIFT 64 #define SCF_EDA_PIN_IN0 128 #define SCF_EDA_PIN_DIV0 256 +#define SCF_EDA_PIN_KEY 512 #define SCF_EDA_V_INIT -10001001.0 #define SCF_EDA_V_MIN -10000000.0 @@ -162,6 +168,59 @@ enum { SCF_EDA_ADD_NB, }; +enum { + SCF_EDA_NAND4_NEG, + SCF_EDA_NAND4_POS, + + SCF_EDA_NAND4_IN0, + SCF_EDA_NAND4_IN1, + SCF_EDA_NAND4_IN2, + SCF_EDA_NAND4_IN3, + SCF_EDA_NAND4_OUT, + + SCF_EDA_NAND4_NB, +}; + +enum { + SCF_EDA_AND2_OR_NEG = SCF_EDA_NAND4_NEG, + SCF_EDA_AND2_OR_POS = SCF_EDA_NAND4_POS, + + SCF_EDA_AND2_OR_IN0 = SCF_EDA_NAND4_IN0, + SCF_EDA_AND2_OR_IN1 = SCF_EDA_NAND4_IN1, + SCF_EDA_AND2_OR_IN2 = SCF_EDA_NAND4_IN2, + SCF_EDA_AND2_OR_IN3 = SCF_EDA_NAND4_IN3, + SCF_EDA_AND2_OR_OUT = SCF_EDA_NAND4_OUT, + + SCF_EDA_AND2_OR_NB, +}; + +enum { + SCF_EDA_IF_NEG, + SCF_EDA_IF_POS, + + SCF_EDA_IF_TRUE, + SCF_EDA_IF_COND, + SCF_EDA_IF_FALSE, + SCF_EDA_IF_OUT, + + SCF_EDA_IF_NB, +}; + +enum { + SCF_EDA_MLA_NEG, + SCF_EDA_MLA_POS, + + SCF_EDA_MLA_IN0, + SCF_EDA_MLA_IN1, + SCF_EDA_MLA_IN2, + SCF_EDA_MLA_IN3, + + SCF_EDA_MLA_OUT, + SCF_EDA_MLA_CF, + + SCF_EDA_MLA_NB, +}; + typedef struct { uint64_t type; uint64_t model; diff --git a/ses_layout.c b/ses_layout.c index 8767c98..794bef0 100644 --- a/ses_layout.c +++ b/ses_layout.c @@ -43,7 +43,7 @@ int ses_layout_draw(ScfEboard* b, uint32_t bx, uint32_t by, uint32_t bw, uint32_ SHOW_COLOR(cr, 0.8, 0, 0); else if (SCF_EDA_PIN_IN & el->flags) - SHOW_COLOR(cr, 1.0, 0.6, 0.07); + SHOW_COLOR(cr, 0.07, 0.6, 1.0); else if (SCF_EDA_PIN_DIV0 & el->flags) SHOW_COLOR(cr, 0, 1, 0); @@ -62,7 +62,7 @@ int ses_layout_draw(ScfEboard* b, uint32_t bx, uint32_t by, uint32_t bw, uint32_ uint8_t text[64]; cairo_select_font_face(cr, "Calibri", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD); - cairo_set_font_size (cr, 26); + cairo_set_font_size (cr, 22); ScfLine* prev = NULL; @@ -75,12 +75,12 @@ int ses_layout_draw(ScfEboard* b, uint32_t bx, uint32_t by, uint32_t bw, uint32_ if (!prev) { int n = snprintf(text, sizeof(text) - 1, "%ld", el->id); - cairo_move_to (cr, l->x0 - 10 - n * 14, l->y0 + 10); + cairo_move_to (cr, l->x0 - 8 - n * 12, l->y0 + 12); cairo_show_text(cr, text); cairo_stroke(cr); if (el->flags & (SCF_EDA_PIN_IN | SCF_EDA_PIN_OUT | SCF_EDA_PIN_DIV0 | SCF_EDA_PIN_SHIFT)) { - cairo_set_font_size(cr, 22); + cairo_set_font_size(cr, 16); if (el->flags & SCF_EDA_PIN_DIV0) n = snprintf(text, sizeof(text) - 1, "DIV0"); @@ -90,7 +90,7 @@ int ses_layout_draw(ScfEboard* b, uint32_t bx, uint32_t by, uint32_t bw, uint32_ else n = snprintf(text, sizeof(text) - 1, "B%ld", el->io_lid); - cairo_move_to (cr, l->x0 - 8 - n * 13, l->y0 + 36); + cairo_move_to (cr, l->x0 - 2 - n * 10, l->y0 + 28); cairo_show_text(cr, text); cairo_stroke(cr); } diff --git a/ses_layout_function.c b/ses_layout_function.c index 95c8334..3d643ce 100644 --- a/ses_layout_function.c +++ b/ses_layout_function.c @@ -6,12 +6,16 @@ static inline int LAYOUT_P0(ScfEcomponent* c) int k = 0; switch (c->type) { case SCF_EDA_NAND: + case SCF_EDA_NAND4: case SCF_EDA_NOT: case SCF_EDA_NOR: case SCF_EDA_XOR: case SCF_EDA_OR: case SCF_EDA_AND: + case SCF_EDA_AND2_OR: case SCF_EDA_ADD: + case SCF_EDA_IF: + case SCF_EDA_MLA: k = 2; break; default: @@ -244,42 +248,25 @@ int epath_cmp_pins(const void* v0, const void* v1) return 0; } -static inline void eline_mov_before(ScfEfunction* f, intptr_t dst, intptr_t src) +static inline int eline_mov_before(ScfEfunction* f, intptr_t dst, intptr_t src) { if (dst == src) - return; + return dst; ScfEline* el = f->elines[src]; - intptr_t i; + long i; - for (i = src + 1; i < f->n_elines; i++) - f->elines[i - 1] = f->elines[i]; + if (src < dst) { + for (i = src + 1; i < dst; i++) + f->elines[i - 1] = f->elines[i]; + f->elines[dst - 1] = el; + return dst - 1; + } - for (i = f->n_elines - 1; i > dst; i--) + for (i = src; i > dst; i--) f->elines[i] = f->elines[i - 1]; - f->elines[dst] = el; - - scf_logd("f->elines[%ld]->id: %ld, f->elines[%ld]->id: %ld\n", src, f->elines[src]->id, dst, f->elines[dst]->id); -} - -static inline void eline_mov_after(ScfEfunction* f, intptr_t dst, intptr_t src) -{ - if (dst == src) - return; - - ScfEline* el = f->elines[src]; - intptr_t i; - - for (i = src + 1; i < f->n_elines; i++) - f->elines[i - 1] = f->elines[i]; - - for (i = f->n_elines - 1; i > dst + 1; i--) - f->elines[i] = f->elines[i - 1]; - - f->elines[dst + 1] = el; - - scf_logd("f->elines[%ld]->id: %ld, f->elines[%ld]->id: %ld\n", src, f->elines[src]->id, dst, f->elines[dst]->id); + return dst; } int _topo_print(scf_vector_t* paths); @@ -289,10 +276,10 @@ static void __ses_layout_path2(ScfEfunction* f, ses_path_t* path, ses_path_t* ba ScfEpin* bp; ScfEpin* p; - intptr_t j; - intptr_t k; - intptr_t n; - intptr_t __n; + long j; + long k; + long n; + long __n; bp = base->pins->data[base->pins->size - 1]; __n = __ses_find_eline_index(f, bp->lid); @@ -320,14 +307,14 @@ static void __ses_layout_path2(ScfEfunction* f, ses_path_t* path, ses_path_t* ba if (!f->elines[n]->vflag) { f->elines[n]->vflag = 1; - eline_mov_before(f, __n, n); + __n = eline_mov_before(f, __n, n); } } } static void __ses_layout_path(ScfEfunction* f, ses_path_t* path, ses_path_t* base) { - intptr_t i; + long i; __ses_layout_path2(f, path, base); @@ -420,25 +407,63 @@ end: return ret; } +static void __ses_layout_key_components(ScfEfunction* f) +{ + ScfEcomponent* c; + ScfEpin* p; + + long i; + long j; + for (i = 0; i < f->n_components; i++) { + c = f->components[i]; + + if (SCF_EDA_NAND4 != c->type + && SCF_EDA_IF != c->type + && SCF_EDA_ADD != c->type + && SCF_EDA_MLA != c->type + && SCF_EDA_AND2_OR != c->type) + continue; + + j = LAYOUT_P0(c); + p = c->pins[j]; + + int n = __ses_find_eline_index(f, p->lid); + int k; + + f->elines[n]->flags |= SCF_EDA_PIN_KEY; + + for (++j; j < c->n_pins; j++) { + p = c->pins[j]; + + k = __ses_find_eline_index(f, p->lid); + + f->elines[k]->flags |= SCF_EDA_PIN_KEY; + + n = eline_mov_before(f, n, k); + } + } +} + static int __ses_layout_lines2(ScfEfunction* f) { - ScfEline* el0; - ScfEline* el1; + ScfEline* el0; + ScfEline* el1; - size_t i; - size_t j; - size_t m; + long i; + long j; + long m; if (f->n_elines <= 2) return 0; __ses_layout_lines4(f); + __ses_layout_key_components(f); #if 1 for (i = 0; i < f->n_elines; i++) { el0 = f->elines[i]; - if (el0->flags & (SCF_EDA_PIN_POS | SCF_EDA_PIN_NEG)) + if (el0->flags & (SCF_EDA_PIN_POS | SCF_EDA_PIN_NEG | SCF_EDA_PIN_KEY)) continue; uint64_t lid; @@ -971,6 +996,7 @@ static void __ses_set_xy(ScfEfunction* f, int d) ScfEpin* p3; long i; + long j; for (i = 0; i < f->n_components; i++) { c = f->components[i]; @@ -983,10 +1009,8 @@ static void __ses_set_xy(ScfEfunction* f, int d) case SCF_EDA_PNP: __set_xy_by_pins(c, SCF_EDA_NPN_B, SCF_EDA_NPN_E); - p0 = c->pins[SCF_EDA_NPN_C]; - p1 = c->pins[SCF_EDA_NPN_E]; - p0->x = c->x + d / 2; - p1->x = c->x - d / 2; + c->pins[SCF_EDA_NPN_C]->x = c->x + d / 2; + c->pins[SCF_EDA_NPN_E]->x = c->x - d / 2; break; case SCF_EDA_NOT: @@ -1001,90 +1025,98 @@ static void __ses_set_xy(ScfEfunction* f, int d) case SCF_EDA_OR: case SCF_EDA_NOR: case SCF_EDA_XOR: - __set_xy_by_pins(c, SCF_EDA_NAND_IN0, SCF_EDA_NAND_IN1); + __set_xy_by_pins(c, SCF_EDA_NAND_IN0, SCF_EDA_NAND_OUT); c->pins[SCF_EDA_NAND_POS]->x = c->x; c->pins[SCF_EDA_NAND_NEG]->x = c->x; - p0 = c->pins[SCF_EDA_NAND_IN0]; - p1 = c->pins[SCF_EDA_NAND_IN1]; - p2 = c->pins[SCF_EDA_NAND_OUT]; + c->pins[SCF_EDA_NAND_IN0]->x = c->x + d / 2; + c->pins[SCF_EDA_NAND_IN1]->x = c->x - d / 2; + c->pins[SCF_EDA_NAND_OUT]->x = c->x; + break; + + case SCF_EDA_AND2_OR: + case SCF_EDA_NAND4: + c->x = c->pins[c->n_pins - 1]->x; + c->y = c->pins[c->n_pins - 1]->y + d / 2; - if (p0->y > p1->y) - SCF_XCHG(p0, p1); + c->pins[SCF_EDA_NAND4_POS]->x = c->x; + c->pins[SCF_EDA_NAND4_NEG]->x = c->x; if (0 == n) { - if (c->y <= p1->y) { - p0->x = c->x + d * 3 / 4; - p1->x = c->x + d / 4; - } else { - p0->x = c->x + d / 4; - p1->x = c->x + d * 3 / 4; - } + c->pins[SCF_EDA_NAND4_IN0]->x = c->x - d * 3 / 4; + c->pins[SCF_EDA_NAND4_IN1]->x = c->x - d / 4; + c->pins[SCF_EDA_NAND4_IN2]->x = c->x + d / 4; + c->pins[SCF_EDA_NAND4_IN3]->x = c->x + d * 3 / 4; + } else { + c->pins[SCF_EDA_NAND4_IN0]->x = c->x + d * 3 / 4; + c->pins[SCF_EDA_NAND4_IN1]->x = c->x + d / 4; + c->pins[SCF_EDA_NAND4_IN2]->x = c->x - d / 4; + c->pins[SCF_EDA_NAND4_IN3]->x = c->x - d * 3 / 4; + } + break; - p2->x = c->x - d * 3 / 4; + case SCF_EDA_MLA: + c->x = c->pins[c->n_pins - 1]->x; + c->y = c->pins[c->n_pins - 1]->y + d / 2; + + c->pins[SCF_EDA_MLA_POS]->x = c->x; + c->pins[SCF_EDA_MLA_NEG]->x = c->x; + + if (0 == n) { + c->pins[SCF_EDA_MLA_CF ]->x = c->x - d * 3 / 4; + c->pins[SCF_EDA_MLA_OUT]->x = c->x + d * 3 / 4; + + c->pins[SCF_EDA_MLA_IN0]->x = c->x - d * 2 / 3; + c->pins[SCF_EDA_MLA_IN1]->x = c->x - d / 3; + c->pins[SCF_EDA_MLA_IN2]->x = c->x; + c->pins[SCF_EDA_MLA_IN3]->x = c->x + d / 3; } else { - if (c->y <= p1->y) { - p0->x = c->x - d * 3 / 4; - p1->x = c->x - d / 4; - } else { - p0->x = c->x - d / 4; - p1->x = c->x - d * 3 / 4; - } + c->pins[SCF_EDA_MLA_CF ]->x = c->x + d * 3 / 4; + c->pins[SCF_EDA_MLA_OUT]->x = c->x - d * 3 / 4; - p2->x = c->x + d * 3 / 4; + c->pins[SCF_EDA_MLA_IN0]->x = c->x + d * 2 / 3; + c->pins[SCF_EDA_MLA_IN1]->x = c->x + d / 3; + c->pins[SCF_EDA_MLA_IN2]->x = c->x; + c->pins[SCF_EDA_MLA_IN3]->x = c->x - d / 3; } break; - case SCF_EDA_ADD: - __set_xy_by_pins(c, SCF_EDA_ADD_IN0, SCF_EDA_ADD_IN1); + case SCF_EDA_IF: + c->x = c->pins[SCF_EDA_IF_OUT]->x; + c->y = c->pins[SCF_EDA_IF_OUT]->y + d / 2; - c->pins[SCF_EDA_ADD_POS]->x = c->x; - c->pins[SCF_EDA_ADD_NEG]->x = c->x; + c->pins[SCF_EDA_IF_POS]->x = c->x; + c->pins[SCF_EDA_IF_NEG]->x = c->x; - p0 = c->pins[SCF_EDA_ADD_IN0]; - p1 = c->pins[SCF_EDA_ADD_IN1]; - p2 = c->pins[SCF_EDA_ADD_OUT]; - p3 = c->pins[SCF_EDA_ADD_CF]; + if (0 == n) { + c->pins[SCF_EDA_IF_TRUE]->x = c->x - d * 3 / 4; + c->pins[SCF_EDA_IF_COND]->x = c->x - 17; + c->pins[SCF_EDA_IF_FALSE]->x = c->x + d * 3 / 4; + } else { + c->pins[SCF_EDA_IF_TRUE]->x = c->x + d * 3 / 4; + c->pins[SCF_EDA_IF_COND]->x = c->x + 17; + c->pins[SCF_EDA_IF_FALSE]->x = c->x - d * 3 / 4; + } + break; - if (p0->y > p1->y) - SCF_XCHG(p0, p1); + case SCF_EDA_ADD: + c->x = c->pins[SCF_EDA_ADD_CF]->x; + c->y = c->pins[SCF_EDA_ADD_CF]->y + d / 2; - if (p2->y > p3->y) - SCF_XCHG(p2, p3); + c->pins[SCF_EDA_ADD_POS]->x = c->x; + c->pins[SCF_EDA_ADD_NEG]->x = c->x; if (0 == n) { - if (c->y <= p1->y) { - p0->x = c->x + d * 3 / 4; - p1->x = c->x + d / 4; - } else { - p0->x = c->x + d / 4; - p1->x = c->x + d * 3 / 4; - } - - if (c->y <= p3->y) { - p2->x = c->x - d / 4; - p3->x = c->x - d * 3 / 4; - } else { - p2->x = c->x - d * 3 / 4; - p3->x = c->x - d / 4; - } + c->pins[SCF_EDA_ADD_IN0]->x = c->x - d / 4; + c->pins[SCF_EDA_ADD_IN1]->x = c->x + d / 4; + c->pins[SCF_EDA_ADD_OUT]->x = c->x + d * 3 / 4; + c->pins[SCF_EDA_ADD_CF ]->x = c->x - d * 3 / 4; } else { - if (c->y <= p1->y) { - p0->x = c->x - d * 3 / 4; - p1->x = c->x - d / 4; - } else { - p0->x = c->x - d / 4; - p1->x = c->x - d * 3 / 4; - } - - if (c->y <= p3->y) { - p2->x = c->x + d / 4; - p3->x = c->x + d * 3 / 4; - } else { - p2->x = c->x + d * 3 / 4; - p3->x = c->x + d / 4; - } + c->pins[SCF_EDA_ADD_IN0]->x = c->x + d / 4; + c->pins[SCF_EDA_ADD_IN1]->x = c->x - d / 4; + c->pins[SCF_EDA_ADD_OUT]->x = c->x - d * 3 / 4; + c->pins[SCF_EDA_ADD_CF ]->x = c->x + d * 3 / 4; } break; default: @@ -1264,14 +1296,18 @@ static void __ses_set_cx(ScfEfunction* f, int d) int tmp = c->x; if (SCF_EDA_NPN == c->type - || SCF_EDA_NPN == c2->type - || SCF_EDA_PNP == c->type || SCF_EDA_PNP == c2->type - || SCF_EDA_NAND == c->type || SCF_EDA_NAND == c2->type - || SCF_EDA_AND == c->type || SCF_EDA_AND == c2->type - || SCF_EDA_ADD == c->type || SCF_EDA_ADD == c2->type - || SCF_EDA_OR == c->type || SCF_EDA_OR == c2->type - || SCF_EDA_XOR == c->type || SCF_EDA_XOR == c2->type - || SCF_EDA_NOR == c->type || SCF_EDA_NOR == c2->type) + || SCF_EDA_NPN == c2->type + || SCF_EDA_PNP == c->type || SCF_EDA_PNP == c2->type + || SCF_EDA_NAND == c->type || SCF_EDA_NAND == c2->type + || SCF_EDA_NAND4 == c->type || SCF_EDA_NAND4 == c2->type + || SCF_EDA_AND == c->type || SCF_EDA_AND == c2->type + || SCF_EDA_ADD == c->type || SCF_EDA_ADD == c2->type + || SCF_EDA_OR == c->type || SCF_EDA_OR == c2->type + || SCF_EDA_XOR == c->type || SCF_EDA_XOR == c2->type + || SCF_EDA_NOR == c->type || SCF_EDA_NOR == c2->type + || SCF_EDA_IF == c->type || SCF_EDA_IF == c2->type + || SCF_EDA_MLA == c->type || SCF_EDA_MLA == c2->type + || SCF_EDA_AND2_OR == c->type || SCF_EDA_AND2_OR == c2->type) c->x = c2->x + d * 2; else c->x = c2->x + d; @@ -1370,14 +1406,18 @@ static void __ses_min_cx(ScfEfunction* f, int d) c->x = f->components[0]->x; else { if (SCF_EDA_NPN == c->type - || SCF_EDA_NPN == mt - || SCF_EDA_PNP == c->type || SCF_EDA_PNP == mt - || SCF_EDA_NAND == c->type || SCF_EDA_NAND == mt - || SCF_EDA_AND == c->type || SCF_EDA_AND == mt - || SCF_EDA_ADD == c->type || SCF_EDA_ADD == mt - || SCF_EDA_OR == c->type || SCF_EDA_OR == mt - || SCF_EDA_XOR == c->type || SCF_EDA_XOR == mt - || SCF_EDA_NOR == c->type || SCF_EDA_NOR == mt) + || SCF_EDA_NPN == mt + || SCF_EDA_PNP == c->type || SCF_EDA_PNP == mt + || SCF_EDA_NAND == c->type || SCF_EDA_NAND == mt + || SCF_EDA_NAND4 == c->type || SCF_EDA_NAND4 == mt + || SCF_EDA_AND == c->type || SCF_EDA_AND == mt + || SCF_EDA_ADD == c->type || SCF_EDA_ADD == mt + || SCF_EDA_OR == c->type || SCF_EDA_OR == mt + || SCF_EDA_XOR == c->type || SCF_EDA_XOR == mt + || SCF_EDA_NOR == c->type || SCF_EDA_NOR == mt + || SCF_EDA_IF == c->type || SCF_EDA_IF == mt + || SCF_EDA_MLA == c->type || SCF_EDA_MLA == mt + || SCF_EDA_AND2_OR == c->type || SCF_EDA_AND2_OR == mt) c->x = max + d * 2; else c->x = max + d; @@ -1401,14 +1441,26 @@ static void __ses_min_cx(ScfEfunction* f, int d) if (c3->x < c2->x) break; - if (SCF_EDA_NPN == c3->type - || SCF_EDA_PNP == c3->type - || SCF_EDA_NAND == c3->type || SCF_EDA_AND == c3->type - || SCF_EDA_ADD == c3->type || SCF_EDA_OR == c3->type - || SCF_EDA_XOR == c3->type || SCF_EDA_NOR == c3->type) { - c2 = c3; - d2 = d * 2; - } + + switch (c3->type) { + case SCF_EDA_NPN: + case SCF_EDA_PNP: + case SCF_EDA_NAND4: + case SCF_EDA_NAND: + case SCF_EDA_AND: + case SCF_EDA_AND2_OR: + case SCF_EDA_ADD: + case SCF_EDA_OR: + case SCF_EDA_XOR: + case SCF_EDA_NOR: + case SCF_EDA_IF: + case SCF_EDA_MLA: + c2 = c3; + d2 = d * 2; + break; + default: + break; + }; } int tmp = c->x; @@ -1419,14 +1471,25 @@ static void __ses_min_cx(ScfEfunction* f, int d) if (c->x > tmp) break; - if (SCF_EDA_NPN == c->type - || SCF_EDA_PNP == c->type - || SCF_EDA_NAND == c->type || SCF_EDA_AND == c->type - || SCF_EDA_ADD == c->type || SCF_EDA_OR == c->type - || SCF_EDA_XOR == c->type || SCF_EDA_NOR == c->type) - c->x = c2->x + d * 2; - else - c->x = c2->x + d2; + switch (c->type) { + case SCF_EDA_NPN: + case SCF_EDA_PNP: + case SCF_EDA_NAND4: + case SCF_EDA_NAND: + case SCF_EDA_AND: + case SCF_EDA_AND2_OR: + case SCF_EDA_ADD: + case SCF_EDA_OR: + case SCF_EDA_XOR: + case SCF_EDA_NOR: + case SCF_EDA_IF: + case SCF_EDA_MLA: + c->x = c2->x + d * 2; + break; + default: + c->x = c2->x + d2; + break; + }; for (k = 0; k < c->n_pins; k++) { p = c->pins[k]; @@ -1439,34 +1502,53 @@ static void __ses_min_cx(ScfEfunction* f, int d) qsort(f->components, f->n_components, sizeof(ScfEcomponent*), ecomponent_cmp_id); } -static void __ses_xchg_ce(ScfEfunction* f, int d) +static void __ses_xchg_px(ScfEfunction* f, int d) { ScfEcomponent* c; ScfEpin* pb; ScfEpin* pe; ScfEpin* pc; - int64_t i; - int64_t j; - - assert(SCF_EDA_NPN_B == SCF_EDA_PNP_B); - assert(SCF_EDA_NPN_C == SCF_EDA_PNP_C); - assert(SCF_EDA_NPN_E == SCF_EDA_PNP_E); + long i; + long j; + int d2; for (i = 0; i < f->n_components; i++) { c = f->components[i]; - if (SCF_EDA_NPN != c->type && SCF_EDA_PNP != c->type) - continue; - j = 0; + switch (c->type) { + case SCF_EDA_PNP: + case SCF_EDA_NPN: + pb = c->pins[SCF_EDA_NPN_B]; + pc = c->pins[SCF_EDA_NPN_C]; + pe = c->pins[SCF_EDA_NPN_E]; + d2 = d * 7 / 8; + break; + + case SCF_EDA_NAND: + case SCF_EDA_NOR: + case SCF_EDA_XOR: + case SCF_EDA_OR: + case SCF_EDA_AND: + pb = c->pins[SCF_EDA_NAND_OUT]; + pe = c->pins[SCF_EDA_NAND_IN0]; + pc = c->pins[SCF_EDA_NAND_IN1]; + d2 = d / 2; + break; + default: + j = -1; + break; + }; + + if (j < 0) + continue; if (c->color > 0) j = (c->color - 1) % 2; - pb = c->pins[SCF_EDA_NPN_B]; - pc = c->pins[SCF_EDA_NPN_C]; - pe = c->pins[SCF_EDA_NPN_E]; + ScfEpin* tmp0 = pc; + ScfEpin* tmp1 = pe; if (pc->y > pe->y) SCF_XCHG(pc, pe); @@ -1482,23 +1564,19 @@ static void __ses_xchg_ce(ScfEfunction* f, int d) SCF_XCHG(pc->x, pe->x); } else if (pc->y < pb->y) { - - pc = c->pins[SCF_EDA_NPN_C]; - pe = c->pins[SCF_EDA_NPN_E]; + pc = tmp0; + pe = tmp1; if ((0 == j && pc->x > pb->x) || (1 == j && pc->x < pb->x)) SCF_XCHG(pc->x, pe->x); } - pc = c->pins[SCF_EDA_NPN_C]; - pe = c->pins[SCF_EDA_NPN_E]; - if (pc->x < c->x) { - pc->x = c->x - d * 7 / 8; - pe->x = c->x + d * 7 / 8; + pc->x = c->x - d2; + pe->x = c->x + d2; } else { - pc->x = c->x + d * 7 / 8; - pe->x = c->x - d * 7 / 8; + pc->x = c->x + d2; + pe->x = c->x - d2; } } } @@ -1542,7 +1620,7 @@ int ses_layout_function(ScfEfunction* f, int d) __ses_set_cx(f, d); __ses_xchg_cx(f, d); __ses_min_cx(f, d); - __ses_xchg_ce(f, d); + __ses_xchg_px(f, d); int tx0 = INT_MAX; int tx1 = 0; diff --git a/ses_node_analysis.c b/ses_node_analysis.c index e1a198b..cee9b24 100644 --- a/ses_node_analysis.c +++ b/ses_node_analysis.c @@ -691,7 +691,7 @@ static int __ses_edges_update_Ab(ScfEfunction* f, scf_vector_t* edges, double* A } else { if (dV < SCF_EDA_V_NPN_OFF && Ve < Bp->v - SCF_EDA_V_NPN_OFF) { c->status = SCF_EDA_Status_OFF; - c->lock = 1; + c->lock = 2; (*n_offs)++; } #if 1 @@ -721,10 +721,10 @@ static int __ses_edges_update_Ab(ScfEfunction* f, scf_vector_t* edges, double* A Rb = V / Ib; } #endif - if (Ib > 0 && dI < -1e-10 && -1e8 < Rb && Rb < 1e8) { + if (dI < -1e-10 && -1e8 < Rb && Rb < 1e8) { if (!edge->amplify_flag) { edge->amplify_flag = 1; -#if 1 +#if 0 scf_logi("edge: [%d], ", edge->index); ses_pin_print(p0); ses_pin_print(p1); @@ -811,7 +811,7 @@ static int __ses_nodes_path_solve2(ScfEfunction* f, ses_path_t* path, int vip_m, ret = __ses_edges_update_Ab(f, edges, A, b, X, N, &n_offs); try++; - scf_logd("ret: %d, try: %d\n\n", ret, try); + scf_logi("ret: %d, try: %d, n_offs: %d\n\n", ret, try, n_offs); for (i = 0; i < n; i++) { node = nodes->data[i]; @@ -866,7 +866,7 @@ static int __ses_nodes_path_solve2(ScfEfunction* f, ses_path_t* path, int vip_m, if (SCF_EDA_NPN == c->type) { if (SCF_EDA_NPN_B == p0->id && edge->a < -1e-4) { c->status = SCF_EDA_Status_OFF; - c->lock = 1; + c->lock = 2; (*changed)++; } @@ -877,7 +877,7 @@ static int __ses_nodes_path_solve2(ScfEfunction* f, ses_path_t* path, int vip_m, } else if (SCF_EDA_PNP == c->type) { if (SCF_EDA_PNP_B == p1->id && edge->a < -1e-4) { c->status = SCF_EDA_Status_OFF; - c->lock = 1; + c->lock = 2; (*changed)++; } @@ -888,7 +888,7 @@ static int __ses_nodes_path_solve2(ScfEfunction* f, ses_path_t* path, int vip_m, } else if (SCF_EDA_Diode == c->type) { if (edge->a < -1e-4) { c->status = SCF_EDA_Status_OFF; - c->lock = 1; + c->lock = 2; (*changed)++; } diff --git a/ses_step_dc_input.c b/ses_step_dc_input.c index dcaa5ad..de18d30 100644 --- a/ses_step_dc_input.c +++ b/ses_step_dc_input.c @@ -12,8 +12,8 @@ static int _dc_input_handler(ScfEfunction* f, int64_t ps, int64_t count, ses_ctx long j; int k; - int x[] = {0, 0, 1, 0, 1}; - int y[] = {1, 1, 0, 1, 0}; + int x[] = {1, 1, 1, 0, 1}; + int y[] = {0, 1, 0, 1, 0}; B = f->components[0]; @@ -26,9 +26,9 @@ static int _dc_input_handler(ScfEfunction* f, int64_t ps, int64_t count, ses_ctx continue; if (SCF_EDA_PIN_IN0 & el->flags) - k = x[(count / 100) & 0x1]; + k = x[el->io_lid]; else - k = y[(count / 100) & 0x1]; + k = y[el->io_lid]; scf_logi("el->io_lid: %ld, k: %d\n", el->io_lid, k); el2 = f->elines[B->pins[k]->lid]; diff --git a/ses_step_draw.c b/ses_step_draw.c index c89a7e7..887b2c5 100644 --- a/ses_step_draw.c +++ b/ses_step_draw.c @@ -67,6 +67,8 @@ void __ses_function_draw(ScfEfunction* f, cairo_t* cr) ScfEpin* p; ScfEpin* p0; ScfEpin* p1; + ScfEpin* p2; + ScfEpin* p3; ScfEpin* pb; ScfEpin* pc; ScfEpin* pe; @@ -127,17 +129,36 @@ void __ses_function_draw(ScfEfunction* f, cairo_t* cr) break; case SCF_EDA_NAND: + case SCF_EDA_NAND4: case SCF_EDA_NOR: case SCF_EDA_AND: case SCF_EDA_OR: case SCF_EDA_XOR: - case SCF_EDA_ADD: n = snprintf(text, sizeof(text) - 1, "%ld", c->id); - if (c->pins[2]->x < c->x) - cairo_move_to(cr, c->x + 10, c->y - 20); + if (c->pins[SCF_EDA_NAND_OUT]->y < c->y) + cairo_move_to(cr, c->x + 6, c->y - 18); else - cairo_move_to(cr, c->x - 10 - n * 10, c->y - 20); + cairo_move_to(cr, c->x + 6, c->y + 30); + break; + + case SCF_EDA_ADD: + n = snprintf(text, sizeof(text) - 1, "%ld", c->id); + + cairo_move_to(cr, c->x + 18, c->y); + break; + + case SCF_EDA_MLA: + n = snprintf(text, sizeof(text) - 1, "%ld", c->id); + + cairo_move_to(cr, c->x + 26, c->y); + break; + + case SCF_EDA_IF: + case SCF_EDA_AND2_OR: + n = snprintf(text, sizeof(text) - 1, "%ld", c->id); + + cairo_move_to(cr, c->x + 6, c->y - 18); break; default: n = snprintf(text, sizeof(text) - 1, "%ld", c->id); @@ -150,8 +171,8 @@ void __ses_function_draw(ScfEfunction* f, cairo_t* cr) cairo_set_font_size(cr, 16); #if 0 - snprintf(text, sizeof(text) - 1, "%ld", c->color); - cairo_move_to(cr, c->x + 4, c->y - 24); + snprintf(text, sizeof(text) - 1, "c%ld", c->color); + cairo_move_to(cr, c->x - 10, c->y - 24); cairo_show_text(cr, text); cairo_stroke(cr); #endif @@ -571,562 +592,463 @@ void __ses_function_draw(ScfEfunction* f, cairo_t* cr) cairo_stroke(cr); break; + case SCF_EDA_AND: case SCF_EDA_NAND: p = c->pins[SCF_EDA_NAND_OUT]; p0 = c->pins[SCF_EDA_NAND_IN0]; p1 = c->pins[SCF_EDA_NAND_IN1]; - if (p0->y > p1->y) - SCF_XCHG(p0, p1); - - if (c->x < p->x) { + if (c->y < p->y) { cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x + 24, c->y); - cairo_stroke(cr); - - cairo_arc(cr, c->x + 20, c->y, 4, 0, 2 * M_PI); - cairo_stroke(cr); - - cairo_arc(cr, c->x + 6, c->y, 10, -0.5 * M_PI, 0.5 * M_PI); + if (SCF_EDA_NAND == c->type) { + cairo_line_to(cr, c->x, c->y + 24); + cairo_stroke(cr); + cairo_arc(cr, c->x, c->y + 20, 4, 0, 2 * M_PI); + } else + cairo_line_to(cr, c->x, c->y + 16); cairo_stroke(cr); - cairo_move_to(cr, c->x + 6, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y - 10); - cairo_line_to(cr, c->x + 6, c->y - 10); + cairo_arc(cr, c->x, c->y + 6, 10, 0, M_PI); cairo_stroke(cr); - if (p0 == c->pins[SCF_EDA_NAND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 6, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + cairo_move_to(cr, c->x + 10, c->y + 6); + cairo_line_to(cr, c->x + 10, c->y - 6); + cairo_line_to(cr, c->x - 10, c->y - 6); + cairo_line_to(cr, c->x - 10, c->y + 6); cairo_stroke(cr); - - if (p1 == c->pins[SCF_EDA_NAND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 6, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); } else { cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x - 24, c->y); - cairo_stroke(cr); - - cairo_arc(cr, c->x - 20, c->y, 4, 0, 2 * M_PI); - cairo_stroke(cr); - - cairo_arc(cr, c->x - 6, c->y, 10, 0.5 * M_PI, 1.5 * M_PI); + if (SCF_EDA_NAND == c->type) { + cairo_line_to(cr, c->x, c->y - 24); + cairo_stroke(cr); + cairo_arc(cr, c->x, c->y - 20, 4, 0, 2 * M_PI); + } else + cairo_line_to(cr, c->x, c->y - 16); cairo_stroke(cr); - cairo_move_to(cr, c->x - 6, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y - 10); - cairo_line_to(cr, c->x - 6, c->y - 10); + cairo_arc(cr, c->x, c->y - 6, 10, -M_PI, 0); cairo_stroke(cr); - if (p0 == c->pins[SCF_EDA_NAND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 6, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + cairo_move_to(cr, c->x + 10, c->y - 6); + cairo_line_to(cr, c->x + 10, c->y + 6); + cairo_line_to(cr, c->x - 10, c->y + 6); + cairo_line_to(cr, c->x - 10, c->y - 6); cairo_stroke(cr); - - if (p1 == c->pins[SCF_EDA_NAND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 6, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); } - cairo_stroke(cr); -#if 0 - p = c->pins[SCF_EDA_NAND_POS]; - if (p->y < c->y) { - cairo_move_to(cr, c->x, c->y - 10); - cairo_line_to(cr, p->x, p->y); - p = c->pins[SCF_EDA_NAND_NEG]; - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, p->x, p->y); - } else { - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, p->x, p->y); - - p = c->pins[SCF_EDA_NAND_NEG]; - cairo_move_to(cr, c->x, c->y - 10); - cairo_line_to(cr, p->x, p->y); - } - - cairo_stroke(cr); -#endif - break; - - case SCF_EDA_AND: - p = c->pins[SCF_EDA_AND_OUT]; - p0 = c->pins[SCF_EDA_AND_IN0]; - p1 = c->pins[SCF_EDA_AND_IN1]; - - if (p0->y > p1->y) + if (p0->x > p1->x) SCF_XCHG(p0, p1); - if (c->x < p->x) { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x + 16, c->y); - cairo_stroke(cr); - - cairo_arc(cr, c->x + 6, c->y, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_stroke(cr); +#define DRAW_GATE_PIN(_p, _x, _y0, _y1) \ + do { \ + cairo_move_to(cr, c->x + (_x), c->y + (_y0)); \ + cairo_line_to(cr, c->x + (_x), c->y + (_y1)); \ + cairo_line_to(cr, (_p)->x, c->y + (_y1)); \ + cairo_line_to(cr, (_p)->x, (_p)->y); \ + cairo_stroke(cr); \ + } while (0) - cairo_move_to(cr, c->x + 6, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y - 10); - cairo_line_to(cr, c->x + 6, c->y - 10); - cairo_stroke(cr); + if (c->y < p->y) { + if (p0 == c->pins[SCF_EDA_NAND_IN1]) { + DRAW_GATE_PIN(p1, 5, -6, -12); - if (p0 == c->pins[SCF_EDA_AND_IN1]) SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 6, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); - cairo_stroke(cr); + DRAW_GATE_PIN(p0, -5, -6, -12); + } else { + DRAW_GATE_PIN(p0, -5, -6, -12); - if (p1 == c->pins[SCF_EDA_AND_IN1]) SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 6, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + DRAW_GATE_PIN(p1, 5, -6, -12); + } } else { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x - 16, c->y); - cairo_stroke(cr); + if (p0 == c->pins[SCF_EDA_NAND_IN1]) { + DRAW_GATE_PIN(p1, 5, 6, 12); - cairo_arc(cr, c->x - 6, c->y, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_stroke(cr); - - cairo_move_to(cr, c->x - 6, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y - 10); - cairo_line_to(cr, c->x - 6, c->y - 10); - cairo_stroke(cr); - - if (p0 == c->pins[SCF_EDA_AND_IN1]) SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 6, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); - cairo_stroke(cr); + DRAW_GATE_PIN(p0, -5, 6, 12); + } else { + DRAW_GATE_PIN(p0, -5, 6, 12); - if (p1 == c->pins[SCF_EDA_AND_IN1]) SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 6, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + DRAW_GATE_PIN(p1, 5, 6, 12); + } } - cairo_stroke(cr); break; - case SCF_EDA_ADD: - p = c->pins[SCF_EDA_ADD_OUT]; - pc = c->pins[SCF_EDA_ADD_CF]; - p0 = c->pins[SCF_EDA_ADD_IN0]; - p1 = c->pins[SCF_EDA_ADD_IN1]; + case SCF_EDA_IF: + case SCF_EDA_AND2_OR: + if (SCF_EDA_IF == c->type) + p = c->pins[SCF_EDA_IF_OUT]; + else + p = c->pins[SCF_EDA_AND2_OR_OUT]; - if (p0->y > p1->y) - SCF_XCHG(p0, p1); + cairo_move_to(cr, p->x, p->y); + cairo_line_to(cr, c->x, c->y - 20); + cairo_stroke(cr); + // draw OR gate + cairo_save(cr); + cairo_translate(cr, c->x, c->y - 6); + cairo_scale(cr, 1.0, 1.6); + cairo_arc (cr, 0, 0, 8, -M_PI, 0); + cairo_restore(cr); + cairo_stroke(cr); - if (p->y > pc->y) - SCF_XCHG(p, pc); + cairo_save(cr); + cairo_translate(cr, c->x, c->y - 1); + cairo_scale(cr, 1.0, 0.6); + cairo_arc (cr, 0, 0, 8, -M_PI, 0); + cairo_restore(cr); + cairo_stroke(cr); - cairo_rectangle(cr, c->x - 18, c->y - 18, 36, 36); + cairo_move_to(cr, c->x + 8, c->y - 6); + cairo_line_to(cr, c->x + 8, c->y); + cairo_move_to(cr, c->x - 8, c->y); + cairo_line_to(cr, c->x - 8, c->y - 6); cairo_stroke(cr); - if (c->x < p->x) { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y - 10); - cairo_line_to(cr, c->x + 18, c->y - 10); - cairo_stroke(cr); + cairo_move_to(cr, c->x - 20, c->y + 10); + cairo_line_to(cr, c->x - 20, c->y + 4); + cairo_line_to(cr, c->x - 4, c->y + 4); + cairo_line_to(cr, c->x - 4, c->y - 6); + cairo_stroke(cr); - cairo_move_to(cr, pc->x, pc->y); - cairo_line_to(cr, pc->x, c->y + 10); - cairo_line_to(cr, c->x + 18, c->y + 10); - cairo_stroke(cr); + cairo_move_to(cr, c->x + 20, c->y + 10); + cairo_line_to(cr, c->x + 20, c->y + 4); + cairo_line_to(cr, c->x + 4, c->y + 4); + cairo_line_to(cr, c->x + 4, c->y - 6); + cairo_stroke(cr); + + // draw two AND gate + cairo_arc(cr, c->x - 20, c->y + 16, 6, -M_PI, 0); + cairo_stroke(cr); + cairo_move_to(cr, c->x + 26, c->y + 16); + cairo_line_to(cr, c->x + 26, c->y + 22); + cairo_line_to(cr, c->x + 14, c->y + 22); + cairo_line_to(cr, c->x + 14, c->y + 16); + + cairo_arc(cr, c->x + 20, c->y + 16, 6, -M_PI, 0); + cairo_stroke(cr); + cairo_move_to(cr, c->x - 26, c->y + 16); + cairo_line_to(cr, c->x - 26, c->y + 22); + cairo_line_to(cr, c->x - 14, c->y + 22); + cairo_line_to(cr, c->x - 14, c->y + 16); + cairo_stroke(cr); - if (p->flags & SCF_EDA_PIN_CF) { - cairo_set_font_size(cr, 22); - cairo_move_to(cr, c->x - 4, c->y + 14); - cairo_show_text(cr, "Σ"); + p0 = c->pins[SCF_EDA_AND2_OR_IN0]; + p1 = c->pins[SCF_EDA_AND2_OR_IN1]; + p2 = c->pins[SCF_EDA_AND2_OR_IN2]; + if (SCF_EDA_IF == c->type) + p3 = p2; + else + p3 = c->pins[SCF_EDA_AND2_OR_IN3]; + + if (SCF_EDA_IF == c->type) { + if (c->x < p1->x) { +#define DRAW_NOT(cx, cy, r, x0, x1) \ + do { \ + cairo_arc(cr, (cx), (cy), (r), 0, 2 * M_PI); \ + cairo_stroke(cr); \ + cairo_move_to(cr, (x0), (cy)); \ + cairo_line_to(cr, (x1), (cy) - (r) - 1); \ + cairo_line_to(cr, (x1), (cy) + (r) + 1); \ + cairo_line_to(cr, (x0), (cy)); \ + cairo_stroke(cr); \ + } while (0) + + DRAW_NOT(c->x - 8, c->y + 28, 3, c->x - 5, c->x + 7); + + cairo_move_to(cr, c->x - 17, c->y + 22); + cairo_line_to(cr, c->x - 17, c->y + 28); + cairo_line_to(cr, c->x - 11, c->y + 28); cairo_stroke(cr); - cairo_set_font_size(cr, 14); - cairo_move_to(cr, c->x - 2, c->y - 4); - cairo_show_text(cr, "C0"); + cairo_move_to(cr, c->x + 17, c->y + 22); + cairo_line_to(cr, c->x + 17, c->y + 28); + cairo_line_to(cr, c->x + 7, c->y + 28); + cairo_stroke(cr); } else { - cairo_set_font_size(cr, 22); - cairo_move_to(cr, c->x - 4, c->y); - cairo_show_text(cr, "Σ"); + DRAW_NOT(c->x + 8, c->y + 28, 3, c->x + 5, c->x - 7); + + cairo_move_to(cr, c->x + 17, c->y + 22); + cairo_line_to(cr, c->x + 17, c->y + 28); + cairo_line_to(cr, c->x + 11, c->y + 28); cairo_stroke(cr); - cairo_set_font_size(cr, 14); - cairo_move_to(cr, c->x - 2, c->y + 14); - cairo_show_text(cr, "C0"); + cairo_move_to(cr, c->x - 17, c->y + 22); + cairo_line_to(cr, c->x - 17, c->y + 28); + cairo_line_to(cr, c->x - 7, c->y + 28); + cairo_stroke(cr); } - cairo_stroke(cr); + } - if (p0 == c->pins[SCF_EDA_AND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 18, c->y - 10); - cairo_line_to(cr, p0->x, c->y - 10); - cairo_line_to(cr, p0->x, p0->y); - cairo_stroke(cr); +#define DRAW_TEXT(_x, _y, _size, _text) \ + do { \ + cairo_set_font_size(cr, _size); \ + cairo_move_to(cr, _x, _y); \ + cairo_show_text(cr, _text); \ + cairo_stroke(cr); \ + } while (0) - if (p1 == c->pins[SCF_EDA_AND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x - 18, c->y + 10); - cairo_line_to(cr, p1->x, c->y + 10); - cairo_line_to(cr, p1->x, p1->y); + if (p0->x < c->x) { + DRAW_GATE_PIN(p0, -23, 22, 28); + DRAW_GATE_PIN(p1, -17, 22, 32); + DRAW_GATE_PIN(p3, 23, 22, 28); + + if (SCF_EDA_IF != c->type) + DRAW_GATE_PIN(p2, 17, 22, 32); } else { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y + 10); - cairo_line_to(cr, c->x - 18, c->y + 10); - cairo_stroke(cr); + DRAW_GATE_PIN(p0, 23, 22, 28); + DRAW_GATE_PIN(p1, 17, 22, 32); + DRAW_GATE_PIN(p3, -23, 22, 28); - cairo_move_to(cr, pc->x, pc->y); - cairo_line_to(cr, pc->x, c->y - 10); - cairo_line_to(cr, c->x - 18, c->y - 10); - cairo_stroke(cr); + if (SCF_EDA_IF != c->type) + DRAW_GATE_PIN(p2, -17, 22, 32); + } + break; - if (p->flags & SCF_EDA_PIN_CF) { - cairo_set_font_size(cr, 22); - cairo_move_to(cr, c->x - 4, c->y - 4); - cairo_show_text(cr, "Σ"); - cairo_stroke(cr); + case SCF_EDA_NAND4: + p = c->pins[SCF_EDA_NAND4_OUT]; - cairo_set_font_size(cr, 14); - cairo_move_to(cr, c->x - 16, c->y + 14); - cairo_show_text(cr, "C0"); - } else { - cairo_set_font_size(cr, 22); - cairo_move_to(cr, c->x - 4, c->y + 14); - cairo_show_text(cr, "Σ"); - cairo_stroke(cr); + cairo_move_to(cr, p->x, p->y); + cairo_line_to(cr, c->x, c->y - 24); + cairo_stroke(cr); + cairo_arc(cr, c->x, c->y - 20, 4, 0, 2 * M_PI); + cairo_stroke(cr); - cairo_set_font_size(cr, 14); - cairo_move_to(cr, c->x - 16, c->y - 4); - cairo_show_text(cr, "C0"); - } - cairo_stroke(cr); + cairo_arc(cr, c->x, c->y - 6, 10, -M_PI, 0); + cairo_stroke(cr); - if (p0 == c->pins[SCF_EDA_AND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 18, c->y - 10); - cairo_line_to(cr, p0->x, c->y - 10); - cairo_line_to(cr, p0->x, p0->y); - cairo_stroke(cr); + cairo_move_to(cr, c->x + 10, c->y - 6); + cairo_line_to(cr, c->x + 10, c->y + 6); + cairo_move_to(cr, c->x - 10, c->y - 6); + cairo_line_to(cr, c->x - 10, c->y + 6); - if (p1 == c->pins[SCF_EDA_AND_IN1]) - SHOW_COLOR(cr, 0.0, 0.0, 0.8); - else - SHOW_COLOR(cr, 0.6, 0.6, 0.0); - cairo_move_to(cr, c->x + 18, c->y + 10); - cairo_line_to(cr, p1->x, c->y + 10); - cairo_line_to(cr, p1->x, p1->y); - } + p0 = c->pins[SCF_EDA_NAND4_IN0]; + p1 = c->pins[SCF_EDA_NAND4_IN3]; + cairo_move_to(cr, p0->x, c->y + 6); + cairo_line_to(cr, p1->x, c->y + 6); cairo_stroke(cr); - break; - case SCF_EDA_NOR: - p = c->pins[SCF_EDA_NOR_OUT]; - p0 = c->pins[SCF_EDA_NOR_IN0]; - p1 = c->pins[SCF_EDA_NOR_IN1]; - - if (p0->y > p1->y) - SCF_XCHG(p0, p1); + p = c->pins[SCF_EDA_NAND4_IN0]; + cairo_move_to(cr, p->x, c->y + 6); + cairo_line_to(cr, p->x, p->y); + cairo_stroke(cr); - if (c->x < p->x) { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x + 24, c->y); - cairo_stroke(cr); + p = c->pins[SCF_EDA_NAND4_IN1]; + cairo_move_to(cr, p->x, c->y + 6); + cairo_line_to(cr, p->x, p->y); + cairo_stroke(cr); - cairo_arc(cr, c->x + 20, c->y, 4, 0, 2 * M_PI); - cairo_stroke(cr); + p = c->pins[SCF_EDA_NAND4_IN2]; + cairo_move_to(cr, p->x, c->y + 6); + cairo_line_to(cr, p->x, p->y); + cairo_stroke(cr); - cairo_save(cr); - cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_restore(cr); - cairo_stroke(cr); + p = c->pins[SCF_EDA_NAND4_IN3]; + cairo_move_to(cr, p->x, c->y + 6); + cairo_line_to(cr, p->x, p->y); + cairo_stroke(cr); + break; - cairo_save(cr); - cairo_translate(cr, c->x - 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_restore(cr); - cairo_stroke(cr); + case SCF_EDA_ADD: + cairo_rectangle(cr, c->x - 16, c->y - 14, 32, 28); + cairo_stroke(cr); - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y + 10); - cairo_move_to(cr, c->x - 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); + pc = c->pins[SCF_EDA_ADD_CF]; + p = c->pins[SCF_EDA_ADD_OUT]; + p1 = c->pins[SCF_EDA_ADD_IN1]; + p0 = c->pins[SCF_EDA_ADD_IN0]; - cairo_move_to(cr, c->x - 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + if (c->x < pc->x) { + DRAW_GATE_PIN(pc, 8, -14, -22); + DRAW_GATE_PIN(p, -8, -14, -22); + DRAW_GATE_PIN(p1, -8, 14, 22); + DRAW_GATE_PIN(p0, 8, 14, 22); - cairo_move_to(cr, c->x - 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + DRAW_TEXT(c->x - 1, c->y - 2, 12, "C0"); + DRAW_TEXT(c->x - 12, c->y - 2, 12, "Σ"); } else { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x - 24, c->y); - cairo_stroke(cr); + DRAW_GATE_PIN(pc, -8, -14, -22); + DRAW_GATE_PIN(p, 8, -14, -22); + DRAW_GATE_PIN(p1, 8, 14, 22); + DRAW_GATE_PIN(p0, -8, 14, 22); - cairo_arc(cr, c->x - 20, c->y, 4, 0, 2 * M_PI); - cairo_stroke(cr); - - cairo_save(cr); - cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_restore(cr); - cairo_stroke(cr); - - cairo_save(cr); - cairo_translate(cr, c->x + 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_restore(cr); - cairo_stroke(cr); + DRAW_TEXT(c->x - 12, c->y - 2, 12, "C0"); + DRAW_TEXT(c->x - 1, c->y - 2, 12, "Σ"); + } + break; - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y + 10); - cairo_move_to(cr, c->x + 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); + case SCF_EDA_MLA: + cairo_rectangle(cr, c->x - 24, c->y - 16, 48, 32); + cairo_stroke(cr); - cairo_move_to(cr, c->x + 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + pc = c->pins[SCF_EDA_MLA_CF]; + p = c->pins[SCF_EDA_MLA_OUT]; + p3 = c->pins[SCF_EDA_MLA_IN3]; + p2 = c->pins[SCF_EDA_MLA_IN2]; + p1 = c->pins[SCF_EDA_MLA_IN1]; + p0 = c->pins[SCF_EDA_MLA_IN0]; - cairo_move_to(cr, c->x + 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); - } - cairo_stroke(cr); + if (c->x < pc->x) { + DRAW_GATE_PIN(pc, 12, -16, -24); + DRAW_GATE_PIN(p, -12, -16, -24); -#if 0 - p = c->pins[SCF_EDA_NOR_POS]; - if (p->y < c->y) { - cairo_move_to(cr, c->x, c->y - 10); - cairo_line_to(cr, p->x, p->y); + DRAW_GATE_PIN(p3, -16, 16, 24); + DRAW_GATE_PIN(p2, -8, 16, 32); + DRAW_GATE_PIN(p1, 8, 16, 32); + DRAW_GATE_PIN(p0, 16, 16, 24); - p = c->pins[SCF_EDA_NOR_NEG]; - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, p->x, p->y); + DRAW_TEXT(c->x + 6, c->y - 4, 12, "C0"); + DRAW_TEXT(c->x - 18, c->y - 4, 12, "Σ"); } else { - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, p->x, p->y); + DRAW_GATE_PIN(pc, -12, -16, -24); + DRAW_GATE_PIN(p, 12, -16, -24); - p = c->pins[SCF_EDA_NOR_NEG]; - cairo_move_to(cr, c->x, c->y - 10); - cairo_line_to(cr, p->x, p->y); - } + DRAW_GATE_PIN(p3, 16, 16, 24); + DRAW_GATE_PIN(p2, 8, 16, 32); + DRAW_GATE_PIN(p1, -8, 16, 32); + DRAW_GATE_PIN(p0, -16, 16, 24); - cairo_stroke(cr); -#endif + DRAW_TEXT(c->x - 18, c->y - 4, 12, "C0"); + DRAW_TEXT(c->x + 10, c->y - 4, 12, "Σ"); + } + DRAW_TEXT(c->x - 12, c->y + 12, 12, "MLA"); break; case SCF_EDA_OR: - p = c->pins[SCF_EDA_OR_OUT]; - p0 = c->pins[SCF_EDA_OR_IN0]; - p1 = c->pins[SCF_EDA_OR_IN1]; - - if (p0->y > p1->y) - SCF_XCHG(p0, p1); + case SCF_EDA_XOR: + case SCF_EDA_NOR: + p = c->pins[SCF_EDA_NOR_OUT]; + p0 = c->pins[SCF_EDA_NOR_IN0]; + p1 = c->pins[SCF_EDA_NOR_IN1]; - if (c->x < p->x) { + if (c->y < p->y) { cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x + 16, c->y); + if (SCF_EDA_NOR == c->type) { + cairo_line_to(cr, c->x, c->y + 24); + cairo_stroke(cr); + cairo_arc(cr, c->x, c->y + 20, 4, 0, 2 * M_PI); + } else + cairo_line_to(cr, c->x, c->y + 16); cairo_stroke(cr); cairo_save(cr); cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); + cairo_scale(cr, 1.0, 1.6); + cairo_arc (cr, 0, 0, 10, 0, M_PI); cairo_restore(cr); cairo_stroke(cr); cairo_save(cr); - cairo_translate(cr, c->x - 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); + cairo_translate(cr, c->x, c->y - 6); + cairo_scale(cr, 1.0, 0.6); + cairo_arc (cr, 0, 0, 10, 0, M_PI); cairo_restore(cr); cairo_stroke(cr); - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y + 10); - cairo_move_to(cr, c->x - 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); - - cairo_move_to(cr, c->x - 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + if (SCF_EDA_XOR == c->type) { + cairo_save(cr); + cairo_translate(cr, c->x, c->y - 11); + cairo_scale(cr, 1.0, 0.6); + cairo_arc (cr, 0, 0, 10, 0, M_PI); + cairo_restore(cr); + cairo_stroke(cr); + } - cairo_move_to(cr, c->x - 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + cairo_move_to(cr, c->x + 10, c->y); + cairo_line_to(cr, c->x + 10, c->y - 6); + cairo_move_to(cr, c->x - 10, c->y - 6); + cairo_line_to(cr, c->x - 10, c->y); } else { cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x - 16, c->y); + if (SCF_EDA_NOR == c->type) { + cairo_line_to(cr, c->x, c->y - 24); + cairo_stroke(cr); + cairo_arc(cr, c->x, c->y - 20, 4, 0, 2 * M_PI); + } else + cairo_line_to(cr, c->x, c->y - 16); cairo_stroke(cr); cairo_save(cr); cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); + cairo_scale(cr, 1.0, 1.6); + cairo_arc (cr, 0, 0, 10, -M_PI, 0); cairo_restore(cr); cairo_stroke(cr); cairo_save(cr); - cairo_translate(cr, c->x + 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); + cairo_translate(cr, c->x, c->y + 6); + cairo_scale(cr, 1.0, 0.6); + cairo_arc (cr, 0, 0, 10, -M_PI, 0); cairo_restore(cr); cairo_stroke(cr); - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y + 10); - cairo_move_to(cr, c->x + 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); - - cairo_move_to(cr, c->x + 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + if (SCF_EDA_XOR == c->type) { + cairo_save(cr); + cairo_translate(cr, c->x, c->y + 11); + cairo_scale(cr, 1.0, 0.6); + cairo_arc (cr, 0, 0, 10, -M_PI, 0); + cairo_restore(cr); + cairo_stroke(cr); + } - cairo_move_to(cr, c->x + 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + cairo_move_to(cr, c->x + 10, c->y); + cairo_line_to(cr, c->x + 10, c->y + 6); + cairo_move_to(cr, c->x - 10, c->y + 6); + cairo_line_to(cr, c->x - 10, c->y); } cairo_stroke(cr); - break; - - case SCF_EDA_XOR: - p = c->pins[SCF_EDA_XOR_OUT]; - p0 = c->pins[SCF_EDA_XOR_IN0]; - p1 = c->pins[SCF_EDA_XOR_IN1]; - if (p0->y > p1->y) + if (p0->x > p1->x) SCF_XCHG(p0, p1); - if (c->x < p->x) { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x + 16, c->y); - cairo_stroke(cr); - - cairo_save(cr); - cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_restore(cr); + if (c->y < p->y) { + cairo_move_to(cr, p0->x, p0->y); + cairo_line_to(cr, p0->x, c->y - 16); cairo_stroke(cr); - cairo_save(cr); - cairo_translate(cr, c->x - 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_restore(cr); + cairo_move_to(cr, p1->x, p1->y); + cairo_line_to(cr, p1->x, c->y - 16); cairo_stroke(cr); - cairo_save(cr); - cairo_translate(cr, c->x - 11, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, -0.5 * M_PI, 0.5 * M_PI); - cairo_restore(cr); - cairo_stroke(cr); - - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x - 6, c->y + 10); - cairo_move_to(cr, c->x - 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); - - cairo_move_to(cr, c->x - 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + if (p0 == c->pins[SCF_EDA_AND_IN1]) { + DRAW_GATE_PIN(p1, 5, -2, -16); + cairo_stroke(cr); - cairo_move_to(cr, c->x - 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); - } else { - cairo_move_to(cr, p->x, p->y); - cairo_line_to(cr, p->x, c->y); - cairo_line_to(cr, c->x - 16, c->y); - cairo_stroke(cr); + SHOW_COLOR(cr, 0.0, 0.0, 0.8); + DRAW_GATE_PIN(p0, -5, -2, -16); + } else { + DRAW_GATE_PIN(p0, -5, -2, -16); + cairo_stroke(cr); - cairo_save(cr); - cairo_translate(cr, c->x, c->y); - cairo_scale(cr, 1.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_restore(cr); + SHOW_COLOR(cr, 0.0, 0.0, 0.8); + DRAW_GATE_PIN(p1, 5, -2, -16); + } cairo_stroke(cr); - - cairo_save(cr); - cairo_translate(cr, c->x + 6, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_restore(cr); + } else { + cairo_move_to(cr, p0->x, p0->y); + cairo_line_to(cr, p0->x, c->y + 16); cairo_stroke(cr); - cairo_save(cr); - cairo_translate(cr, c->x + 11, c->y); - cairo_scale(cr, 0.6, 1.0); - cairo_arc (cr, 0, 0, 10, 0.5 * M_PI, 1.5 * M_PI); - cairo_restore(cr); + cairo_move_to(cr, p1->x, p1->y); + cairo_line_to(cr, p1->x, c->y + 16); cairo_stroke(cr); - cairo_move_to(cr, c->x, c->y + 10); - cairo_line_to(cr, c->x + 6, c->y + 10); - cairo_move_to(cr, c->x + 6, c->y - 10); - cairo_line_to(cr, c->x, c->y - 10); + if (p0 == c->pins[SCF_EDA_AND_IN1]) { + DRAW_GATE_PIN(p1, 5, 2, 16); + cairo_stroke(cr); - cairo_move_to(cr, c->x + 2, c->y - 5); - cairo_line_to(cr, p0->x, c->y - 5); - cairo_line_to(cr, p0->x, p0->y); + SHOW_COLOR(cr, 0.0, 0.0, 0.8); + DRAW_GATE_PIN(p0, -5, 2, 16); + } else { + DRAW_GATE_PIN(p0, -5, 2, 16); + cairo_stroke(cr); - cairo_move_to(cr, c->x + 2, c->y + 5); - cairo_line_to(cr, p1->x, c->y + 5); - cairo_line_to(cr, p1->x, p1->y); + SHOW_COLOR(cr, 0.0, 0.0, 0.8); + DRAW_GATE_PIN(p1, 5, 2, 16); + } + cairo_stroke(cr); } - cairo_stroke(cr); break; case SCF_EDA_NOT: @@ -1236,7 +1158,7 @@ int ses_draw(ScfEfunction* f, const char* file, uint32_t bx, uint32_t by, uint32 SHOW_COLOR(cr, 0.8, 0, 0); else if (SCF_EDA_PIN_IN & el->flags) - SHOW_COLOR(cr, 1.0, 0.6, 0.07); + SHOW_COLOR(cr, 0.07, 0.6, 1.0); else if (SCF_EDA_PIN_DIV0 & el->flags) SHOW_COLOR(cr, 0, 1, 0); @@ -1260,16 +1182,16 @@ int ses_draw(ScfEfunction* f, const char* file, uint32_t bx, uint32_t by, uint32 if (!prev) { cairo_select_font_face(cr, "Calibri", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD); - cairo_set_font_size(cr, 26); + cairo_set_font_size(cr, 22); int n = snprintf(text, sizeof(text) - 1, "%ld", el->id); - cairo_move_to (cr, l->x0 - 8 - n * 13, l->y0 + 12); + cairo_move_to (cr, l->x0 - 8 - n * 12, l->y0 + 12); cairo_show_text(cr, text); cairo_stroke(cr); if (el->flags & (SCF_EDA_PIN_IN | SCF_EDA_PIN_OUT | SCF_EDA_PIN_DIV0 | SCF_EDA_PIN_SHIFT)) { - cairo_set_font_size(cr, 22); + cairo_set_font_size(cr, 16); if (el->flags & SCF_EDA_PIN_DIV0) n = snprintf(text, sizeof(text) - 1, "DIV0"); @@ -1279,7 +1201,7 @@ int ses_draw(ScfEfunction* f, const char* file, uint32_t bx, uint32_t by, uint32 else n = snprintf(text, sizeof(text) - 1, "B%ld", el->io_lid); - cairo_move_to (cr, l->x0 - 8 - n * 13, l->y0 + 36); + cairo_move_to (cr, l->x0 - 2 - n * 10, l->y0 + 28); cairo_show_text(cr, text); cairo_stroke(cr); } diff --git a/ses_step_open.c b/ses_step_open.c index 277ee2c..55a72a4 100644 --- a/ses_step_open.c +++ b/ses_step_open.c @@ -211,9 +211,9 @@ static void __open_status_line(ScfEfunction* f, ScfEline* el, ScfEline* LP, ScfE else el->v = SCF_EDA_V_NPN_ON / 2; - scf_logw(""); - ses_eline_print(el); - printf("->v: %lg\n", el->v); +// scf_logw(""); +// ses_eline_print(el); +// printf("->v: %lg\n", el->v); } static void __open_status_IC(ScfEfunction* f, ScfEcomponent* IC, ScfEline* LP, ScfEline* LN) diff --git a/ses_step_topo.c b/ses_step_topo.c index 952e615..588afae 100644 --- a/ses_step_topo.c +++ b/ses_step_topo.c @@ -32,7 +32,6 @@ static int __ses_dfs_line(ScfEcomponent* rc, ScfEpin* np, scf_vector_t* __paths, ScfEline* el = rc->pf->elines[np->lid]; ScfEpin* p; - int add = 0; int ret = 0; long j; @@ -47,6 +46,8 @@ static int __ses_dfs_line(ScfEcomponent* rc, ScfEpin* np, scf_vector_t* __paths, return __ses_dfs_add_ppath(__paths, ppath); } + ses_path_t* tmp = *ppath; + for (j = 0; j + 1 < el->n_pins; j += 2) { c = rc->pf->components[el->pins[j]]; @@ -67,7 +68,6 @@ static int __ses_dfs_line(ScfEcomponent* rc, ScfEpin* np, scf_vector_t* __paths, return ret; *ppath = NULL; - add = 0; } continue; } @@ -75,29 +75,9 @@ static int __ses_dfs_line(ScfEcomponent* rc, ScfEpin* np, scf_vector_t* __paths, if (p->vflag) continue; - if ((SCF_EDA_Capacitor == rc->type || SCF_EDA_Inductor == rc->type) - && SCF_EDA_Capacitor != c->type && SCF_EDA_Inductor != c->type) { - - ret = __ses_dfs_add_ppath(__paths, ppath); - if (ret < 0) - return ret; - - *ppath = NULL; - add = 0; - } - if (!c->ops || !c->ops->shared || !c->ops->shared(p, flags)) p->vflag = 1; - ses_path_t* tmp = NULL; - - if ((SCF_EDA_Capacitor == c->type || SCF_EDA_Inductor == c->type) - && SCF_EDA_Capacitor != rc->type && SCF_EDA_Inductor != rc->type) { - tmp = *ppath; - *ppath = NULL; - add = 1; - } - ret = __ses_dfs_path(c, p, __paths, ppath, flags); if (ret < 0) return ret; @@ -106,18 +86,19 @@ static int __ses_dfs_line(ScfEcomponent* rc, ScfEpin* np, scf_vector_t* __paths, if (!p->pflag) p->vflag = 0; } - - if (tmp) - *ppath = tmp; } - if (add) { - ret = __ses_dfs_add_ppath(__paths, ppath); - if (ret < 0) - return ret; - *ppath = NULL; - } + if (tmp && tmp == *ppath) { + assert(tmp->pins->size > 0); + + c = el->pf->IC; + if (c && el->id < c->n_pins) { + p = c->pins[el->id]; + + ret = __ses_dfs_line(c, p, __paths, ppath, flags); + } + } #if 0 scf_logi(""); ses_pin_print(np); @@ -1430,7 +1411,9 @@ static void _topo_clear(ScfEfunction* f) for (i = 0; i < f->n_components; i++) { c = f->components[i]; c->vflag = 0; - c->lock = 0; + + if (c->lock > 0) + c->lock--; if (SCF_EDA_Inductor != c->type) c->a = 0; diff --git a/ses_step_va.c b/ses_step_va.c index 8d463ef..33ea667 100644 --- a/ses_step_va.c +++ b/ses_step_va.c @@ -125,7 +125,7 @@ int __ses_path_va_branch(ScfEfunction* f, ses_path_t* path, int m, int n, double if (0 == m && path->pins->size - 1 == n) path->a = a; - scf_logw("path: %d, c%ldp%ld-c%ldp%ld, p0->v: %lg, p1->v: %lg, v: %lg, cv: %lg, lv: %lg, pr: %lg, path->pr: %lg, a: %lg\n\n", + scf_logd("path: %d, c%ldp%ld-c%ldp%ld, p0->v: %lg, p1->v: %lg, v: %lg, cv: %lg, lv: %lg, pr: %lg, path->pr: %lg, a: %lg\n\n", path->index, p0->cid, p0->id, p1->cid, p1->id, p0->v, p1->v, v, cv, lv, pr, path->pr, a); double r = 0; @@ -163,17 +163,17 @@ int __ses_path_va_branch(ScfEfunction* f, ses_path_t* path, int m, int n, double c->a = a * sign; c->count = count; - scf_logi("path: %d, i: %d, c%ldp%ld, p->v: %lg, dv: %lg, r: %lg, p->a: %lg, a: %lg, p->pr: %lg, e%ld->v: %lg\n\n", + scf_logd("path: %d, i: %d, c%ldp%ld, p->v: %lg, dv: %lg, r: %lg, p->a: %lg, a: %lg, p->pr: %lg, e%ld->v: %lg\n\n", path->index, i, p->cid, p->id, p->v, dv, r, p->a, a, p->pr, el->id, el->v); r = 0; } else { dv = p->v; - scf_logi("path: %d, i: %d, c%ldp%ld, p->v: %lg, dv: %lg, a: %lg, p->pr: %lg, e%ld->v: %lg\n", + scf_logd("path: %d, i: %d, c%ldp%ld, p->v: %lg, dv: %lg, a: %lg, p->pr: %lg, e%ld->v: %lg\n", path->index, i, p->cid, p->id, p->v, dv, a, p->pr, el->id, el->v); } } - printf("\n"); +// printf("\n"); if (0 == m) { p0->sr = _sr0; diff --git a/test/Makefile b/test/Makefile index 3709298..938aaac 100644 --- a/test/Makefile +++ b/test/Makefile @@ -1,6 +1,6 @@ -#CFILES += main.c +CFILES += main.c #CFILES += test.c -CFILES += fft.c +#CFILES += fft.c #CFILES += dct.c #CFILES += pnp.c #CFILES += colpitts.c diff --git a/test/fft.c b/test/fft.c index 18a48b7..8c73704 100644 --- a/test/fft.c +++ b/test/fft.c @@ -9,7 +9,7 @@ #define REAL(z,i) ((z)[2*(i)]) #define IMAG(z,i) ((z)[2*(i)+1]) -#define N 1024 +#define N 512 int main() { diff --git a/test/main.c b/test/main.c index 1300be5..793484c 100644 --- a/test/main.c +++ b/test/main.c @@ -79,9 +79,9 @@ int main(int argc, char* argv[]) R5->r = 1000; R0->r = 1000; C0->uf = 10; - C1->uf = 0.01; - C2->uf = 0.01; - C3->uf = 0.01; + C1->uf = 0.03; + C2->uf = 0.03; + C3->uf = 0.03; C1->r = 1; C2->r = 1; C3->r = 1; -- 2.25.1