-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
#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
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
+++ /dev/null
-#include<stdio.h>
-#include<stdlib.h>
-#include<string.h>
-#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;
-}
--- /dev/null
+#include<stdio.h>
+#include<stdlib.h>
+#include<string.h>
+#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;
+}
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);
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)
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;
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;
}
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;
}
__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},
{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[] =
SCF_EDA_ADD,
+ SCF_EDA_NAND4,
+ SCF_EDA_AND2_OR,
+ SCF_EDA_IF,
+ SCF_EDA_MLA,
+
SCF_EDA_Components_NB,
};
#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
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;
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);
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;
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");
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);
}
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:
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);
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);
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);
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;
ScfEpin* p3;
long i;
+ long j;
for (i = 0; i < f->n_components; i++) {
c = f->components[i];
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:
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:
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;
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;
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;
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];
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);
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;
}
}
}
__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;
} 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
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);
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];
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)++;
}
} 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)++;
}
} 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)++;
}
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];
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];
ScfEpin* p;
ScfEpin* p0;
ScfEpin* p1;
+ ScfEpin* p2;
+ ScfEpin* p3;
ScfEpin* pb;
ScfEpin* pc;
ScfEpin* pe;
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);
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
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:
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);
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");
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);
}
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)
ScfEline* el = rc->pf->elines[np->lid];
ScfEpin* p;
- int add = 0;
int ret = 0;
long j;
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]];
return ret;
*ppath = NULL;
- add = 0;
}
continue;
}
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;
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);
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;
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;
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;
-#CFILES += main.c
+CFILES += main.c
#CFILES += test.c
-CFILES += fft.c
+#CFILES += fft.c
#CFILES += dct.c
#CFILES += pnp.c
#CFILES += colpitts.c
#define REAL(z,i) ((z)[2*(i)])
#define IMAG(z,i) ((z)[2*(i)+1])
-#define N 1024
+#define N 512
int main()
{
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;
projects / ses.git / commitdiff