axis1: S+= axis2.S

axis2*axis1: S? (здесь CRC в hex-виде) - это слейв спросил у своего "коллеги", чо там у него за Сэ

@axis2*axis1: S=120 (здесь CRC в hex-виде) - на что он ответил.

@axis1 S+=120 OK - а если бы не ответил, то был бы ERROR

/* as*(t^3)+bs*(t^2) etc */

volatile double spline,as,bs,cs,ds,tmp;

tmp = 0.001; // остальные тоже с вменяемыми значениями

spline = ds + tmp * (cs + tmp * (bs + as*tmp));

//---------------------------------------------------------------------------
#include <windows.h>
#include <winbase.h>
#include <stdio.h>
#include <sys\timeb.h>
#pragma hdrstop

//---------------------------------------------------------------------------
static unsigned long long base_m;
static double base_d=0;
static long long ddm=0;

#pragma argsused
double prec_time(void)
{
LARGE_INTEGER counter_b;
LARGE_INTEGER counter_e;
LARGE_INTEGER freq;
unsigned long long m;
struct timeb ct;
double d;

QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&counter_b);
ftime(&ct);
QueryPerformanceCounter(&counter_e);
m=(((unsigned long long)counter_b.QuadPart>>1)+((unsigned long long)counter_e.QuadPart>>1));
//m - новая поправка
d=ct.time*1000.0+ct.millitm; //Собственно время в миллисекундах
if (base_d)
{
long long dm;
double dd=d-base_d;
base_m+=(dd)*((double)freq.QuadPart/1000.0);
dm=m-base_m;
ddm+=dm;
if (dd>0)
{
printf("%d\n",ddm);
if (ddm<0)
base_m-=freq.QuadPart/300000;
else
base_m+=freq.QuadPart/300000;
ddm=0;
}
base_d=d;
return d+((double)dm/((double)freq.QuadPart/1000.0));
}
else
{
base_m=m;
base_d=d;
return d;
}
}


int main(int argc, char* argv[])
{
int i;
struct timeb ct;
double pt=prec_time();

for(i=0;i<10000;i++)
{
double t1;
double t2;
ftime(&ct);
t1=ct.time*1000.0+ct.millitm;
t2=prec_time();
printf("%f - %f = %f, interval = %f\n",t1,t2,t2-t1,t2-pt);
pt=t2;
Sleep(2);
}
return 0;
}

/*  reduced to 32 bits */
    int32_t     DDA1;            // speed (dS/dt)
    int32_t     DDA2;            // acceleration (d2S/dt)
    int32_t        DDA3;            // accel.derivative (d3S/dt)

typedef struct

{
  int32_t integer;
 uint32_t fractional;
}fixpt64;

    fixpt64     DDA1;            // speed (dS/dt)
    fixpt64     DDA2;            // acceleration (d2S/dt)
    fixpt64     DDA3;            // accel.derivative (d3S/dt)

typedef long long fixpt64;

((WTCubic*)&Cubic.Message)->d[axis].dda1.i = (signed long)(dda1[axis] >> 32);
((WTCubic*)&Cubic.Message)->d[axis].dda1.f = (unsigned long)(dda1[axis] & 0xFFFFFFFFuLL);
((WTCubic*)&Cubic.Message)->d[axis].dda2.i = (signed long)(dda2[axis] >> 32);
((WTCubic*)&Cubic.Message)->d[axis].dda2.f = (unsigned long)(dda2[axis] & 0xFFFFFFFFuLL);
((WTCubic*)&Cubic.Message)->d[axis].dda3.i = (signed long)(dda3[axis] >> 32);
((WTCubic*)&Cubic.Message)->d[axis].dda3.f = (unsigned long)(dda3[axis] & 0xFFFFFFFFuLL);

10.1.7 Arc Motion
Any pair of the linear axes (XY, YZ, XZ) can be controlled to move in a circular arc in the
plane of that pair of axes. While this is occurring, the third linear axis and the rotational
axes can be controlled to move simultaneously at effectively a constant rate. As in coordinated
linear motion, the motions can be co-ordinated so that acceleration and
deceleration do not affect the path.
If the rotational axes do not move, but the third linear axis does move, the trajectory of the
controlled point is a helix