From 196ed3be1b00eca3b00699ac3f46fbaf37bb4820 Mon Sep 17 00:00:00 2001
From: Edward Emelianov <eddy@sao.ru>
Date: Mon, 8 Dec 2025 13:31:23 +0300
Subject: [PATCH] change time from double to struct timespec

---
 LibSidServo/PID.c                     |  25 ++---
 LibSidServo/PID.h                     |   2 +-
 LibSidServo/examples/dump.c           |  33 +++---
 LibSidServo/examples/dump.h           |   2 +-
 LibSidServo/examples/dumpswing.c      |  12 +--
 LibSidServo/examples/goto.c           |   3 +-
 LibSidServo/examples/scmd_traectory.c |  25 +++--
 LibSidServo/examples/traectories.c    |   2 +-
 LibSidServo/main.c                    |  84 +++++++++++----
 LibSidServo/main.h                    |   7 +-
 LibSidServo/movingmodel.c             |   2 +-
 LibSidServo/serial.c                  | 145 +++++++++-----------------
 LibSidServo/sidservo.h                |   5 +-
 LibSidServo/ssii.c                    |  28 ++---
 LibSidServo/ssii.h                    |   4 +-
 15 files changed, 189 insertions(+), 190 deletions(-)

diff --git a/LibSidServo/PID.c b/LibSidServo/PID.c
index e043a82..3f642cd 100644
--- a/LibSidServo/PID.c
+++ b/LibSidServo/PID.c
@@ -84,8 +84,9 @@ typedef struct{
  * @return calculated new speed or -1 for max speed
  */
 static double getspeed(const coordval_t *tagpos, PIDpair_t *pidpair, axisdata_t *axis){
-    if(tagpos->t < axis->position.t || tagpos->t - axis->position.t > Conf.PIDMaxDt){
-        DBG("target time: %g, axis time: %g - too big! (tag-ax=%g)", tagpos->t, axis->position.t, tagpos->t - axis->position.t);
+    double dt = timediff(&tagpos->t, &axis->position.t);
+    if(dt < 0 || dt > Conf.PIDMaxDt){
+        DBG("target time: %ld, axis time: %ld - too big! (tag-ax=%g)", tagpos->t.tv_sec, axis->position.t.tv_sec, dt);
         return axis->speed.val; // data is too old or wrong
     }
     double error = tagpos->val - axis->position.val, fe = fabs(error);
@@ -125,9 +126,9 @@ static double getspeed(const coordval_t *tagpos, PIDpair_t *pidpair, axisdata_t
             }else DBG("Current error: %g", fe);
             break;
         case AXIS_STOPPED: // start pointing to target; will change speed next time
-            DBG("AXIS STOPPED!!!!");
+            DBG("AXIS STOPPED!!!! --> Slewing");
             axis->state = AXIS_SLEWING;
-            return NAN;
+            return getspeed(tagpos, pidpair, axis);
         case AXIS_ERROR:
             DBG("Can't move from erroneous state");
             return 0.;
@@ -136,16 +137,16 @@ static double getspeed(const coordval_t *tagpos, PIDpair_t *pidpair, axisdata_t
         DBG("WTF? Where is a PID?");
         return axis->speed.val;
     }
-    if(tagpos->t < pid->prevT || tagpos->t - pid->prevT > Conf.PIDMaxDt){
+    double dtpid = timediff(&tagpos->t, &pid->prevT);
+    if(dtpid < 0 || dtpid > Conf.PIDMaxDt){
         DBG("time diff too big: clear PID");
         pid_clear(pid);
     }
-    double dt = tagpos->t - pid->prevT;
-    if(dt > Conf.PIDMaxDt) dt = Conf.PIDCycleDt;
+    if(dtpid > Conf.PIDMaxDt) dtpid = Conf.PIDCycleDt;
     pid->prevT = tagpos->t;
-    DBG("CALC PID (er=%g, dt=%g), state=%d", error, dt, axis->state);
-    double tagspeed = pid_calculate(pid, error, dt);
-    if(axis->state == AXIS_GUIDING) return axis->speed.val + tagspeed / dt; // velocity-based
+    DBG("CALC PID (er=%g, dt=%g), state=%d", error, dtpid, axis->state);
+    double tagspeed = pid_calculate(pid, error, dtpid);
+    if(axis->state == AXIS_GUIDING) return axis->speed.val + tagspeed / dtpid; // velocity-based
     return tagspeed; // coordinate-based
 }
 
@@ -214,7 +215,7 @@ mcc_errcodes_t correct2(const coordval_pair_t *target){
     adder = dv/Ylimits.max.accel * (m.encYspeed.val + dv / 2.)
             + Conf.PIDMaxDt * tagspeed.Y
             + tagspeed.Y * tagspeed.Y / Ylimits.max.accel / 2.;
-    endpoint.Y = m.encYposition.val + Ysign * tagspeed.Y / Ylimits.max.accel;
-    DBG("TAG speeds: %g/%g; TAG pos: %g/%g", tagspeed.X, tagspeed.Y, endpoint.X, endpoint.Y);
+    endpoint.Y = m.encYposition.val + Ysign * adder;
+    DBG("TAG speeds: %g/%g (deg/s); TAG pos: %g/%g (deg)", tagspeed.X/M_PI*180., tagspeed.Y/M_PI*180., endpoint.X/M_PI*180., endpoint.Y/M_PI*180.);
     return Mount.moveWspeed(&endpoint, &tagspeed);
 }
diff --git a/LibSidServo/PID.h b/LibSidServo/PID.h
index 30f1aa2..5ecfad0 100644
--- a/LibSidServo/PID.h
+++ b/LibSidServo/PID.h
@@ -27,7 +27,7 @@ typedef struct {
     double prev_error;  // Previous error
     double integral;    // Integral term
     double *pidIarray;  // array for Integral
-    double prevT;       // time of previous correction
+    struct timespec prevT; // time of previous correction
     size_t pidIarrSize; // it's size
     size_t curIidx;     // and index of current element
 } PIDController_t;
diff --git a/LibSidServo/examples/dump.c b/LibSidServo/examples/dump.c
index a04b375..de111ed 100644
--- a/LibSidServo/examples/dump.c
+++ b/LibSidServo/examples/dump.c
@@ -24,7 +24,7 @@
 #include "simpleconv.h"
 
 // starting dump time (to conform different logs)
-static double dumpT0 = -1.;
+static struct timespec dumpT0 = {0};
 
 #if 0
 // amount of elements used for encoders' data filtering
@@ -63,7 +63,9 @@ static double filter(double val, int idx){
 #endif
 
 // return starting time of dump
-double dumpt0(){ return dumpT0; }
+void dumpt0(struct timespec *t){
+    if(t) *t = dumpT0;
+}
 
 
 /**
@@ -77,10 +79,10 @@ void logmnt(FILE *fcoords, mountdata_t *m){
     if(!m){ // write header
         fprintf(fcoords, "      time    Xmot(deg)   Ymot(deg) Xenc(deg)  Yenc(deg)   VX(d/s)    VY(d/s)     millis\n");
         return;
-    }else if(dumpT0 < 0.) dumpT0 = m->encXposition.t;
+    }else if(dumpT0.tv_sec == 0) dumpT0 = m->encXposition.t;
     // write data
     fprintf(fcoords, "%12.6f %10.6f %10.6f %10.6f %10.6f %10.6f %10.6f %10u\n",
-            m->encXposition.t - dumpT0, RAD2DEG(m->motXposition.val), RAD2DEG(m->motYposition.val),
+            Mount.timeDiff(&m->encXposition.t, &dumpT0), RAD2DEG(m->motXposition.val), RAD2DEG(m->motYposition.val),
             RAD2DEG(m->encXposition.val), RAD2DEG(m->encYposition.val),
             RAD2DEG(m->encXspeed.val), RAD2DEG(m->encYspeed.val),
             m->millis);
@@ -106,16 +108,17 @@ void dumpmoving(FILE *fcoords, double t, int N){
         LOGWARN("Can't get mount data");
     }
     uint32_t mdmillis = mdata.millis;
-    double enct = (mdata.encXposition.t + mdata.encYposition.t) / 2.;
+    struct timespec encXt = mdata.encXposition.t;
     int ctr = -1;
     double xlast = mdata.motXposition.val, ylast = mdata.motYposition.val;
-    double t0 = Mount.currentT();
-    while(Mount.currentT() - t0 < t && ctr < N){
+    double t0 = Mount.timeFromStart();
+    while(Mount.timeFromStart() - t0 < t && ctr < N){
         usleep(1000);
         if(MCC_E_OK != Mount.getMountData(&mdata)){ WARNX("Can't get data"); continue;}
-        double tmsr = (mdata.encXposition.t + mdata.encYposition.t) / 2.;
-        if(tmsr == enct) continue;
-        enct = tmsr;
+        //double tmsr = (mdata.encXposition.t + mdata.encYposition.t) / 2.;
+        struct timespec msrt = mdata.encXposition.t;
+        if(msrt.tv_nsec == encXt.tv_nsec) continue;
+        encXt = msrt;
         if(fcoords) logmnt(fcoords, &mdata);
         if(mdata.millis == mdmillis) continue;
         //DBG("ctr=%d, motpos=%g/%g", ctr, mdata.motXposition.val, mdata.motYposition.val);
@@ -126,7 +129,7 @@ void dumpmoving(FILE *fcoords, double t, int N){
             ctr = 0;
         }else ++ctr;
     }
-    DBG("Exit dumping; tend=%g, tmon=%g", t, Mount.currentT() - t0);
+    DBG("Exit dumping; tend=%g, tmon=%g", t, Mount.timeFromStart() - t0);
 }
 
 /**
@@ -146,14 +149,6 @@ void waitmoving(int N){
         millis = mdata.millis;
         if(mdata.Xstate != AXIS_STOPPED || mdata.Ystate != AXIS_STOPPED) ctr = 0;
         else ++ctr;
-        /*
-        if(mdata.motXposition.val != xlast || mdata.motYposition.val != ylast){
-            xlast = mdata.motXposition.val;
-            ylast = mdata.motYposition.val;
-            //DBG("x/y: %g/%g", RAD2DEG(xlast), RAD2DEG(ylast));
-            ctr = 0;
-        }else ++ctr;
-        */
     }
 }
 
diff --git a/LibSidServo/examples/dump.h b/LibSidServo/examples/dump.h
index 0089539..0731f2e 100644
--- a/LibSidServo/examples/dump.h
+++ b/LibSidServo/examples/dump.h
@@ -27,4 +27,4 @@ void dumpmoving(FILE *fcoords, double t, int N);
 void waitmoving(int N);
 int getPos(coordval_pair_t *mot, coordval_pair_t *enc);
 void chk0(int ncycles);
-double dumpt0();
+void dumpt0(struct timespec *t);
diff --git a/LibSidServo/examples/dumpswing.c b/LibSidServo/examples/dumpswing.c
index 01002ab..4d4b51f 100644
--- a/LibSidServo/examples/dumpswing.c
+++ b/LibSidServo/examples/dumpswing.c
@@ -83,7 +83,7 @@ void waithalf(double t){
     uint32_t millis = 0;
     double xlast = 0., ylast = 0.;
     while(ctr < 5){
-        if(Mount.currentT() >= t) return;
+        if(Mount.timeFromStart() >= t) return;
         usleep(1000);
         if(MCC_E_OK != Mount.getMountData(&mdata)){ WARNX("Can't get data"); continue;}
         if(mdata.millis == millis) continue;
@@ -158,24 +158,24 @@ int main(int argc, char **argv){
     }else{
         tagX = 0.; tagY = DEG2RAD(G.amplitude);
     }
-    double t = Mount.currentT(), t0 = t;
+    double t = Mount.timeFromStart(), t0 = t;
     coordpair_t tag = {.X = tagX, .Y = tagY}, rtag = {.X = -tagX, .Y = -tagY};
     double divide = 2.;
     for(int i = 0; i < G.Nswings; ++i){
         Mount.moveTo(&tag);
-        DBG("CMD: %g", Mount.currentT()-t0);
+        DBG("CMD: %g", Mount.timeFromStart()-t0);
         t += G.period / divide;
         divide = 1.;
         waithalf(t);
         DBG("Moved to +, t=%g", t-t0);
-        DBG("CMD: %g", Mount.currentT()-t0);
+        DBG("CMD: %g", Mount.timeFromStart()-t0);
         Mount.moveTo(&rtag);
         t += G.period;
         waithalf(t);
         DBG("Moved to -, t=%g", t-t0);
-        DBG("CMD: %g", Mount.currentT()-t0);
+        DBG("CMD: %g", Mount.timeFromStart()-t0);
     }
-    green("Move to zero @ %g\n", Mount.currentT());
+    green("Move to zero @ %g\n", Mount.timeFromStart());
     tag = (coordpair_t){0};
     // be sure to move @ 0,0
     if(MCC_E_OK != Mount.moveTo(&tag)){
diff --git a/LibSidServo/examples/goto.c b/LibSidServo/examples/goto.c
index a9a68e1..6c5cadc 100644
--- a/LibSidServo/examples/goto.c
+++ b/LibSidServo/examples/goto.c
@@ -91,8 +91,7 @@ int main(int _U_ argc, char _U_ **argv){
     if(MCC_E_OK != Mount.init(Config)) ERRX("Can't init mount");
     coordval_pair_t M, E;
     if(!getPos(&M, &E)) ERRX("Can't get current position");
-    printf("Current time: %.10f\n", Mount.currentT());
-    DBG("xt: %g, x: %g", M.X.t, M.X.val);
+    printf("Current time: %.10f\n", Mount.timeFromStart());
     if(G.coordsoutput){
         if(!G.wait) green("When logging I should wait until moving ends; added '-w'\n");
         G.wait = 1;
diff --git a/LibSidServo/examples/scmd_traectory.c b/LibSidServo/examples/scmd_traectory.c
index 53cbce6..67ad655 100644
--- a/LibSidServo/examples/scmd_traectory.c
+++ b/LibSidServo/examples/scmd_traectory.c
@@ -98,31 +98,34 @@ static void runtraectory(traectory_fn tfn){
     coordval_pair_t telXY;
     coordval_pair_t target;
     coordpair_t traectXY;
-    double t0 = dumpt0(), tlast = 0., tstart = Mount.currentT();
-    double tlastX = 0., tlastY = 0.;
+    double tlast = 0., tstart = Mount.timeFromStart();
+    long tlastXnsec = 0, tlastYnsec = 0;
+    struct timespec tcur, t0 = {0};
+    dumpt0(&t0);
     while(1){
         if(!telpos(&telXY)){
             WARNX("No next telescope position");
             return;
         }
-        if(telXY.X.t == tlastX && telXY.Y.t == tlastY) continue; // last measure - don't mind
-        DBG("\n\nTELPOS: %g'/%g' (%.6f/%.6f) measured @ %.6f/%.6f", RAD2AMIN(telXY.X.val), RAD2AMIN(telXY.Y.val), RAD2DEG(telXY.X.val), RAD2DEG(telXY.Y.val), telXY.X.t, telXY.Y.t);
-        tlastX = telXY.X.t; tlastY = telXY.Y.t;
-        double t = Mount.currentT();
+        if(!Mount.currentT(&tcur)) continue;
+        if(telXY.X.t.tv_nsec == tlastXnsec && telXY.Y.t.tv_nsec == tlastYnsec) continue; // last measure - don't mind
+        DBG("\n\nTELPOS: %g'/%g' (%.6f/%.6f)", RAD2AMIN(telXY.X.val), RAD2AMIN(telXY.Y.val), RAD2DEG(telXY.X.val), RAD2DEG(telXY.Y.val));
+        tlastXnsec = telXY.X.t.tv_nsec; tlastYnsec = telXY.Y.t.tv_nsec;
+        double t = Mount.timeFromStart();
         if(fabs(telXY.X.val) > G.Xmax || fabs(telXY.Y.val) > G.Ymax || t - tstart > G.tmax) break;
         if(!traectory_point(&traectXY, t)) break;
         target.X.val = traectXY.X; target.Y.val = traectXY.Y;
-        target.X.t = target.Y.t = t;
-        if(t0 < 0.) t0 = dumpt0();
+        target.X.t = target.Y.t = tcur;
+        if(t0.tv_nsec == 0 && t0.tv_sec == 0) dumpt0(&t0);
         else{
             //DBG("target: %g'/%g'", RAD2AMIN(traectXY.X), RAD2AMIN(traectXY.Y));
-            DBG("%g: dX=%.4f'', dY=%.4f''", t-t0, RAD2ASEC(traectXY.X-telXY.X.val), RAD2ASEC(traectXY.Y-telXY.Y.val));
+            DBG("%g: dX=%.4f'', dY=%.4f''", t-tstart, RAD2ASEC(traectXY.X-telXY.X.val), RAD2ASEC(traectXY.Y-telXY.Y.val));
             //DBG("Correct to: %g/%g with EP %g/%g", RAD2DEG(target.X.val), RAD2DEG(target.Y.val), RAD2DEG(endpoint.X), RAD2DEG(endpoint.Y));
             if(errlog)
-                fprintf(errlog, "%10.4f  %10.4f  %10.4f\n", telXY.X.t-t0, RAD2ASEC(traectXY.X-telXY.X.val), RAD2ASEC(traectXY.Y-telXY.Y.val));
+                fprintf(errlog, "%10.4f  %10.4f  %10.4f\n", Mount.timeDiff(&telXY.X.t, &t0), RAD2ASEC(traectXY.X-telXY.X.val), RAD2ASEC(traectXY.Y-telXY.Y.val));
         }
         if(MCC_E_OK != Mount.correctTo(&target)) WARNX("Error of correction!");
-        while((t = Mount.currentT()) - tlast < Config->PIDRefreshDt) usleep(500);
+        while((t = Mount.timeFromStart()) - tlast < Config->PIDRefreshDt) usleep(500);
         tlast = t;
     }
     WARNX("No next traectory point or emulation ends");
diff --git a/LibSidServo/examples/traectories.c b/LibSidServo/examples/traectories.c
index 1baac90..e51f15a 100644
--- a/LibSidServo/examples/traectories.c
+++ b/LibSidServo/examples/traectories.c
@@ -41,7 +41,7 @@ int init_traectory(traectory_fn f, coordpair_t *XY0){
     if(!f || !XY0) return FALSE;
     cur_traectory = f;
     XYstart = *XY0;
-    tstart = Mount.currentT();
+    tstart = Mount.timeFromStart();
     mountdata_t mdata;
     int ntries = 0;
     for(; ntries < 10; ++ntries){
diff --git a/LibSidServo/main.c b/LibSidServo/main.c
index ab9d8e2..b56811b 100644
--- a/LibSidServo/main.c
+++ b/LibSidServo/main.c
@@ -32,6 +32,11 @@
 #include "ssii.h"
 #include "PID.h"
 
+// adder for monotonic time by realtime: inited any call of init()
+static struct timespec timeadder = {0}, // adder of CLOCK_REALTIME to CLOCK_MONOTONIC
+    t0 = {0},           // curtime() for initstarttime() call
+    starttime = {0};    // starting time by monotonic (for timefromstart())
+
 conf_t Conf = {0};
 // parameters for model
 static movemodel_t *Xmodel, *Ymodel;
@@ -50,26 +55,57 @@ limits_t
 static mcc_errcodes_t shortcmd(short_command_t *cmd);
 
 /**
- * @brief nanotime - monotonic time from first run
- * @return struct timespec by CLOCK_MONOTONIC but with setpoint by CLOCK_REALTIME on observations start
+ * @brief curtime - monotonic time from first run
+ * @param t - struct timespec by CLOCK_MONOTONIC but with setpoint by CLOCK_REALTIME on observations start
+ * @return TRUE if all OK
  * FIXME: double -> struct timespec; on init: init t0 by CLOCK_REALTIME
  */
-double nanotime(){
-    static double t0 = -1.;
+int curtime(struct timespec *t){
+    struct timespec now;
+    if(clock_gettime(CLOCK_MONOTONIC, &now)) return FALSE;
+    now.tv_sec += timeadder.tv_sec;
+    now.tv_nsec += timeadder.tv_nsec;
+    if(now.tv_nsec > 999999999L){
+        ++now.tv_sec;
+        now.tv_nsec -= 1000000000L;
+    }
+    if(t) *t = now;
+    return TRUE;
+}
+
+// init starttime; @return TRUE if all OK
+static int initstarttime(){
+    struct timespec start;
+    if(clock_gettime(CLOCK_MONOTONIC, &starttime)) return FALSE;
+    if(clock_gettime(CLOCK_REALTIME, &start)) return FALSE;
+    timeadder.tv_sec = start.tv_sec - starttime.tv_sec;
+    timeadder.tv_nsec = start.tv_nsec - starttime.tv_nsec;
+    if(timeadder.tv_nsec < 0){
+        --timeadder.tv_sec;
+        timeadder.tv_nsec += 1000000000L;
+    }
+    curtime(&t0);
+    return TRUE;
+}
+// return difference (in seconds) between time1 and time0
+double timediff(const struct timespec *time1, const struct timespec *time0){
+    if(!time1 || !time0) return -1.;
+    return (time1->tv_sec - time0->tv_sec) + (time1->tv_nsec - time0->tv_nsec) / 1e9;
+}
+// difference between given time and  last initstarttime() call
+double timediff0(const struct timespec *time1){
+    return timediff(time1, &t0);
+}
+// time from last initstarttime() call
+double timefromstart(){
     struct timespec now;
     if(clock_gettime(CLOCK_MONOTONIC, &now)) return -1.;
-    if(t0 < 0.){
-        struct timespec start;
-        if(clock_gettime(CLOCK_REALTIME, &start)) return -1.;
-        t0 = (double)start.tv_sec + (double)start.tv_nsec * 1e-9
-             - (double)now.tv_sec - (double)now.tv_nsec * 1e-9;
-    }
-    DBG("ASK nanotime: %g", (double)now.tv_sec + (double)now.tv_nsec * 1e-9 + t0);
-    return (double)now.tv_sec + (double)now.tv_nsec * 1e-9 + t0;
+    return (now.tv_sec - starttime.tv_sec) + (now.tv_nsec - starttime.tv_nsec) / 1e9;
 }
 
 /**
  * @brief quit - close all opened and return to default state
+ * TODO: close serial devices even in "model" mode
  */
 static void quit(){
     if(Conf.RunModel) return;
@@ -79,18 +115,17 @@ static void quit(){
     DBG("Exit");
 }
 
-void getModData(coordval_pair_t *c, movestate_t *xst, movestate_t *yst){
+void getModData(coordpair_t *c, movestate_t *xst, movestate_t *yst){
     if(!c || !Xmodel || !Ymodel) return;
-    double tnow = nanotime();
+    double tnow = timefromstart();
     moveparam_t Xp, Yp;
     movestate_t Xst = Xmodel->get_state(Xmodel, &Xp);
     //DBG("Xstate = %d", Xst);
     if(Xst == ST_MOVE) Xst = Xmodel->proc_move(Xmodel, &Xp, tnow);
     movestate_t Yst = Ymodel->get_state(Ymodel, &Yp);
     if(Yst == ST_MOVE) Yst = Ymodel->proc_move(Ymodel, &Yp, tnow);
-    c->X.t = c->Y.t = tnow;
-    c->X.val = Xp.coord;
-    c->Y.val =  Yp.coord;
+    c->X = Xp.coord;
+    c->Y = Yp.coord;
     if(xst) *xst = Xst;
     if(yst) *yst = Yst;
 }
@@ -149,6 +184,7 @@ double LS_calc_slope(less_square_t *l, double x, double t){
 static mcc_errcodes_t init(conf_t *c){
     FNAME();
     if(!c) return MCC_E_BADFORMAT;
+    if(!initstarttime()) return MCC_E_FAILED;
     Conf = *c;
     mcc_errcodes_t ret = MCC_E_OK;
     Xmodel = model_init(&Xlimits);
@@ -303,7 +339,7 @@ static mcc_errcodes_t move2s(const coordpair_t *target, const coordpair_t *speed
 static mcc_errcodes_t emstop(){
     FNAME();
     if(Conf.RunModel){
-        double curt = nanotime();
+        double curt = timefromstart();
         Xmodel->emergency_stop(Xmodel, curt);
         Ymodel->emergency_stop(Ymodel, curt);
         return MCC_E_OK;
@@ -315,7 +351,7 @@ static mcc_errcodes_t emstop(){
 static mcc_errcodes_t stop(){
     FNAME();
     if(Conf.RunModel){
-        double curt = nanotime();
+        double curt = timefromstart();
         Xmodel->stop(Xmodel, curt);
         Ymodel->stop(Ymodel,curt);
         return MCC_E_OK;
@@ -332,7 +368,7 @@ static mcc_errcodes_t stop(){
 static mcc_errcodes_t shortcmd(short_command_t *cmd){
     if(!cmd) return MCC_E_BADFORMAT;
     if(Conf.RunModel){
-        double curt = nanotime();
+        double curt = timefromstart();
         moveparam_t param = {0};
         param.coord = cmd->Xmot; param.speed = cmd->Xspeed;
         if(!model_move2(Xmodel, &param, curt)) return MCC_E_FAILED;
@@ -364,7 +400,7 @@ static mcc_errcodes_t shortcmd(short_command_t *cmd){
 static mcc_errcodes_t longcmd(long_command_t *cmd){
     if(!cmd) return MCC_E_BADFORMAT;
     if(Conf.RunModel){
-        double curt = nanotime();
+        double curt = timefromstart();
         moveparam_t param = {0};
         param.coord = cmd->Xmot; param.speed = cmd->Xspeed;
         if(!model_move2(Xmodel, &param, curt)) return MCC_E_FAILED;
@@ -534,7 +570,6 @@ mount_t Mount = {
     .init = init,
     .quit = quit,
     .getMountData = getMD,
-//    .slewTo = slew2,
     .moveTo = move2,
     .moveWspeed = move2s,
     .setSpeed = setspeed,
@@ -544,7 +579,10 @@ mount_t Mount = {
     .longCmd = longcmd,
     .getHWconfig = get_hwconf,
     .saveHWconfig = write_hwconf,
-    .currentT = nanotime,
+    .currentT = curtime,
+    .timeFromStart = timefromstart,
+    .timeDiff = timediff,
+    .timeDiff0 = timediff0,
     .correctTo = correct2,
     .getMaxSpeed = maxspeed,
     .getMinSpeed = minspeed,
diff --git a/LibSidServo/main.h b/LibSidServo/main.h
index 4246b1c..769d305 100644
--- a/LibSidServo/main.h
+++ b/LibSidServo/main.h
@@ -29,8 +29,11 @@
 
 extern conf_t Conf;
 extern limits_t Xlimits, Ylimits;
-double nanotime();
-void getModData(coordval_pair_t *c, movestate_t *xst, movestate_t *yst);
+int curtime(struct timespec *t);
+double timediff(const struct timespec *time1, const struct timespec *time0);
+double timediff0(const struct timespec *time1);
+double timefromstart();
+void getModData(coordpair_t *c, movestate_t *xst, movestate_t *yst);
 typedef struct{
     double *x, *t, *t2, *xt; // arrays of coord/time and multiply
     double xsum, tsum, t2sum, xtsum; // sums of coord/time and their multiply
diff --git a/LibSidServo/movingmodel.c b/LibSidServo/movingmodel.c
index 0472459..4326859 100644
--- a/LibSidServo/movingmodel.c
+++ b/LibSidServo/movingmodel.c
@@ -60,7 +60,7 @@ movemodel_t *model_init(limits_t *l){
 
 int model_move2(movemodel_t *model, moveparam_t *target, double t){
     if(!target || !model) return FALSE;
-    DBG("MOVE to %g at speed %g", target->coord, target->speed);
+    DBG("MOVE to %g (deg) at speed %g (deg/s)", target->coord/M_PI*180., target->speed/M_PI*180.);
     // only positive velocity
     if(target->speed < 0.) target->speed = -target->speed;
     if(fabs(target->speed) < model->Min.speed){
diff --git a/LibSidServo/serial.c b/LibSidServo/serial.c
index e550945..5e040f5 100644
--- a/LibSidServo/serial.c
+++ b/LibSidServo/serial.c
@@ -59,49 +59,35 @@ typedef struct __attribute__((packed)){
 
 // calculate current X/Y speeds
 void getXspeed(){
-    static double t0 = -1.; // time of start - eliminate problem of very large times in squares
-    if(t0 < 0.) t0 = mountdata.encXposition.t;
     static less_square_t *ls = NULL;
     if(!ls){
         ls = LS_init(Conf.EncoderSpeedInterval / Conf.EncoderReqInterval);
         if(!ls) return;
     }
     pthread_mutex_lock(&datamutex);
-    double speed = LS_calc_slope(ls, mountdata.encXposition.val, mountdata.encXposition.t - t0);
+    double dt = timediff0(&mountdata.encXposition.t);
+    double speed = LS_calc_slope(ls, mountdata.encXposition.val, dt);
     if(fabs(speed) < 1.5 * Xlimits.max.speed){
         mountdata.encXspeed.val = speed;
         mountdata.encXspeed.t = mountdata.encXposition.t;
     }
     pthread_mutex_unlock(&datamutex);
     //DBG("Xspeed=%g", mountdata.encXspeed.val);
-#if 0
-    mountdata.encXspeed.val = (mountdata.encXposition.val - lastXenc.val) / (t - lastXenc.t);
-    mountdata.encXspeed.t = (lastXenc.t + mountdata.encXposition.t) / 2.;
-    lastXenc.val = mountdata.encXposition.val;
-    lastXenc.t = t;
-#endif
 }
 void getYspeed(){
-    static double t0 = -1.; // time of start - eliminate problem of very large times in squares
-    if(t0 < 0.) t0 = mountdata.encXposition.t;
     static less_square_t *ls = NULL;
     if(!ls){
         ls = LS_init(Conf.EncoderSpeedInterval / Conf.EncoderReqInterval);
         if(!ls) return;
     }
     pthread_mutex_lock(&datamutex);
-    double speed = LS_calc_slope(ls, mountdata.encYposition.val, mountdata.encYposition.t - t0);
+    double dt = timediff0(&mountdata.encYposition.t);
+    double speed = LS_calc_slope(ls, mountdata.encYposition.val, dt);
     if(fabs(speed) < 1.5 * Ylimits.max.speed){
         mountdata.encYspeed.val = speed;
         mountdata.encYspeed.t = mountdata.encYposition.t;
     }
     pthread_mutex_unlock(&datamutex);
-#if 0
-    mountdata.encYspeed.val = (mountdata.encYposition.val - lastYenc.val) / (t - lastYenc.t);
-    mountdata.encYspeed.t = (lastYenc.t + mountdata.encYposition.t) / 2.;
-    lastYenc.val = mountdata.encYposition.val;
-    lastYenc.t = t;
-#endif
 }
 
 /**
@@ -109,7 +95,8 @@ void getYspeed(){
  * @param databuf - input buffer with 13 bytes of data
  * @param t - time when databuf[0] got
  */
-static void parse_encbuf(uint8_t databuf[ENC_DATALEN], double t){
+static void parse_encbuf(uint8_t databuf[ENC_DATALEN], struct timespec *t){
+    if(!t) return;
     enc_t *edata = (enc_t*) databuf;
 /*
 #ifdef EBUG
@@ -147,8 +134,8 @@ static void parse_encbuf(uint8_t databuf[ENC_DATALEN], double t){
     mountdata.encXposition.val = X_ENC2RAD(edata->encX);
     mountdata.encYposition.val = Y_ENC2RAD(edata->encY);
     DBG("Got positions X/Y= %.6g / %.6g", mountdata.encXposition.val, mountdata.encYposition.val);
-    mountdata.encXposition.t = t;
-    mountdata.encYposition.t = t;
+    mountdata.encXposition.t = *t;
+    mountdata.encYposition.t = *t;
     pthread_mutex_unlock(&datamutex);
     //if(t - lastXenc.t > Conf.EncoderSpeedInterval) getXspeed();
     //if(t - lastYenc.t > Conf.EncoderSpeedInterval) getYspeed();
@@ -163,11 +150,11 @@ static void parse_encbuf(uint8_t databuf[ENC_DATALEN], double t){
  * @param t - measurement time
  * @return amount of data read or 0 if problem
  */
-static int getencval(int fd, double *val, double *t){
+static int getencval(int fd, double *val, struct timespec *t){
     if(fd < 0) return FALSE;
     char buf[128];
     int got = 0, Lmax = 127;
-    double t0 = nanotime();
+    double t0 = timefromstart();
     do{
         fd_set rfds;
         FD_ZERO(&rfds);
@@ -186,7 +173,7 @@ static int getencval(int fd, double *val, double *t){
             buf[got] = 0;
         } else continue;
         if(strchr(buf, '\n')) break;
-    }while(Lmax && nanotime() - t0 < Conf.EncoderReqInterval);
+    }while(Lmax && timefromstart() - t0 < Conf.EncoderReqInterval);
     if(got == 0) return 0; // WTF?
     char *estr = strrchr(buf, '\n');
     if(!estr) return 0;
@@ -201,7 +188,7 @@ static int getencval(int fd, double *val, double *t){
         return 0; // wrong number
     }
     if(val) *val = (double) data;
-    if(t) *t = t0;
+    if(t){ if(!curtime(t)) return 0; }
     return got;
 }
 // try to read 1 byte from encoder; return -1 if nothing to read or -2 if device seems to be disconnected
@@ -265,8 +252,6 @@ static void clrmntbuf(){
     if(mntfd < 0) return;
     uint8_t byte;
     fd_set rfds;
-    //double t0 = nanotime();
-    //int n = 0;
     do{
         FD_ZERO(&rfds);
         FD_SET(mntfd, &rfds);
@@ -280,10 +265,8 @@ static void clrmntbuf(){
         if(FD_ISSET(mntfd, &rfds)){
             ssize_t l = read(mntfd, &byte, 1);
             if(l != 1) break;
-            //++n;
         } else break;
     }while(1);
-    //DBG("Cleared by %g (got %d bytes)", nanotime() - t0, n);
 }
 
 // main encoder thread (for separate encoder): read next data and make parsing
@@ -291,7 +274,7 @@ static void *encoderthread1(void _U_ *u){
     if(Conf.SepEncoder != 1) return NULL;
     uint8_t databuf[ENC_DATALEN];
     int wridx = 0, errctr = 0;
-    double t = 0.;
+    struct timespec tcur;
     while(encfd[0] > -1 && errctr < MAX_ERR_CTR){
         int b = getencbyte();
         if(b == -2) ++errctr;
@@ -302,13 +285,14 @@ static void *encoderthread1(void _U_ *u){
             if((uint8_t)b == ENC_MAGICK){
 //                DBG("Got magic -> start filling packet");
                 databuf[wridx++] = (uint8_t) b;
-                t = nanotime();
             }
             continue;
         }else databuf[wridx++] = (uint8_t) b;
         if(wridx == ENC_DATALEN){
-            parse_encbuf(databuf, t);
-            wridx = 0;
+            if(curtime(&tcur)){
+                parse_encbuf(databuf, &tcur);
+                wridx = 0;
+            }
         }
     }
     if(encfd[0] > -1){
@@ -323,30 +307,28 @@ static void *encoderthread2(void _U_ *u){
     if(Conf.SepEncoder != 2) return NULL;
     DBG("Thread started");
     int errctr = 0;
-    double t0 = nanotime();
+    double t0 = timefromstart();
     const char *req = "\n";
     int need2ask = 0; // need or not to ask encoder for new data
     while(encfd[0] > -1 && encfd[1] > -1 && errctr < MAX_ERR_CTR){
+        struct timespec t;
+        if(!curtime(&t)) continue;
         if(need2ask){
             if(1 != write(encfd[0], req, 1)) { ++errctr; continue; }
             else if(1 != write(encfd[1], req, 1)) { ++errctr; continue; }
         }
-        double v, t;
+        double v;
         if(getencval(encfd[0], &v, &t)){
             pthread_mutex_lock(&datamutex);
             mountdata.encXposition.val = X_ENC2RAD(v);
-            //DBG("encX(%g) = %g", t, mountdata.encXposition.val);
             mountdata.encXposition.t = t;
             pthread_mutex_unlock(&datamutex);
-            //if(t - lastXenc.t > Conf.EncoderSpeedInterval) getXspeed();
             getXspeed();
             if(getencval(encfd[1], &v, &t)){
                 pthread_mutex_lock(&datamutex);
                 mountdata.encYposition.val = Y_ENC2RAD(v);
-                //DBG("encY(%g) = %g", t, mountdata.encYposition.val);
                 mountdata.encYposition.t = t;
                 pthread_mutex_unlock(&datamutex);
-                //if(t - lastYenc.t > Conf.EncoderSpeedInterval) getYspeed();
                 getYspeed();
                 errctr = 0;
                 need2ask = 0;
@@ -360,9 +342,8 @@ static void *encoderthread2(void _U_ *u){
             else need2ask = 1;
             continue;
         }
-        while(nanotime() - t0 < Conf.EncoderReqInterval){ usleep(50); }
-        //DBG("DT=%g (RI=%g)", nanotime()-t0, Conf.EncoderReqInterval);
-        t0 = nanotime();
+        while(timefromstart() - t0 < Conf.EncoderReqInterval){ usleep(50); }
+        t0 = timefromstart();
     }
     DBG("ERRCTR=%d", errctr);
     for(int i = 0; i < 2; ++i){
@@ -391,13 +372,14 @@ void data_free(data_t **x){
 }
 
 static void chkModStopped(double *prev, double cur, int *nstopped, axis_status_t *stat){
+    if(!prev || !nstopped || !stat) return;
     if(isnan(*prev)){
         *stat = AXIS_STOPPED;
         DBG("START");
     }else if(*stat != AXIS_STOPPED){
         if(fabs(*prev - cur) < DBL_EPSILON && ++(*nstopped) > MOTOR_STOPPED_CNT){
             *stat = AXIS_STOPPED;
-            DBG("AXIS stopped");
+            DBG("AXIS stopped; prev=%g, cur=%g; nstopped=%d", *prev/M_PI*180., cur/M_PI*180., *nstopped);
         }
     }else if(*prev != cur){
         DBG("AXIS moving");
@@ -412,42 +394,43 @@ static void *mountthread(void _U_ *u){
     uint8_t buf[2*sizeof(SSstat)];
     SSstat *status = (SSstat*) buf;
     bzero(&mountdata, sizeof(mountdata));
-    double t0 = nanotime(), tstart = t0;
-    static double oldmt = -100.; // old `millis measurement` time
+    double t0 = timefromstart(), tstart = t0, tcur = t0;
+    double oldmt = -100.; // old `millis measurement` time
     static uint32_t oldmillis = 0;
     if(Conf.RunModel){
         double Xprev = NAN, Yprev = NAN; // previous coordinates
         int xcnt = 0, ycnt = 0;
         while(1){
-            coordval_pair_t c;
+            coordpair_t c;
             movestate_t xst, yst;
             // now change data
             getModData(&c, &xst, &yst);
+            struct timespec tnow;
+            if(!curtime(&tnow) || (tcur = timefromstart()) < 0.) continue;
             pthread_mutex_lock(&datamutex);
-            double tnow = c.X.t;
             mountdata.encXposition.t = mountdata.encYposition.t = tnow;
-            mountdata.encXposition.val = c.X.val;
-            mountdata.encYposition.val = c.Y.val;
+            mountdata.encXposition.val = c.X;
+            mountdata.encYposition.val = c.Y;
             //DBG("t=%g, X=%g, Y=%g", tnow, c.X.val, c.Y.val);
-            if(tnow - oldmt > Conf.MountReqInterval){
-                oldmillis = mountdata.millis = (uint32_t)((tnow - tstart) * 1e3);
+            if(tcur - oldmt > Conf.MountReqInterval){
+                oldmillis = mountdata.millis = (uint32_t)((tcur - tstart) * 1e3);
                 mountdata.motYposition.t = mountdata.motXposition.t = tnow;
                 if(xst == ST_MOVE)
-                    mountdata.motXposition.val = c.X.val + (c.X.val - mountdata.motXposition.val)*(drand48() - 0.5)/100.;
+                    mountdata.motXposition.val = c.X + (c.X - mountdata.motXposition.val)*(drand48() - 0.5)/100.;
                 else
-                    mountdata.motXposition.val = c.X.val;
+                    mountdata.motXposition.val = c.X;
                 if(yst == ST_MOVE)
-                    mountdata.motYposition.val = c.Y.val + (c.Y.val - mountdata.motYposition.val)*(drand48() - 0.5)/100.;
+                    mountdata.motYposition.val = c.Y + (c.Y - mountdata.motYposition.val)*(drand48() - 0.5)/100.;
                 else
-                    mountdata.motYposition.val = c.Y.val;
-                oldmt = tnow;
+                    mountdata.motYposition.val = c.Y;
+                oldmt = tcur;
             }else mountdata.millis = oldmillis;
-            chkModStopped(&Xprev, c.X.val, &xcnt, &mountdata.Xstate);
-            chkModStopped(&Yprev, c.Y.val, &ycnt, &mountdata.Ystate);
+            chkModStopped(&Xprev, c.X, &xcnt, &mountdata.Xstate);
+            chkModStopped(&Yprev, c.Y, &ycnt, &mountdata.Ystate);
             pthread_mutex_unlock(&datamutex);
             getXspeed(); getYspeed();
-            while(nanotime() - t0 < Conf.EncoderReqInterval) usleep(50);
-            t0 = nanotime();
+            while(timefromstart() - t0 < Conf.EncoderReqInterval) usleep(50);
+            t0 = timefromstart();
         }
     }
     // data to get
@@ -457,31 +440,8 @@ static void *mountthread(void _U_ *u){
     if(!cmd_getstat) goto failed;
     while(mntfd > -1 && errctr < MAX_ERR_CTR){
         // read data to status
-        double t0 = nanotime();
-#if 0
-// 127 milliseconds to get answer on X/Y commands!!!
-        int64_t ans;
-        int ctr = 0;
-        if(SSgetint(CMD_MOTX, &ans)){
-            pthread_mutex_lock(&datamutex);
-            mountdata.motXposition.t = tgot;
-            mountdata.motXposition.val = X_MOT2RAD(ans);
-            pthread_mutex_unlock(&datamutex);
-            ++ctr;
-        }
-        tgot = nanotime();
-        if(SSgetint(CMD_MOTY, &ans)){
-            pthread_mutex_lock(&datamutex);
-            mountdata.motXposition.t = tgot;
-            mountdata.motXposition.val = X_MOT2RAD(ans);
-            pthread_mutex_unlock(&datamutex);
-            ++ctr;
-        }
-        if(ctr == 2){
-            mountdata.millis = (uint32_t)(1e3 * tgot);
-            DBG("Got both coords; millis=%d", mountdata.millis);
-        }
-#endif
+        struct timespec tcur;
+        if(!curtime(&tcur)) continue;
         // 80 milliseconds to get answer on GETSTAT
         if(!MountWriteRead(cmd_getstat, &d) || d.len != sizeof(SSstat)){
 #ifdef EBUG
@@ -498,14 +458,13 @@ static void *mountthread(void _U_ *u){
         errctr = 0;
         pthread_mutex_lock(&datamutex);
         // now change data
-        SSconvstat(status, &mountdata, t0);
+        SSconvstat(status, &mountdata, &tcur);
         pthread_mutex_unlock(&datamutex);
-        //DBG("GOT FULL stat by %g", nanotime() - t0);
         // allow writing & getters
         do{
             usleep(500);
-        }while(nanotime() - t0 < Conf.MountReqInterval);
-        t0 = nanotime();
+        }while(timefromstart() - t0 < Conf.MountReqInterval);
+        t0 = timefromstart();
     }
     data_free(&cmd_getstat);
 failed:
@@ -611,6 +570,7 @@ create_thread:
 
 // close all opened serial devices and quit threads
 void closeSerial(){
+    // TODO: close devices in "model" mode too!
     if(Conf.RunModel) return;
     if(mntfd > -1){
         DBG("Cancel mount thread");
@@ -660,30 +620,23 @@ static int wr(const data_t *out, data_t *in, int needeol){
         return FALSE;
     }
     clrmntbuf();
-    //double t0 = nanotime();
     if(out){
         if(out->len != (size_t)write(mntfd, out->buf, out->len)){
             DBG("written bytes not equal to need");
             return FALSE;
         }
-        //DBG("Send to mount %zd bytes: %s", out->len, out->buf);
         if(needeol){
             int g = write(mntfd, "\r", 1); // add EOL
             (void) g;
         }
     }
-    //DBG("sent by %g", nanotime() - t0);
-    //uint8_t buf[256];
-    //data_t dumb = {.buf = buf, .maxlen = 256};
     if(!in) return TRUE;
-    //if(!in) in = &dumb; // even if user don't ask for answer, try to read to clear trash
     in->len = 0;
     for(size_t i = 0; i < in->maxlen; ++i){
         int b = getmntbyte();
         if(b < 0) break; // nothing to read -> go out
         in->buf[in->len++] = (uint8_t) b;
     }
-    //DBG("got %zd bytes by %g", in->len, nanotime() - t0);
     while(getmntbyte() > -1);
     return TRUE;
 }
diff --git a/LibSidServo/sidservo.h b/LibSidServo/sidservo.h
index 1e2ca38..d075289 100644
--- a/LibSidServo/sidservo.h
+++ b/LibSidServo/sidservo.h
@@ -239,7 +239,10 @@ typedef struct{
     mcc_errcodes_t  (*longCmd)(long_command_t *cmd); // send/get long command
     mcc_errcodes_t  (*getHWconfig)(hardware_configuration_t *c); // get hardware configuration
     mcc_errcodes_t  (*saveHWconfig)(hardware_configuration_t *c); // save hardware configuration
-    double          (*currentT)(); // current time
+    int             (*currentT)(struct timespec *t); // current time
+    double          (*timeFromStart)(); // amount of seconds from last init
+    double          (*timeDiff)(const struct timespec *time1, const struct timespec *time0); // difference of times
+    double          (*timeDiff0)(const struct timespec *time1); // difference between current time and last init time
     mcc_errcodes_t  (*getMaxSpeed)(coordpair_t *v); // maximal speed by both axis
     mcc_errcodes_t  (*getMinSpeed)(coordpair_t *v); // minimal -//-
     mcc_errcodes_t  (*getAcceleration)(coordpair_t *a); // acceleration/deceleration
diff --git a/LibSidServo/ssii.c b/LibSidServo/ssii.c
index 6f5fd9c..6e5c89e 100644
--- a/LibSidServo/ssii.c
+++ b/LibSidServo/ssii.c
@@ -67,17 +67,17 @@ static void ChkStopped(const SSstat *s, mountdata_t *m){
  * @param m (o) - output
  * @param t - measurement time
  */
-void SSconvstat(const SSstat *s, mountdata_t *m, double t){
-    if(!s || !m) return;
+void SSconvstat(const SSstat *s, mountdata_t *m, struct timespec *t){
+    if(!s || !m || !t) return;
     m->motXposition.val = X_MOT2RAD(s->Xmot);
     m->motYposition.val = Y_MOT2RAD(s->Ymot);
     ChkStopped(s, m);
-    m->motXposition.t = m->motYposition.t = t;
+    m->motXposition.t = m->motYposition.t = *t;
     // fill encoder data from here, as there's no separate enc thread
     if(!Conf.SepEncoder){
         m->encXposition.val = X_ENC2RAD(s->Xenc);
         m->encYposition.val = Y_ENC2RAD(s->Yenc);
-        m->encXposition.t = m->encYposition.t = t;
+        m->encXposition.t = m->encYposition.t = *t;
         getXspeed(); getYspeed();
     }
     m->keypad = s->keypad;
@@ -176,33 +176,37 @@ int SSstop(int emerg){
 mcc_errcodes_t updateMotorPos(){
     mountdata_t md = {0};
     if(Conf.RunModel) return MCC_E_OK;
-    double t0 = nanotime(), t = 0.;
+    double t0 = timefromstart(), t = 0.;
+    struct timespec curt;
     DBG("start @ %g", t0);
     do{
-        t = nanotime();
+        t = timefromstart();
+        if(!curtime(&curt)){
+            usleep(10000);
+            continue;
+        }
         if(MCC_E_OK == getMD(&md)){
-            if(md.encXposition.t == 0 || md.encYposition.t == 0){
+            if(md.encXposition.t.tv_sec == 0 || md.encYposition.t.tv_sec == 0){
                 DBG("Just started, t-t0 = %g!", t - t0);
-                DBG("t-t0 = %g", nanotime() - t0);
-                //usleep(10000);
+                usleep(10000);
                 continue;
             }
             if(md.Xstate != AXIS_STOPPED || md.Ystate != AXIS_STOPPED) return MCC_E_OK;
-            DBG("got; t pos x/y: %g/%g; tnow: %g", md.encXposition.t, md.encYposition.t, t);
+            DBG("got; t pos x/y: %ld/%ld; tnow: %ld", md.encXposition.t.tv_sec, md.encYposition.t.tv_sec, curt.tv_sec);
             mcc_errcodes_t OK = MCC_E_OK;
             if(fabs(md.motXposition.val - md.encXposition.val) > Conf.EncodersDisagreement && md.Xstate == AXIS_STOPPED){
                 DBG("NEED to sync X: motors=%g, axiss=%g", md.motXposition.val, md.encXposition.val);
                 if(!SSsetterI(CMD_MOTXSET, X_RAD2MOT(md.encXposition.val))){
                     DBG("Xpos sync failed!");
                     OK = MCC_E_FAILED;
-                }else DBG("Xpos sync OK, Dt=%g", nanotime() - t0);
+                }else DBG("Xpos sync OK, Dt=%g", t - t0);
             }
             if(fabs(md.motYposition.val - md.encYposition.val) > Conf.EncodersDisagreement && md.Ystate == AXIS_STOPPED){
                 DBG("NEED to sync Y: motors=%g, axiss=%g", md.motYposition.val, md.encYposition.val);
                 if(!SSsetterI(CMD_MOTYSET, Y_RAD2MOT(md.encYposition.val))){
                     DBG("Ypos sync failed!");
                     OK = MCC_E_FAILED;
-                }else DBG("Ypos sync OK, Dt=%g", nanotime() - t0);
+                }else DBG("Ypos sync OK, Dt=%g", t - t0);
             }
             if(MCC_E_OK == OK){
                 DBG("Encoders synced");
diff --git a/LibSidServo/ssii.h b/LibSidServo/ssii.h
index 504bb1b..abd8007 100644
--- a/LibSidServo/ssii.h
+++ b/LibSidServo/ssii.h
@@ -173,7 +173,7 @@
 #define SITECH_LOOP_FREQUENCY   (1953.)
 
 // amount of consequent same coordinates to detect stop
-#define MOTOR_STOPPED_CNT       (4)
+#define MOTOR_STOPPED_CNT       (19)
 
 // TODO: take it from settings?
 // steps per revolution (SSI - x4 - for SSI)
@@ -331,7 +331,7 @@ typedef struct{
 } __attribute__((packed)) SSconfig;
 
 uint16_t SScalcChecksum(uint8_t *buf, int len);
-void SSconvstat(const SSstat *status, mountdata_t *mountdata, double t);
+void SSconvstat(const SSstat *status, mountdata_t *mountdata, struct timespec *t);
 int SStextcmd(const char *cmd, data_t *answer);
 int SSrawcmd(const char *cmd, data_t *answer);
 int SSgetint(const char *cmd, int64_t *ans);