#CFILES += nor.c
#CFILES += not.c
#CFILES += and_gate.c
-CFILES += or_gate.c
-#CFILES += add_gate.c
+#CFILES += or_gate.c
+CFILES += add_gate.c
CFILES += ../scf_eda_pack.c
CFILES += ../pack/scf_pack.c
int main(int argc, char* argv[])
{
ScfEcomponent* B;
+ ScfEcomponent* R0;
+ ScfEcomponent* R1;
ScfEcomponent* NAND0;
ScfEcomponent* NOR0;
f = scf_efunction__alloc("add_gate");
EDA_INST_ADD_COMPONENT(f, B, SCF_EDA_Battery);
+ EDA_INST_ADD_COMPONENT(f, R0, SCF_EDA_Resistor);
+ EDA_INST_ADD_COMPONENT(f, R1, SCF_EDA_Resistor);
B->pins[SCF_EDA_Battery_NEG]->flags = SCF_EDA_PIN_NEG;
B->pins[SCF_EDA_Battery_POS]->flags = SCF_EDA_PIN_POS;
EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_IN0, NOR0, SCF_EDA_NOR_IN0);
EDA_PIN_ADD_PIN(NAND0, SCF_EDA_NAND_IN1, NOR0, SCF_EDA_NOR_IN1);
- 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;
+ EDA_PIN_ADD_PIN(R0, 0, NAND0, SCF_EDA_NAND_IN0);
+ EDA_PIN_ADD_PIN(R1, 0, NAND0, SCF_EDA_NAND_IN1);
- NOR1->pins[SCF_EDA_NOR_OUT]->flags = SCF_EDA_PIN_OUT;
+ R0->pins[1]->flags = SCF_EDA_PIN_IN | SCF_EDA_PIN_IN0;
+ R1->pins[1]->flags = SCF_EDA_PIN_IN;
+
+ NOR1->pins[SCF_EDA_NOR_OUT]->flags = SCF_EDA_PIN_OUT;
+ NOT0->pins[SCF_EDA_NOT_OUT]->flags |= SCF_EDA_PIN_CF;
scf_eboard__add_function(b, f);
}
}
+int ses_va_curve(ScfEcomponent* c, const char* txt)
+{
+ FILE* fp = fopen(txt, "rb");
+ if (!fp)
+ return -EINVAL;
+
+ double d = 0.0;
+ double v = 0.0;
+ double a = 0.0;
+ double base = 0.1;
+ int dot = 0;
+
+ while (1) {
+ int ch = fgetc(fp);
+ if (EOF == ch)
+ break;
+
+ if (' ' == ch)
+ continue;
+
+ if (',' == ch) {
+ d = 0.0;
+ dot = 0;
+ base = 0.1;
+ continue;
+ }
+
+ if ('.' == ch) {
+ dot++;
+ if (dot > 1) {
+ scf_loge("too many dots: '%d' > 1\n", dot);
+ fclose(fp);
+ return -EINVAL;
+ }
+ continue;
+ }
+
+ if ('\n' == ch) {
+ ScfEcurve* curve = calloc(1, sizeof(ScfEcurve));
+ if (!curve) {
+ fclose(fp);
+ return -ENOMEM;
+ }
+
+ int ret = scf_ecomponent__add_curve(c, curve);
+ if (ret < 0) {
+ free(curve);
+ fclose(fp);
+ return ret;
+ }
+
+ curve->v = v;
+ curve->a = a;
+ curve->hfe = d;
+
+ scf_logi("curve v: %lg, a: %lg, hfe: %lg, R: %lg\n", v, a, d, v / a);
+
+ d = 0.0;
+ dot = 0;
+ base = 0.1;
+ continue;
+ }
+
+ if ('0' <= ch && '9' >= ch) {
+ ch -= '0';
+
+ if (0 == dot) {
+ d *= 10.0;
+ d += ch;
+ } else {
+ d += ch * base;
+ base /= 10.0;
+ }
+ continue;
+ }
+
+ switch (ch) {
+ case 'm':
+ d *= 1e-3;
+ break;
+
+ case 'u':
+ d *= 1e-6;
+ break;
+
+ case 'V':
+ v = d;
+ d = 0.0;
+ break;
+
+ case 'A':
+ a = d;
+ d = 0.0;
+ break;
+ default:
+ scf_loge("char '%c, %d' Not support\n", ch, ch);
+ fclose(fp);
+ return -EINVAL;
+ break;
+ };
+ }
+
+ fclose(fp);
+ return 0;
+}
+
int ses_init_component(ScfEcomponent* c)
{
ScfEcomponent* c2;
return -EINVAL;
c->ops = ed->ops;
+ if (ed->va_curve) {
+ int ret = ses_va_curve(c, ed->va_curve);
+ if (ret < 0)
+ return ret;
+ }
+
if (!ed->cpk)
return 0;
printf("f: %s\n", f->name);
- ses_steps_analyse(f, 100, 4);
+ ses_steps_analyse(f, 100, 1);
}
ScfEboard_free(b);
if (!*pbuf)
*plen = 0;
-// prlongf("\n");
scf_logd("p: %p\n", p);
long i;
static int __pnp_path_off(ScfEpin* p0, ScfEpin* p1)
{
- if (SCF_EDA_PNP_E == p0->id)
+ if (SCF_EDA_PNP_E != p0->id)
+ return 1;
+
+ if (!p1 || SCF_EDA_PNP_E != p1->id)
return 0;
return 1;
}
static ScfEdata component_datas[] =
{
- {SCF_EDA_None, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL},
- {SCF_EDA_Battery, 0, SCF_EDA_Battery_POS, 0, 0, 1e-9, 1e9, 0, 0, NULL, NULL},
+ {SCF_EDA_None, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL},
+ {SCF_EDA_Battery, 0, SCF_EDA_Battery_POS, 0, 0, 1e-9, 1e9, 0, 0, NULL, NULL, NULL},
- {SCF_EDA_Resistor, 0, 0, 0, 0, 1e4, 0, 0, 0, NULL, NULL},
- {SCF_EDA_Capacitor, 0, 0, 0, 0, 10, 0.1, 0, 0, NULL, NULL},
- {SCF_EDA_Inductor, 0, 0, 0, 0, 10, 0, 1e3, 0, NULL, NULL},
+ {SCF_EDA_Resistor, 0, 0, 0, 0, 1e4, 0, 0, 0, NULL, NULL, NULL},
+ {SCF_EDA_Capacitor, 0, 0, 0, 0, 10, 0.1, 0, 0, NULL, NULL, NULL},
+ {SCF_EDA_Inductor, 0, 0, 0, 0, 10, 0, 1e3, 0, NULL, NULL, NULL},
- {SCF_EDA_Diode, 0, 0, 0, 0, 0, 0, 0, 0, &__diode_ops, NULL},
- {SCF_EDA_NPN, 0, 0, 0, 0, 0, 0, 0, 0, &__npn_ops, NULL},
- {SCF_EDA_PNP, 0, 0, 0, 0, 0, 0, 0, 0, &__pnp_ops, NULL},
+ {SCF_EDA_Diode, 0, 0, 0, 0, 0, 0, 0, 0, &__diode_ops, NULL, NULL},
+ {SCF_EDA_NPN, 0, 0, 0, 0, 0, 0, 0, 0, &__npn_ops, NULL, "./cpk/9013.txt"},
+ {SCF_EDA_PNP, 0, 0, 0, 0, 0, 0, 0, 0, &__pnp_ops, NULL, NULL},
- {SCF_EDA_NAND, 0, 0, 0, 0, 0, 0, 0, 0, &__nand_ops, "./cpk/nand.cpk"},
- {SCF_EDA_NOR, 0, 0, 0, 0, 0, 0, 0, 0, &__nor_ops, "./cpk/nor.cpk"},
- {SCF_EDA_NOT, 0, 0, 0, 0, 0, 0, 0, 0, &__not_ops, "./cpk/not.cpk"},
+ {SCF_EDA_NAND, 0, 0, 0, 0, 0, 0, 0, 0, &__nand_ops, "./cpk/nand.cpk", NULL},
+ {SCF_EDA_NOR, 0, 0, 0, 0, 0, 0, 0, 0, &__nor_ops, "./cpk/nor.cpk", NULL},
+ {SCF_EDA_NOT, 0, 0, 0, 0, 0, 0, 0, 0, &__not_ops, "./cpk/not.cpk", NULL},
};
static ScfEdata pin_datas[] =
{
- {SCF_EDA_None, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL},
+ {SCF_EDA_None, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL},
- {SCF_EDA_Diode, 0, SCF_EDA_Diode_NEG, 0, 0, 750, 0, 0, 0, NULL, NULL},
+ {SCF_EDA_Diode, 0, SCF_EDA_Diode_NEG, 0, 0, 750, 0, 0, 0, NULL, NULL, NULL},
- {SCF_EDA_NPN, 0, SCF_EDA_NPN_B, 0, 0, 750, 0, 0, 0, NULL, NULL},
- {SCF_EDA_NPN, 0, SCF_EDA_NPN_C, 0, 0, 3, 0, 0, 250, NULL, NULL},
+ {SCF_EDA_NPN, 0, SCF_EDA_NPN_B, 0, 0, 750, 0, 0, 0, NULL, NULL, NULL},
+ {SCF_EDA_NPN, 0, SCF_EDA_NPN_C, 0, 0, 3, 0, 0, 250, NULL, NULL, NULL},
- {SCF_EDA_PNP, 0, SCF_EDA_PNP_B, 0, 0, 750, 0, 0, 0, NULL, NULL},
- {SCF_EDA_PNP, 0, SCF_EDA_PNP_C, 0, 0, 3, 0, 0, 250, NULL, NULL},
+ {SCF_EDA_PNP, 0, SCF_EDA_PNP_B, 0, 0, 750, 0, 0, 0, NULL, NULL, NULL},
+ {SCF_EDA_PNP, 0, SCF_EDA_PNP_C, 0, 0, 3, 0, 0, 250, NULL, NULL, NULL},
};
static ScfEdata* _pin_find_data(const uint64_t type, const uint64_t model, const uint64_t pid)
pin->id = i;
pin->ic_lid = -1;
- scf_loge("pin %p, id: %ld, ic_lid: %ld\n", pin, pin->id, pin->ic_lid);
+ scf_logd("pin %p, id: %ld, ic_lid: %ld\n", pin, pin->id, pin->ic_lid);
if (scf_ecomponent__add_pin(c, pin) < 0) {
ScfEcomponent_free(c);
return c;
}
+int scf_ecomponent__add_curve(ScfEcomponent* c, ScfEcurve* curve)
+{
+ if (!c || !curve)
+ return -EINVAL;
+
+ void* p = realloc(c->curves, sizeof(ScfEcurve*) * (c->n_curves + 1));
+ if (!p)
+ return -ENOMEM;
+
+ c->curves = p;
+ c->curves[c->n_curves++] = curve;
+ return 0;
+}
+
int scf_ecomponent__add_pin(ScfEcomponent* c, ScfEpin* pin)
{
if (!c || !pin)
void* ops;
char* cpk;
+ char* va_curve;
} ScfEdata;
typedef struct {
SCF_PACK_INFO_VAR(ScfLine, y1),
SCF_PACK_END(ScfLine)
+typedef struct {
+ SCF_PACK_DEF_VAR(double, v);
+ SCF_PACK_DEF_VAR(double, a);
+ SCF_PACK_DEF_VAR(double, hfe);
+} ScfEcurve;
+
+SCF_PACK_TYPE(ScfEcurve)
+SCF_PACK_INFO_VAR(ScfEcurve, v),
+SCF_PACK_INFO_VAR(ScfEcurve, a),
+SCF_PACK_INFO_VAR(ScfEcurve, hfe),
+SCF_PACK_END(ScfEcurve)
+
typedef struct scf_eops_s ScfEops;
typedef struct scf_epin_s ScfEpin;
typedef struct scf_ecomponent_s ScfEcomponent;
SCF_PACK_DEF_VAR(uint64_t, model);
SCF_PACK_DEF_OBJS(ScfEpin, pins);
+ SCF_PACK_DEF_OBJS(ScfEcurve, curves);
+
SCF_PACK_DEF_OBJ(ScfEfunction, pf);
SCF_PACK_DEF_OBJ(ScfEfunction, f);
SCF_PACK_DEF_OBJ(ScfEops, ops);
SCF_PACK_INFO_VAR(ScfEcomponent, id),
SCF_PACK_INFO_VAR(ScfEcomponent, type),
SCF_PACK_INFO_VAR(ScfEcomponent, model),
-SCF_PACK_INFO_OBJS(ScfEcomponent, pins, ScfEpin),
+SCF_PACK_INFO_OBJS(ScfEcomponent, pins, ScfEpin),
+SCF_PACK_INFO_OBJS(ScfEcomponent, curves, ScfEcurve),
SCF_PACK_INFO_VAR(ScfEcomponent, v),
SCF_PACK_INFO_VAR(ScfEcomponent, a),
int scf_epin__add_component(ScfEpin* pin, uint64_t cid, uint64_t pid);
int scf_epin__del_component(ScfEpin* pin, uint64_t cid, uint64_t pid);
-ScfEcomponent* scf_ecomponent__alloc (uint64_t type);
+ScfEcomponent* scf_ecomponent__alloc(uint64_t type);
int scf_ecomponent__add_pin(ScfEcomponent* c, ScfEpin* pin);
int scf_ecomponent__del_pin(ScfEcomponent* c, ScfEpin* pin);
+int scf_ecomponent__add_curve(ScfEcomponent* c, ScfEcurve* curve);
ScfEdata* scf_ecomponent__find_data(const uint64_t type, const uint64_t model);
ScfEfunction* scf_efunction__alloc (const char* name);
ses_path_t* ses_path_alloc();
void ses_path_free (ses_path_t* path);
-void ses_path_print(ses_path_t* path);
+void ses_path_print(ses_path_t* path, ScfEfunction* f);
ses_path_t* ses_path_ref (ses_path_t* src);
int ses_path_xchg (ses_path_t* path0, int k0, ses_path_t* path1, int k1);
void ses_nodes_free (scf_vector_t* nodes);
void ses_nodes_print(scf_vector_t* nodes);
-void ses_paths_print(scf_vector_t* paths);
+void ses_paths_print(scf_vector_t* paths, ScfEfunction* f);
ses_ctx_t* ses_ctx_alloc();
void ses_ctx_free (ses_ctx_t* ctx);
return 0;
}
-int ses_lines_diff_components(ScfEfunction* f, ses_graph_t* graph)
-{
- if (!f || !graph)
- return -EINVAL;
-
- ses_vertex_t* v0;
- ses_vertex_t* v1;
-
- ScfEline* el0;
- ScfEline* el1;
- ScfEconn* ec;
-
- size_t i;
- size_t j;
- size_t k;
-
- for (i = 0; i + 1 < f->n_elines; i++) {
- el0 = f->elines[i];
-
- if (el0->n_conns <= 1)
- continue;
-
- v0 = ses_vertex_add(graph, el0);
- if (!v0)
- return -ENOMEM;
-
- for (j = i + 1; j < f->n_elines; j++) {
- el1 = f->elines[j];
-
- if (el1->n_conns <= 1)
- continue;
-
- for (k = 0; k < el0->n_conns; k++) {
- ec = el0->conns[k];
-
- if (el1->id == ec->lid)
- break;
- }
-
- if (k < el0->n_conns)
- continue;
-
- v1 = ses_vertex_add(graph, el1);
- if (!v1)
- return -ENOMEM;
-
- if (ses_vertex_connect(v0, v1) < 0)
- return -ENOMEM;
- }
- }
-
- scf_vector_qsort(graph, ses_vertex_cmp_edges);
-
-#if 0
- for (i = 0; i < graph->size; i++) {
- v0 = graph->data[i];
-
- el0 = v0->data;
- scf_loge("i: %ld, l%ld\n", i, el0->id);
-
- for (j = 0; j < v0->edges->size; j++) {
- v1 = v0->edges->data[j];
-
- el1 = v1->data;
- scf_logi("j: %ld, l%ld\n", j, el1->id);
- }
- printf("\n");
- }
-#endif
- return 0;
-}
-
int epath_cmp_pins(const void* v0, const void* v1)
{
const ses_path_t* p0 = *(const ses_path_t**)v0;
scf_vector_qsort(paths, epath_cmp_pins);
- ses_paths_print(paths);
+ ses_paths_print(paths, f);
for (i = 0; i < paths->size; i++) {
base = paths->data[i];
p0 = c->pins[SCF_EDA_NPN_C];
p1 = c->pins[SCF_EDA_NPN_E];
- p0->x = c->x + d / 3;
- p1->x = c->x - d / 3;
+ p0->x = c->x + d / 2;
+ p1->x = c->x - d / 2;
break;
case SCF_EDA_NAND:
int tmp = c->x;
- c->x = c2->x + d;
+ if (SCF_EDA_NPN == c->type
+ || SCF_EDA_PNP == c->type
+ || SCF_EDA_NPN == c2->type
+ || SCF_EDA_PNP == c2->type)
+ c->x = c2->x + d * 2;
+ else
+ c->x = c2->x + d;
for (k = 0; k < c->n_pins; k++) {
p = c->pins[k];
int tmp = c->x;
int max = 0;
+ int mt = 0;
int m0 = 0;
if (c->color > 0)
_next:
continue;
_max:
- if (max < c2->x)
+ if (max < c2->x) {
max = c2->x;
+ mt = c2->type;
+ }
}
if (0 == max)
continue;
- c->x = max + d;
+ if (SCF_EDA_NPN == c->type
+ || SCF_EDA_PNP == c->type
+ || SCF_EDA_NPN == mt
+ || SCF_EDA_PNP == mt)
+ c->x = max + d * 2;
+ else
+ c->x = max + d;
for (k = 0; k < c->n_pins; k++) {
p = c->pins[k];
if (c->x > tmp)
break;
- c->x = c2->x + d;
+ if (SCF_EDA_NPN == c->type
+ || SCF_EDA_PNP == c->type
+ || SCF_EDA_NPN == c2->type
+ || SCF_EDA_PNP == c2->type)
+ c->x = c2->x + d * 2;
+ else
+ c->x = c2->x + d;
for (k = 0; k < c->n_pins; k++) {
p = c->pins[k];
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;
+ } else {
+ pc->x = c->x + d * 7 / 8;
+ pe->x = c->x - d * 7 / 8;
+ }
}
}
}
}
+static void __ses_Vb_by_curve(ScfEcomponent* c, double Ib, double* V)
+{
+ int i;
+ for (i = 0; i < c->n_curves; i++) {
+ if (Ib < c->curves[i]->a)
+ break;
+ }
+
+ double V0;
+ double V1;
+ double A0;
+ double A1;
+ double R;
+
+ if (0 == i) {
+ V0 = 0.0;
+ A0 = 0.0;
+ V1 = c->curves[i]->v;
+ A1 = c->curves[i]->a;
+
+ } else if (i >= c->n_curves) {
+ assert(2 <= c->n_curves);
+
+ V0 = c->curves[c->n_curves - 2]->v;
+ A0 = c->curves[c->n_curves - 2]->a;
+ V1 = c->curves[c->n_curves - 1]->v;
+ A1 = c->curves[c->n_curves - 1]->a;
+ } else {
+ V0 = c->curves[i - 1]->v;
+ A0 = c->curves[i - 1]->a;
+ V1 = c->curves[i]->v;
+ A1 = c->curves[i]->a;
+ }
+
+ R = (V1 - V0) / (A1 - A0);
+ *V = V0 + R * (Ib - A0);
+
+ scf_logi("i: %d, n_curves: %ld, Ib: %lg, R: %lg, V: %lg\n", i, c->n_curves, Ib, R, *V);
+}
+
static int __ses_edges_update_Ab(ScfEfunction* f, scf_vector_t* edges, double* A, double* b, double* X, int N, int* n_offs)
{
ses_edge_t* edge;
double dV = Vb - Ve;
double Ib = X[n + edge->index];
double Rb = SCF_EDA_V_NPN_ON / Ib;
-
+ double V = SCF_EDA_V_NPN_ON;
+#if 0
+ if (c->curves && c->n_curves > 0) {
+ __ses_Vb_by_curve(c, Ib, &V);
+ __ses_Vb_by_curve(c, V, &V);
+ Rb = V / Ib;
+ }
+#endif
if (-1e8 < Rb && Rb < 1e8) {
- if (dV < SCF_EDA_V_NPN_ON * 0.99 || dV > SCF_EDA_V_NPN_ON * 1.01) {
+ if (dV < V * 0.99 || dV > V * 1.01) {
if (p0->IC)
- scf_logi("edge: [%d] IC%ld_c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, Ib: %lg, Rb: %lg\n",
- edge->index, p0->IC->id, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, Ib, Rb);
+ scf_logi("edge: [%d] IC%ld_c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, V: %lg, Ib: %lg, Rb: %lg\n",
+ edge->index, p0->IC->id, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, V, Ib, Rb);
else
- scf_logi("edge: [%d] c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, Ib: %lg, Rb: %lg\n",
- edge->index, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, Ib, Rb);
+ scf_logi("edge: [%d] c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, V: %lg, Ib: %lg, Rb: %lg\n",
+ edge->index, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, V, Ib, Rb);
A[(n + edge->index) * N + n + edge->index] = -Rb;
+ b[ n + edge->index] += 0;
k++;
+ } else {
+ if (p0->IC)
+ scf_logw("edge: [%d] IC%ld_c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, V: %lg, Ib: %lg, Rb: %lg\n",
+ edge->index, p0->IC->id, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, V, Ib, Rb);
+ else
+ scf_logw("edge: [%d] c%ldp%ld-c%ldp%ld, Vb: %lg, Ve: %lg, dV: %lg, V: %lg, Ib: %lg, Rb: %lg\n",
+ edge->index, p0->cid, p0->id, p1->cid, p1->id, Vb, Ve, dV, V, Ib, Rb);
}
} else {
c->status = SCF_EDA_Status_OFF;
edge->amplify_flag = 1;
if (p0->IC)
- scf_logi("edge: [%d] IC%ld_c%ldp%ld-c%ldp%ld [b%d], Ic: %lg, Ib: %lg, dI: %lg, dVbe: %lg, Rb: %lg\n",
+ scf_logd("edge: [%d] IC%ld_c%ldp%ld-c%ldp%ld [b%d], Ic: %lg, Ib: %lg, dI: %lg, dVbe: %lg, Rb: %lg\n",
edge->index, p0->IC->id, p0->cid, p0->id, p1->cid, p1->id, edge->edge_b->index, Ic, Ib, dI, dV, Rb);
else
- scf_logi("edge: [%d] c%ldp%ld-c%ldp%ld [b%d], Ic: %lg, Ib: %lg, dI: %lg, dVbe: %lg, Rb: %lg\n",
+ scf_logd("edge: [%d] c%ldp%ld-c%ldp%ld [b%d], Ic: %lg, Ib: %lg, dI: %lg, dVbe: %lg, Rb: %lg\n",
edge->index, p0->cid, p0->id, p1->cid, p1->id, edge->edge_b->index, Ic, Ib, dI, dV, Rb);
for (i = 0; i < N; i++)
int n_offs = 0;
-#define MAX_TRYS 200
+#define MAX_TRYS 20
int try = 0;
do {
n_offs = 0;
}
}
-void ses_path_print(ses_path_t* path)
+void ses_path_print(ses_path_t* path, ScfEfunction* f)
{
if (!path)
return;
- ses_path_t* child;
- ScfEpin* p;
+ ses_path_t* child;
+ ScfEcomponent* c;
+ ScfEpin* p;
int i;
- int j;
if (!path->parent)
printf("\033[31mpath : %d, n_diodes: %d, n_NPNs: %d, n_PNPs: %d, n_capacitors: %d, n_transistors: %d, \033[0m",
for (i = 0; i < path->pins->size; i++) {
p = path->pins->data[i];
- if (p->IC)
- printf("IC%ld_", p->IC->id);
+ if (p->IC) {
+ c = p->IC->f->components[p->cid];
- printf("c%ldp%ld ", p->cid, p->id);
+ printf("IC%ld_", p->IC->id);
+ } else
+ c = f->components[p->cid];
+
+ switch (c->type) {
+ case SCF_EDA_Resistor:
+ printf("R%ldp%ld ", p->cid, p->id);
+ break;
+
+ case SCF_EDA_Capacitor:
+ printf("C%ldp%ld ", p->cid, p->id);
+ break;
+
+ case SCF_EDA_Inductor:
+ printf("L%ldp%ld ", p->cid, p->id);
+ break;
+
+ case SCF_EDA_Diode:
+ printf("D%ldp%ld ", p->cid, p->id);
+ break;
+
+ case SCF_EDA_NPN:
+ case SCF_EDA_PNP:
+ if (SCF_EDA_NPN_B == p->id)
+ printf("T%ldb ", p->cid);
+ else if (SCF_EDA_NPN_C == p->id)
+ printf("T%ldc ", p->cid);
+ else
+ printf("T%lde ", p->cid);
+ break;
+ default:
+ printf("c%ldp%ld ", p->cid, p->id);
+ break;
+ };
}
printf("\n");
printf("\033[34mconnection: %d, n_diodes: %d, n_NPNs: %d, n_PNPs: %d, n_capacitors: %d, n_transistors: %d, parent: %d, \033[0m",
child->index, child->n_diodes, child->n_NPNs, child->n_PNPs, child->n_capacitors, child->n_transistors, path->index);
- ses_path_print(child);
+ ses_path_print(child, f);
} else
printf("\033[34mconnection: %d\033[0m\n", child->index);
}
printf("\033[32mchild : %d, n_diodes: %d, n_NPNs: %d, n_PNPs: %d, n_capacitors: %d, n_transistors: %d, parent: %d, \033[0m",
child->index, child->n_diodes, child->n_NPNs, child->n_PNPs, child->n_capacitors, child->n_transistors, path->index);
- ses_path_print(child);
+ ses_path_print(child, f);
}
}
printf("\033[33mbridge: %d, n_diodes: %d, n_NPNs: %d, n_PNPs: %d, n_capacitors: %d, n_transistors: %d, parent: %d, \033[0m",
child->index, child->n_diodes, child->n_NPNs, child->n_PNPs, child->n_capacitors, child->n_transistors, path->index);
- ses_path_print(child);
+ ses_path_print(child, f);
}
}
}
-void ses_paths_print(scf_vector_t* paths)
+void ses_paths_print(scf_vector_t* paths, ScfEfunction* f)
{
ses_path_t* path;
for (i = 0; i < paths->size; i++) {
path = paths->data[i];
- ses_path_print(path);
+ ses_path_print(path, f);
printf("\n");
}
}
if (lb == LP && le == LN) {
if (pb->IC)
- scf_loge("NPN IC%ld_c%ld, short connected\n", pb->IC->id, c->id);
+ scf_loge("NPN IC%ld_T%ld, short connected\n", pb->IC->id, c->id);
else
- scf_loge("NPN c%ld, short connected\n", c->id);
+ scf_loge("NPN T%ld, short connected\n", c->id);
return -EINVAL;
}
c->status = SCF_EDA_Status_OFF;
if (pb->IC)
- scf_loge("NPN IC%ld_c%ld, status: %d\n", pb->IC->id, c->id, c->status);
+ scf_loge("NPN IC%ld_T%ld, status: %d\n", pb->IC->id, c->id, c->status);
else
- scf_loge("NPN c%ld, status: %d\n", c->id, c->status);
+ scf_loge("NPN T%ld, status: %d\n", c->id, c->status);
continue;
}
if (c->lock) {
if (pb->IC)
- scf_loge("\033[34mIC%ld_c%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
+ scf_loge("\033[34mIC%ld_T%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
pb->IC->id, c->id, c->status, c->lock, pb->v, pe->v, pb->v - pe->v, SCF_EDA_V_NPN_OFF);
else
- scf_loge("\033[34mc%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
+ scf_loge("\033[34mT%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
c->id, c->status, c->lock, pb->v, pe->v, pb->v - pe->v, SCF_EDA_V_NPN_OFF);
continue;
}
}
if (pb->IC)
- scf_loge("\033[34mIC%ld_c%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
+ scf_loge("\033[34mIC%ld_T%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
pb->IC->id, c->id, c->status, c->lock, pb->v, pe->v, pb->v - pe->v, SCF_EDA_V_NPN_OFF);
else
- scf_loge("\033[34mc%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
+ scf_loge("\033[34mT%ld, status: %d, lock: %d, pb->v: %lg, pe->v: %lg, diff: %lg, off: %lg\033[0m\n",
c->id, c->status, c->lock, pb->v, pe->v, pb->v - pe->v, SCF_EDA_V_NPN_OFF);
}
#include<cairo/cairo.h>
#include"ses_core.h"
-#define SHOW_BITS 10000.0
+#define SHOW_BITS 1000.0
static void ses_text_a(cairo_t* cr, int x, int y, double a)
{
cairo_set_source_rgb(cr, 0.0, 0.0, 0.7);
if (v > 1e-1 || v < -1e-1) {
- snprintf(text, sizeof(text) - 1, "%lgv", (int64_t)(v * SHOW_BITS) / SHOW_BITS);
+ snprintf(text, sizeof(text) - 1, "%lgV", (int64_t)(v * SHOW_BITS) / SHOW_BITS);
cairo_move_to (cr, x, y);
cairo_show_text(cr, text);
cairo_set_line_width(cr, 2.5);
- uint8_t text[64];
- int n = snprintf(text, sizeof(text) - 1, "%ld", c->id);
-
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_select_font_face(cr, "Calibri", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, 20);
- cairo_move_to (cr, c->x - 10 - n * 10, c->y - 12);
- cairo_show_text (cr, text);
+
+ uint8_t text[64];
+ int n = 0;
+
+ switch (c->type) {
+ case SCF_EDA_Resistor:
+ n = snprintf(text, sizeof(text) - 1, "R%ld", c->id);
+
+ cairo_move_to(cr, c->x + 10, c->y + 8);
+ break;
+
+ case SCF_EDA_Capacitor:
+ n = snprintf(text, sizeof(text) - 1, "C%ld", c->id);
+
+ cairo_move_to(cr, c->x - 8 - n * 10, c->y - 12);
+ break;
+
+ case SCF_EDA_Inductor:
+ n = snprintf(text, sizeof(text) - 1, "L%ld", c->id);
+
+ cairo_move_to(cr, c->x - 12 - n * 10, c->y - 12);
+ break;
+
+ case SCF_EDA_Diode:
+ n = snprintf(text, sizeof(text) - 1, "D%ld", c->id);
+
+ cairo_move_to(cr, c->x + 15, c->y + 10);
+ break;
+
+ case SCF_EDA_NPN:
+ case SCF_EDA_PNP:
+ n = snprintf(text, sizeof(text) - 1, "T%ld", c->id);
+
+ if (c->pins[SCF_EDA_NPN_B]->y < c->y)
+ cairo_move_to(cr, c->x - 20 - n * 10, c->y - 12);
+ else
+ cairo_move_to(cr, c->x - 20 - n * 10, c->y + 12);
+ break;
+ default:
+ n = snprintf(text, sizeof(text) - 1, "%ld", c->id);
+ cairo_move_to(cr, c->x - 10 - n * 10, c->y - 12);
+ break;
+ };
+
+ cairo_show_text(cr, text);
cairo_stroke(cr);
if ((SCF_EDA_Diode == c->type || SCF_EDA_NPN == c->type) && SCF_EDA_Status_OFF == c->status)
else
snprintf(text, sizeof(text) - 1, "%lguF", c->uf);
- cairo_move_to (cr, c->x + 4, c->y - 5);
+ cairo_move_to (cr, c->x + 2, c->y - 8);
cairo_show_text(cr, text);
cairo_stroke(cr);
break;
cairo_select_font_face(cr, "Georgia", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
- ses_text_a(cr, c->x + 10, c->y + 25, c->a);
+ ses_text_a(cr, c->x + 10, c->y + 27, c->a);
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
if (c->r + c->dr > 1e6)
- snprintf(text, sizeof(text) - 1, "%lgM", (int64_t)(c->r + c->dr) / 1000.0);
+ snprintf(text, sizeof(text) - 1, "%lgMΩ", (int64_t)(c->r + c->dr) / 1000.0);
else if (c->r + c->dr > 999)
- snprintf(text, sizeof(text) - 1, "%lgk", (int64_t)((c->r + c->dr) * 1000.0) / 1000000.0);
+ snprintf(text, sizeof(text) - 1, "%lgkΩ", (int64_t)((c->r + c->dr) * 1000.0) / 1000000.0);
else
snprintf(text, sizeof(text) - 1, "%lgΩ", (int64_t)((c->r + c->dr) * 1000.0) / 1000.0);
- cairo_move_to (cr, c->x + 4, c->y - 5);
+ cairo_move_to (cr, c->x + 10, c->y - 9);
cairo_show_text(cr, text);
cairo_stroke(cr);
break;
cairo_rel_line_to(cr, -dx0 * 2, -dy0 * 2);
cairo_stroke(cr);
+ cairo_select_font_face(cr, "Georgia", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+
if ((c->x + dx3 + dx0 > c->x + dx3 - dx0 && pe->x > pc->x)
|| (c->x + dx3 + dx0 < c->x + dx3 - dx0 && pe->x < pc->x)) {
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
- cairo_line_to(cr, pe->x, pe->y);
+ cairo_line_to(cr, pe->x, c->y + dy3 + dy0);
+ cairo_line_to(cr, pe->x, pe->y);
vertical(&dx1, &dy1, dx3 * 2 + dx0, dy3 * 2 + dy0, 3);
forward (&dx4, &dy4, dx3 * 2 + dx0, dy3 * 2 + dy0, 8);
- cairo_move_to(cr, c->x - dx3 + dx4 + dx1, c->y - dy3 + dy4 + dy1);
- cairo_line_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
+ cairo_move_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
+ cairo_line_to(cr, c->x - dx3 + dx4 + dx1, c->y - dy3 + dy4 + dy1);
+ cairo_move_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
cairo_line_to(cr, c->x - dx3 + dx4 - dx1, c->y - dy3 + dy4 - dy1);
cairo_stroke(cr);
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
- cairo_line_to(cr, pc->x, pc->y);
+ cairo_line_to(cr, pc->x, c->y + dy3 - dy0);
+ cairo_line_to(cr, pc->x, pc->y);
cairo_stroke(cr);
} else {
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
- cairo_line_to(cr, pc->x, pc->y);
+ cairo_line_to(cr, pc->x, c->y + dy3 + dy0);
+ cairo_line_to(cr, pc->x, pc->y);
cairo_stroke(cr);
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
- cairo_line_to(cr, pe->x, pe->y);
+ cairo_line_to(cr, pe->x, c->y + dy3 - dy0);
+ cairo_line_to(cr, pe->x, pe->y);
vertical(&dx1, &dy1, dx3 * 2 - dx0, dy3 * 2 - dy0, 3);
forward (&dx4, &dy4, dx3 * 2 - dx0, dy3 * 2 - dy0, 8);
- cairo_move_to(cr, c->x - dx3 + dx4 + dx1, c->y - dy3 + dy4 + dy1);
- cairo_line_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
+ cairo_move_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
+ cairo_line_to(cr, c->x - dx3 + dx4 + dx1, c->y - dy3 + dy4 + dy1);
+ cairo_move_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
cairo_line_to(cr, c->x - dx3 + dx4 - dx1, c->y - dy3 + dy4 - dy1);
cairo_stroke(cr);
}
- cairo_select_font_face(cr, "Georgia", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
- if (pb->y > c->y)
- ses_text_a(cr, c->x, c->y + 20, pb->a);
- else
- ses_text_a(cr, c->x, c->y - 20, pb->a);
+ if (pb->y > c->y) {
+ ses_text_a(cr, c->x + 2, c->y + 32, pb->a);
- ses_text_a(cr, c->x, c->y, pc->a);
+ if (pc->x < c->x) {
+ ses_text_a(cr, pc->x + 2, c->y - 10, pc->a);
+ ses_text_a(cr, c ->x + 2, c->y - 10, pe->a);
+ } else {
+ ses_text_a(cr, pe->x + 2, c->y - 10, pe->a);
+ ses_text_a(cr, c ->x + 2, c->y - 10, pc->a);
+ }
+ } else {
+ ses_text_a(cr, c->x + 2, c->y - 28, pb->a);
- if (pe->y > c->y)
- ses_text_a(cr, c->x, c->y + 20, pe->a);
- else
- ses_text_a(cr, c->x, c->y - 20, pe->a);
+ if (pc->x < c->x) {
+ ses_text_a(cr, pc->x + 2, c->y + 28, pc->a);
+ ses_text_a(cr, c ->x + 2, c->y + 28, pe->a);
+ } else {
+ ses_text_a(cr, pe->x + 2, c->y + 28, pe->a);
+ ses_text_a(cr, c ->x + 2, c->y + 28, pc->a);
+ }
+ }
cairo_stroke(cr);
break;
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
- cairo_line_to(cr, pe->x, pe->y);
+ cairo_line_to(cr, pe->x, c->y + dy3 + dy0);
+ cairo_line_to(cr, pe->x, pe->y);
vertical(&dx1, &dy1, dx3 * 2 + dx0, dy3 * 2 + dy0, 4);
forward (&dx4, &dy4, dx3 * 2 + dx0, dy3 * 2 + dy0, 12);
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
- cairo_line_to(cr, pc->x, pc->y);
+ cairo_line_to(cr, pc->x, c->y + dy3 - dy0);
+ cairo_line_to(cr, pc->x, pc->y);
cairo_stroke(cr);
} else {
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 + dx0, c->y + dy3 + dy0);
- cairo_line_to(cr, pc->x, pc->y);
+ cairo_line_to(cr, pc->x, c->y + dy3 + dy0);
+ cairo_line_to(cr, pc->x, pc->y);
cairo_stroke(cr);
cairo_move_to(cr, c->x - dx3, c->y - dy3);
cairo_line_to(cr, c->x + dx3 - dx0, c->y + dy3 - dy0);
- cairo_line_to(cr, pe->x, pe->y);
+ cairo_line_to(cr, pe->x, c->y + dy3 - dy0);
+ cairo_line_to(cr, pe->x, pe->y);
vertical(&dx1, &dy1, dx3 * 2 - dx0, dy3 * 2 - dy0, 4);
forward (&dx4, &dy4, dx3 * 2 - dx0, dy3 * 2 - dy0, 12);
cairo_select_font_face(cr, "Georgia", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
- if (pb->y > c->y)
- ses_text_a(cr, c->x, c->y + 20, pb->a);
- else
- ses_text_a(cr, c->x, c->y - 20, pb->a);
+ if (pb->y > c->y) {
+ ses_text_a(cr, c->x + 2, c->y + 32, pb->a);
- ses_text_a(cr, c->x, c->y, pc->a);
+ if (pc->x < c->x) {
+ ses_text_a(cr, pc->x + 2, c->y - 10, pc->a);
+ ses_text_a(cr, c ->x + 2, c->y - 10, pe->a);
+ } else {
+ ses_text_a(cr, pe->x + 2, c->y - 10, pe->a);
+ ses_text_a(cr, c ->x + 2, c->y - 10, pc->a);
+ }
+ } else {
+ ses_text_a(cr, c->x + 2, c->y - 28, pb->a);
+
+ if (pc->x < c->x) {
+ ses_text_a(cr, pc->x + 2, c->y + 28, pc->a);
+ ses_text_a(cr, c ->x + 2, c->y + 28, pe->a);
+ } else {
+ ses_text_a(cr, pe->x + 2, c->y + 28, pe->a);
+ ses_text_a(cr, c ->x + 2, c->y + 28, pc->a);
+ }
+ }
- if (pe->y > c->y)
- ses_text_a(cr, c->x, c->y + 20, pe->a);
- else
- ses_text_a(cr, c->x, c->y - 20, pe->a);
cairo_stroke(cr);
break;
if (!prev) {
cairo_select_font_face(cr, "Calibri", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
-
cairo_set_font_size(cr, 28);
int n = snprintf(text, sizeof(text) - 1, "%ld", el->id);
cairo_move_to (cr, l->x0 - 10 - n * 12, l->y0 + 10);
cairo_show_text(cr, text);
cairo_stroke(cr);
-
- // V of line
- if (el->v < SCF_EDA_V_MIN)
- n = snprintf(text, sizeof(text) - 1, "0v");
- else if (el->v > SCF_EDA_V_MAX)
- n = snprintf(text, sizeof(text) - 1, "%lgv", B->pins[SCF_EDA_Battery_POS]->v);
-
- else if (el->v > 1e-2 || el->v < -1e-2)
- n = snprintf(text, sizeof(text) - 1, "%lgv", (int64_t)(el->v * SHOW_BITS) / SHOW_BITS);
-
- else if (el->v > 1e-5 || el->v < -1e-5)
- n = snprintf(text, sizeof(text) - 1, "%lgmV", (int64_t)(el->v * 1000.0 * SHOW_BITS) / SHOW_BITS);
- else
- n = snprintf(text, sizeof(text) - 1, "%lguV", (int64_t)(el->v * 1000000.0 * SHOW_BITS) / SHOW_BITS);
-
- cairo_set_font_size(cr, 20);
-
- if (el->v == B->pins[SCF_EDA_Battery_POS]->v)
- cairo_set_source_rgb(cr, 1, 0, 0);
-
- else if (el->v == B->pins[SCF_EDA_Battery_NEG]->v)
- cairo_set_source_rgb(cr, 0, 0, 1);
-
- cairo_move_to (cr, l->x0 + 10, l->y0 - 8);
- cairo_show_text(cr, text);
- cairo_stroke(cr);
}
cairo_set_line_width(cr, 4);
prev = l;
}
+
+ if (prev) {
+ int n;
+
+ if (el->v < SCF_EDA_V_MIN)
+ n = snprintf(text, sizeof(text) - 1, "0V");
+ else if (el->v > SCF_EDA_V_MAX)
+ n = snprintf(text, sizeof(text) - 1, "%lgV", B->pins[SCF_EDA_Battery_POS]->v);
+
+ else if (el->v > 1e-2 || el->v < -1e-2)
+ n = snprintf(text, sizeof(text) - 1, "%lgV", (int64_t)(el->v * SHOW_BITS) / SHOW_BITS);
+
+ else if (el->v > 1e-5 || el->v < -1e-5)
+ n = snprintf(text, sizeof(text) - 1, "%lgmV", (int64_t)(el->v * 1000.0 * SHOW_BITS) / SHOW_BITS);
+ else
+ n = snprintf(text, sizeof(text) - 1, "%lguV", (int64_t)(el->v * 1000000.0 * SHOW_BITS) / SHOW_BITS);
+
+ if (el->v == B->pins[SCF_EDA_Battery_POS]->v)
+ cairo_set_source_rgb(cr, 1, 0, 0);
+ else if (el->v == B->pins[SCF_EDA_Battery_NEG]->v)
+ cairo_set_source_rgb(cr, 0, 0, 1);
+
+ cairo_set_font_size(cr, 20);
+
+ if (prev->x1 - prev->x0 >= 12 + n * 12)
+ cairo_move_to(cr, prev->x1 - 12 - n * 12, prev->y0 - 5);
+ else
+ cairo_move_to(cr, prev->x1 + 4, prev->y0 - 5);
+
+ cairo_show_text(cr, text);
+ cairo_stroke(cr);
+ }
}
__ses_function_draw(f, cr);
return 0;
}
-static int __topo_bridge_connection(ScfEfunction* f, scf_vector_t* paths, ses_path_t* bridge, ScfEpin* vip, ses_path_t** ppath)
+static int __topo_connect(ScfEfunction* f, scf_vector_t* paths, ses_path_t* conn, ScfEpin* vip, ses_path_t** ppath)
{
ses_path_t* path;
- ses_path_t* conn;
- ScfEpin* p0 = bridge->pins->data[0];
- ScfEpin* p1 = bridge->pins->data[bridge->pins->size - 1];
+ ScfEpin* p0 = conn->pins->data[0];
+ ScfEpin* p1 = conn->pins->data[conn->pins->size - 1];
ScfEpin* p2;
ScfEpin* p3;
for (j = 0; j < paths->size; j++) {
path = paths->data[j];
- if (path == bridge)
+ if (path == conn)
continue;
p2 = path->pins->data[0];
}
if (path->childs) {
- k = __topo_bridge_connection(f, path->childs, bridge, vip, ppath);
+ k = __topo_connect(f, path->childs, conn, vip, ppath);
if (k >= 0)
return k;
}
if (path->bridges) {
- k = __topo_bridge_connection(f, path->bridges, bridge, vip, ppath);
+ k = __topo_connect(f, path->bridges, conn, vip, ppath);
if (k >= 0)
return k;
}
if (ses_same_line(f, p1, Bn))
continue;
- k = __topo_bridge_connection(f, paths, pier, p1, &bridge);
+ k = __topo_connect(f, paths, pier, p1, &bridge);
if (k < 0)
continue;
} else if (ses_same_line(f, p1, Bn)) {
- k = __topo_bridge_connection(f, paths, pier, p0, &bridge);
+ k = __topo_connect(f, paths, pier, p0, &bridge);
if (k < 0)
continue;
if (ses_same_line(f, p0, Bp) && ses_same_line(f, p1, Bn))
continue;
- int k0 = __topo_bridge_connection(f, paths, path, p0, &path->conn0);
+ int k0 = __topo_connect(f, paths, path, p0, &path->conn0);
if (k0 < 0)
continue;
- int k1 = __topo_bridge_connection(f, paths, path, p1, &path->conn1);
+ int k1 = __topo_connect(f, paths, path, p1, &path->conn1);
if (k1 < 0)
continue;
return ret;
scf_logi("\n");
- ses_paths_print(ctx->paths);
+ ses_paths_print(ctx->paths, f);
scf_logi("\n\n");
ret = __ses_topo_layers(f, ctx->paths);
_topo_key_components(f, path);
}
- ses_paths_print(ctx->paths);
+ ses_paths_print(ctx->paths, f);
return 0;
}
c->count = count;
- scf_loge("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_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",
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_loge("path: %d, i: %d, c%ldp%ld, p->v: %lg, dv: %lg, a: %lg, p->pr: %lg, e%ld->v: %lg\n",
+ scf_logi("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);
}
}
scf_eboard__add_function(b, f);
- int len = 0;
+ long len = 0;
uint8_t* buf = NULL;
ScfEboard_pack(b, &buf, &len);
#include <gsl/gsl_fft_complex.h>
#include <gsl/gsl_fft_real.h>
#include <gsl/gsl_fft_halfcomplex.h>
+#include <cairo/cairo.h>
#define REAL(z,i) ((z)[2*(i)])
#define IMAG(z,i) ((z)[2*(i)+1])
-#define N 256
+#define N 512
int main()
{
double data[2 * N];
+ cairo_surface_t* surface;
+ cairo_t* cr;
+
+ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 600, 400);
+ cr = cairo_create (surface);
+
+ cairo_set_line_width(cr, 2);
+ cairo_set_source_rgb(cr, 1, 1, 1);
+ cairo_rectangle (cr, 0, 0, 600, 600);
+ cairo_fill(cr);
+ cairo_stroke(cr);
+
+ cairo_select_font_face(cr, "Calibri", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+ cairo_set_font_size(cr, 20);
+ cairo_set_source_rgb(cr, 0, 0, 0);
+
+ cairo_move_to(cr, 20, 234.5);
+ cairo_line_to(cr, 580, 234.5);
+ cairo_stroke(cr);
+
+ double v0 = 0.0;
+ double s = 0.0;
+ double min = 10.0;
+ double max = 0.0;
+ int n = 0;
+
for (i = 0; i < N; i++) {
fscanf(fp, "%d, %lg", &j, &v);
+
REAL(data, i) = v;
IMAG(data, i) = 0.0;
+#if 1
+ if (i > 11 && i < 550) {
+ printf("i: %d, v0: %lg, v: %lg\n", i, v0, v);
+
+ if (max < v)
+ max = v;
+ if (min > v)
+ min = v;
+
+ cairo_move_to(cr, 40 + (i - 1), 300 - 20 * v0);
+ cairo_line_to(cr, 40 + i, 300 - 20 * v);
+ cairo_stroke(cr);
+
+ s += v;
+ n++;
+ }
+ v0 = v;
+#endif
}
+
+ printf("s/n: %lg, max: %lg, min: %lg, 300 - 10 * (max + min): %lg\n", s/n, max, min, 300 - 10 * (max + min));
+
+ cairo_surface_write_to_png(surface, "sin.png");
+
+ cairo_destroy(cr);
+ cairo_surface_destroy(surface);
+ surface = NULL;
+ cr = NULL;
+
gsl_fft_complex_radix2_forward(data, 1, N);
double Zmax = 0;
scf_eboard__add_function(b, f);
- int len = 0;
+ long len = 0;
uint8_t* buf = NULL;
ScfEboard_pack(b, &buf, &len);
projects / ses.git / commitdiff