1, add some options with argv[] in command line, such as show the voltage & current...

2, save a temp file of .cpk every 100 times, it can be run continue next time.

diff --git a/main.c b/main.c
index b8c905685347bfbbdceb019610b59af48bf9814c..198706d077fadb76ff789c43b7396e77966c1d58 100644 (file)
--- a/main.c
+++ b/main.c
@@ -186,14 +186,17 @@ int ses_draw_IC(ScfEcomponent* c)
 
 static void usage()
 {
-       printf("usage: ./ses [-l] [-f fname] [-t timeslice] [-c count] [-I IC] [-V 0,1,...] [-A 0,1,...] src.cpk\n\n");
-       printf("-l: need layout\n");
+       printf("usage: ./ses [-l 0] [-f fname] [-t timeslice] [-c count] [-d 0] [-s Nth] [-n N] [-I IC] [-V \"v0, v1 - v2,...\"] [-A \"i1,i2c,...\"] src.cpk\n\n");
+       printf("-l: if need layout: 0 not, 1 layout, default is 1.\n");
        printf("-f: function name in board\n");
        printf("-t: time slice, such as 100ps, 100ns, 100us, 100ms.\n");
        printf("-c: count of running times\n");
+       printf("-d: if draw graphs of circuit status: 0 not, 1 draw, default is 1.\n");
+       printf("-s: show from the Nth sample\n");
+       printf("-n: show when every N samples\n");
        printf("-I: show the internal circuit graph of IC number\n");
-       printf("-V: show the voltage of line numbers\n");
-       printf("-A: show the current of component numbers\n");
+       printf("-V: show the voltage of line numbers, v1 - v2 means the diff voltage between line 1 and line 2.\n");
+       printf("-A: show the current of components, i1 means the component with ID 1, i2c means the C pin of NPN or PNP with ID 2.\n");
        printf("src.cpk: electronic model file to simulate\n\n");
 }
 
@@ -211,7 +214,11 @@ int main(int argc, char* argv[])
        int64_t  count  = 1;
        int64_t  ps     = 100;
        int64_t  IC     = -1;
-       int      layout = 0;
+
+       int      layout = 1;
+       int      draw   = 1;
+       int      start  = 0;
+       int      every  = 1;
 
        long i;
        long j;
@@ -226,7 +233,12 @@ int main(int argc, char* argv[])
 
                        switch (argv[i][1]) {
                                case 'l':
-                                       layout = 1;
+                                       if (++i >= argc) {
+                                               usage();
+                                               return -EINVAL;
+                                       }
+
+                                       layout = atoi(argv[i]);
                                        break;
 
                                case 'f':
@@ -274,6 +286,33 @@ int main(int argc, char* argv[])
                                        count = atol(argv[i]);
                                        break;
 
+                               case 'd':
+                                       if (++i >= argc) {
+                                               usage();
+                                               return -EINVAL;
+                                       }
+
+                                       draw = atol(argv[i]);
+                                       break;
+                               case 's':
+                                       if (++i >= argc) {
+                                               usage();
+                                               return -EINVAL;
+                                       }
+
+                                       start = atol(argv[i]);
+                                       break;
+                               case 'n':
+                                       if (++i >= argc) {
+                                               usage();
+                                               return -EINVAL;
+                                       }
+
+                                       every = atol(argv[i]);
+                                       if (every < 1)
+                                               every = 1;
+                                       break;
+
                                case 't':
                                        if (++i >= argc) {
                                                usage();
@@ -383,6 +422,14 @@ int main(int argc, char* argv[])
                        break;
                }
 
+               ctx->Vshow = V;
+               ctx->Ashow = A;
+
+               ctx->start = start;
+               ctx->N     = every;
+               ctx->i     = 0;
+               ctx->draw_flag = draw;
+
                ret = 0;
                if (fname) {
                        if (!strcmp(f->name, fname)) {

diff --git a/ses_core.h b/ses_core.h
index 0213f127e3bf734f29314b7b532a366b958f358a..01401a1042f64eab84c7435fb64c6d94bac8c1b1 100644 (file)
--- a/ses_core.h
+++ b/ses_core.h
@@ -108,7 +108,18 @@ struct ses_ctx_s
 {
        scf_vector_t*  paths;
 
+       char*          Vshow;
+       char*          Ashow;
+
+       FILE*          Vfp;
+       FILE*          Afp;
+
        int            changed;
+
+       int            start;
+       int            N;
+       int            i;
+       uint8_t        draw_flag:1;
 };
 
 struct ses_step_s

diff --git a/ses_step_draw.c b/ses_step_draw.c
index e1fc818bf6d42350bbc717c56a0bd71d96807c64..ca3e43395dd2bfe8a6c19146b17ab6bf48acc049 100644 (file)
--- a/ses_step_draw.c
+++ b/ses_step_draw.c
@@ -1547,36 +1547,182 @@ static void __draw_IC(ScfEfunction* f, int64_t ps, int64_t count, int64_t i)
        }
 }
 
-static int _draw_handler(ScfEfunction* f, int64_t ps, int64_t count, ses_ctx_t* ctx)
+static int print_a(ScfEfunction* f, ses_ctx_t* ctx)
 {
-       static int64_t i = 0;
+       if (!ctx->Ashow)
+               return 0;
 
-       char file[128];
-       snprintf(file, sizeof(file) - 1, "./draw_%ld.png", i);
-#if 0
-       if (count < 64000 && count > 100)
+       if (!ctx->Afp) {
+               ctx->Afp = fopen("a.txt", "w");
+               if (!ctx->Afp)
+                       return -1;
+       }
+
+       char* p;
+       int   j = -1;
+       int   k = SCF_EDA_NPN_E;
+
+       fprintf(ctx->Afp, "%d", ctx->i);
+
+       for (p = ctx->Ashow; *p; p++) {
+
+               switch (*p) {
+                       case 'i':
+                       case 'I':
+                               j = 0;
+                               break;
+                       case '0':
+                       case '1':
+                       case '2':
+                       case '3':
+                       case '4':
+                       case '5':
+                       case '6':
+                       case '7':
+                       case '8':
+                       case '9':
+                               if (j >= 0)
+                                       j = j * 10 + *p - '0';
+                               break;
+
+                       case 'b':
+                               k = SCF_EDA_NPN_B;
+                               break;
+                       case 'c':
+                               k = SCF_EDA_NPN_C;
+                               break;
+                       case 'e':
+                               k = SCF_EDA_NPN_E;
+                               break;
+
+                       case ',':
+                               if (j >= 0 && j < f->n_components) {
+                                       ScfEcomponent* c = f->components[j];
+
+                                       double a = c->a;
+
+                                       if (SCF_EDA_NPN == c->type || SCF_EDA_PNP == c->type)
+                                               a = c->pins[k]->a;
+
+                                       fprintf(ctx->Afp, ", %lg", a);
+                               }
+
+                               j = -1;
+                               k = SCF_EDA_NPN_E;
+                               break;
+                       default:
+                               break;
+               };
+       }
+
+       if (j >= 0 && j < f->n_components) {
+               ScfEcomponent* c = f->components[j];
+
+               double a = c->a;
+
+               if (SCF_EDA_NPN == c->type || SCF_EDA_PNP == c->type)
+                       a = c->pins[k]->a;
+
+               fprintf(ctx->Afp, ", %lg", a);
+       }
+
+       fprintf(ctx->Afp, "\n");
+       fflush(ctx->Afp);
+       return 0;
+}
+
+static int print_v(ScfEfunction* f, ses_ctx_t* ctx)
+{
+       if (!ctx->Vshow)
                return 0;
-#endif
 
-       if (1 || count % 10 == 0) {
-#if 1
-               static FILE* fp = NULL;
-               if (!fp)
-                       fp = fopen("v.txt", "w");
+       if (!ctx->Vfp) {
+               ctx->Vfp = fopen("v.txt", "w");
+               if (!ctx->Vfp)
+                       return -1;
+       }
 
-               if (fp) {
-                       fprintf(fp, "%ld, %lg\n", i, f->elines[4]->v);
-                       fflush(fp);
-               }
-#endif
-               int j = count % 400;
+       char* p;
+       int   op = 0;
+       int   j  = -1;
+       int   k  = -1;
+
+       fprintf(ctx->Vfp, "%d", ctx->i);
+
+       for (p = ctx->Vshow; *p; p++) {
+
+               switch (*p) {
+                       case 'v':
+                       case 'V':
+                               if (j < 0)
+                                       j = atoi(p + 1);
+                               else
+                                       k = atoi(p + 1);
+                               break;
+
+                       case '-':
+                               op = '-';
+                               break;
+
+                       case ',':
+                               if ('-' == op) {
+                                       if (j >= 0
+                                                       && j < f->n_elines
+                                                       && k < f->n_elines
+                                                       && k >= 0)
+                                               fprintf(ctx->Vfp, ", %lg", f->elines[j]->v - f->elines[k]->v);
+
+                               } else {
+                                       if (j >= 0 && j < f->n_elines)
+                                               fprintf(ctx->Vfp, ", %lg", f->elines[j]->v);
+                               }
+
+                               j  = -1;
+                               k  = -1;
+                               op = 0;
+                               break;
+                       default:
+                               break;
+               };
+       }
+
+       if ('-' == op) {
+               if (j >= 0
+                               && j < f->n_elines
+                               && k < f->n_elines
+                               && k >= 0)
+                       fprintf(ctx->Vfp, ", %lg", f->elines[j]->v - f->elines[k]->v);
+
+       } else {
+               if (j >= 0 && j < f->n_elines)
+                       fprintf(ctx->Vfp, ", %lg", f->elines[j]->v);
+       }
+
+       fprintf(ctx->Vfp, "\n");
+       fflush(ctx->Vfp);
+       return 0;
+}
+
+static int _draw_handler(ScfEfunction* f, int64_t ps, int64_t count, ses_ctx_t* ctx)
+{
+       if (count < ctx->start)
+               return 0;
+
+       if (count % ctx->N == 0) {
+
+               print_v(f, ctx);
+               print_a(f, ctx);
+
+               if (ctx->draw_flag) {
+                       char file[128];
+                       snprintf(file, sizeof(file) - 1, "./draw_%d.png", ctx->i);
 
-//             if (j > 396 || j < 20) {
                        ses_draw(f, file, f->x, f->y, f->w, f->h, ps, count);
 
-                       __draw_IC(f, ps, count, i);
-//             }
-               i++;
+                       __draw_IC(f, ps, count, ctx->i);
+               }
+
+               ctx->i++;
        }
 
        return 0;

diff --git a/ses_utils.c b/ses_utils.c
index 9dd7bdf796a1cc88735092503cfe7117faa311fa..67eba7abff02d73ae08c56d56d0bd0cad6dfb203 100644 (file)
--- a/ses_utils.c
+++ b/ses_utils.c
@@ -23,6 +23,12 @@ void ses_ctx_free(ses_ctx_t* ctx)
                        scf_vector_free (ctx->paths);
                }
 
+               if (ctx->Vfp)
+                       fclose(ctx->Vfp);
+
+               if (ctx->Afp)
+                       fclose(ctx->Afp);
+
                free(ctx);
        }
 }