reni_v0.67.c

// Known problems / open tasks

// - no time correlation between two results => create daemon

// - write output to a given filename

// - create string to send from of a one-byte-command

// - reevaluate over border from dx10.log (30MB)

// - reevaluate more than one call

///////////////////////////

//

//      +----------------- unused (left) connector

//      |      +---------- compensator (relative humidity, air temperature, barometric pressure)

//      |      |      +--- used (right) connector

//      |      |      |

//      v      |      v

//    +----\   v   /----+

//    |     \-----/     |

//    |       AUX       |

//    |      TP I/O     |

//    |                 |

//    | O     ML10    O |

//    |       EC10      |

//     \               /

//      \      O      /

//       \    USB    /

//        +---------+

//             A

//             |

//             +---------- USB connector

//

//

// The PC sends commands down to the DX10 interface via pipe 0x01 and reads its answers back via pipe 0x81.

// A 5Khz data-stream will be read from DX10 interface via pipe 0x82.

// After reading anything via 0x81 or 0x82 the PC asks immediately for an acknowledge via pipe 0x00.

// Before measuring dynamically the PC sends a command every 100ms (while measuring every 333ms).

// The answer takes typically 31ms (maximum 79ms).

//

#include <usb.h>

#include <stdio.h>

#include <math.h>

#include <process.h>     // needed for _beginthread()

#include <getopt.h>      // needed for getopt

#include "version.h"

// this device's vendor and product id

#define THIS_VID 0x0837

#define THIS_PID 0x000b

#define BOOTWAITCYCLES 22               // waiting time for green LED in 0,5 secs

#define STANDARD_MEASURE_FREQUENCY 5000 // internal frequency of measurements (5kHz)

#define WAVES_PER_MM 809078.31378724    // 1 / ( 0,0006328(wavelength) / 512(resolution) )

#define DYNAMIC_RANGE 0x400000          // at this value the dynamic data overflows

FILE *g_fp_out;

FILE *g_fp_log;

int g_iPkt_count=1;

int g_iPkt_max=250; // 250 = 0.05 sec * 5kHz (default measuring-Time: -t0.05)

int g_iReeval=0;

int g_iWarning=0;

int g_iCount=5; // 5 = 0.001 sec * 5kHz (default time-step-Interval: -i0.001)

int g_iDbgLevel=0;

usb_dev_handle *g_Dev = NULL; // the device handle

unsigned short g_iPacket=0;  // packet-counter

int g_iSync=-1;     // synchronisation with fifth short

int g_iMode=-1;     // counter within the 5 shorts

int g_iUsb=0;       // result = distance counter of wavelength/512

int g_iLastusb=0;   // last result

int g_iReduce=g_iCount;

#define ABS(x) ((x>0)?(x):(-(x)))

#define NEXT_RING_INDEX(x, y) (((x+1)<y)?(x+1):(x+1-y))

#define MAX_STREAM0x81 12

#define BUFFLEN0x81    0x200

struct {            // data for 12 asynchronous streams

    void* async;

    int nos;        // number of shorts

    unsigned int time0x81;

    unsigned int time0x00;

    int ret0x00;

  int fuel;

    unsigned short buff[BUFFLEN0x81];

} g_sInterrupt0x81[MAX_STREAM0x81];

int g_iInterrupt0x81_index_write;  // active stream for writing

int g_iInterrupt0x81_index_read;   // active stream for reading

int g_bInterrupt;               // switch for interrupt

#define MAX_STREAM0x82 20

#define BUFFLEN0x82    0x1000

struct {            // data for 20 asynchronous streams

    void* async;

    int nos;        // number of shorts

    unsigned short buff[BUFFLEN0x82];

} g_sData0x82[MAX_STREAM0x82];

int g_iData0x82_index; // active stream

#define END_TOKEN   (unsigned short)0xFEDC  // end of token

struct {            // list of tokens

    unsigned short words[8];

    char name[15];

} g_sTokenlist[]={

    {{0x8020,                                           END_TOKEN}, "DOWN_Init8020"}, // 8000 8020

    {{0x8060,                                           END_TOKEN}, "DOWN_Conf8060"}, // 8000 8060

    {{0x8030,                                           END_TOKEN}, "DOWN_MSta8030"}, // 8000 8030

    {{0x8040,                                           END_TOKEN}, "DOWN_MEnd8040"}, // 8000 8040   [8010 01ff 8020 0002]

    {{0x8011,0x01e2,0x0005,0x00e0,0x00c7,0x00ff,        END_TOKEN}, "DOWN_Clear   "}, // 8000 8011

    {{0x8010,0x01e2,0x0005,0x00e0,0x00c7,0x00ff,        END_TOKEN}, "DOWN_Initial "}, // 8000 8010 (8010) 0857 09ba 0173 01ff

    {{0x8010,0x01e2,0x0005,0x00d3,0x00ba,0x00ff,        END_TOKEN}, "DOWN_Zerosta "}, // 8000 8010 (8010) 00e1 0005 00f2 00d8 00ff

    {{0x8010,0x01e2,0x0005,0x00cc,0x00b3,0x00ff,        END_TOKEN}, "DOWN_Zerodyn "}, // 8000 8010 (8010) 00e1 0005 00f2 00d8 00ff

    {{0x8010,0x01e2,0x0005,0x00d0,0x00b7,0x00ff,        END_TOKEN}, "DOWN_Measure "}, // 8000 8010 (8010) 00e1 000e 00d0 0000 0000 0000 0000 0000 0010 0040 0000 0000 000f 00ff

    {{0x8010,0x01e2,0x0005,0x00cf,0x00b6,0x00ff,        END_TOKEN}, "DOWN_Unkn3   "}, // 8000 8010 (8010) 00e1 0005 00f2 00d8 00ff

    {{0x8010,0x01e2,0x0006,0x00d8,0x0000,0x00c0,0x00ff, END_TOKEN}, "DOWN_Unkn5   "}, // 8000 8010 (8010) 00e1 0005 00f2 00d8 00ff

    {{0x8010,0x01e2,0x0005,0x00dc,0x00c3,0x00ff,        END_TOKEN}, "DOWN_Unkn6   "}, // 8000 8010 (8010) 00e1 0005 00f2 00d8 00ff   [8020 0002]

    {{0x8010,0x01e3,0x0005,0x00e0,0x00c8,0x00ff,        END_TOKEN}, "DOWN_un_Init2"}, // 8000 8010

    {{0x8011,0x01e3,0x0005,0x00e0,0x00c8,0x00ff,        END_TOKEN}, "DOWN_un_Sync "}, // 8000 8011

};

// sequence must have the SAME order!!!

enum TOK {DOWN_Init8020

=0,       DOWN_Conf8060

,         DOWN_MSta8030

,         DOWN_MEnd8040

,         DOWN_Clear

,         DOWN_Initial

,         DOWN_Zerosta

,         DOWN_Zerodyn

,         DOWN_Measure

,         DOWN_Unkn3

,         DOWN_Unkn5

,         DOWN_Unkn6

,         DOWN_un_Init2

,         DOWN_un_Sync

,         DOWN_LAST//////////////////////////////

,         FUNCTION_WAIT             // wait 1000 msec

,         FUNCTION_LOAD_PIPE        // reset pipe 0x82, scheduling data transfer

,         FUNCTION_START_MEASURE

,         FUNCTION_STOP_MEASURE

,         END_PROGRAM

};

// Seen original order of commands:

// DOWN_Zerosta,    d3

// DOWN_Zerodyn,    cc

// DOWN_Unkn3,      cf

// DOWN_Conf8060,   %

// DOWN_Unkn5,      d800

// DOWN_Unkn3,      cf

// milli secs since first call

unsigned int msec(void)

{

    unsigned int a, d;

    long long ticks;

    static unsigned int first = 0;

    static unsigned int mhz = 0;

    if (mhz==0) {

        unsigned char temp[10] = {""};

        unsigned long size = sizeof(temp);

        HKEY hKey;

        RegOpenKey(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", &hKey);

        RegQueryValueEx(hKey, "~MHz", NULL, NULL, temp, &size);

        RegCloseKey(hKey);

        mhz=*(int*)temp;

        __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));

        ticks = ((unsigned long long)a) | (((unsigned long long)d) << 32);

        first=ticks/mhz/1000;

        return 0;

    }

    __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));

    ticks = ((unsigned long long)a) | (((unsigned long long)d) << 32);

    return (ticks/mhz/1000)-first;

}

#define DBG9   9    // stdout: print endless data

#define DBG3   3    // stdout:

#define DBG2   2    // stdout:

#define DBG1   1    // stdout: print only with option -d1

#define ALL    0    // stdout: print always

#define WARN  -1    // stderr: warning, continue program

#define EXIT  -2    // stderr: error, stop program immediately

void output(int mode, const char *fmt, ...)

{

    va_list ap;

    char string[4096];

  FILE*fp=stdout;

  if (mode>g_iDbgLevel)  // hide output because of low log-level

    return;

    if (mode<=WARN) {

    fflush(stdout);

    fp=stderr;

  }

    va_start(ap, fmt);

    vsprintf(string, fmt, ap);

    fprintf(fp, string);

    fflush(fp);

    va_end(ap);

    if (mode==WARN)

    g_iWarning++;

    if (mode==EXIT)

        exit(-1);

    return;

}

usb_dev_handle *open_dev(void)

{

    struct usb_bus *bus;

    struct usb_device *dev;

    for(bus = usb_get_busses(); bus; bus = bus->next)

        for(dev = bus->devices; dev; dev = dev->next)

            if(dev->descriptor.idVendor == THIS_VID && dev->descriptor.idProduct == THIS_PID)

                return usb_open(dev);

    return NULL;

}

short read_pipe_0x00(void)

{

    short tmp=0;

    int ret, i, iTime;

    if ((ret=usb_control_msg(

        g_Dev,                                  //    usb_dev_handle

        0x80,                                   // #  int requesttype => 80: read data from device

        0x00,                                   // #  int request

        0x0000,                                 // ## int value

        0x0000,                                 // ## int index

        (char*)&tmp,                            //    char *bytes

        0x0002,                                 // ## int size

        1000)) < 0)                             //    int timeout

        output(EXIT, "ERROR usb_control_msg\n");

    if(tmp != 0x0000)

        output(WARN, "pipe00 returns value\n");

    return tmp;

}

void get_reeval_line(unsigned short *adr, int *nos)

{

    int k, l, m;

    char sLine[9999];

    do {

        if(!fgets(sLine, 9999, g_fp_log))   // read data line

            output(EXIT, "ERROR no more data to simulate\n");

    } while ( (sLine[0]<'0') || (sLine[0]>'9') );   // skip comments...

    l=strlen(sLine);

    for (m=0, k=2; m<l; m++)            // read time, dir+pipe

        if (sLine[m]==' ')

            if (!--k)

                break;

    if (adr)

        for (k=0, m++; m<l; m+=5, k++)      // read all shorts

            sscanf(&sLine[m], "%04x", adr+k);

    if (nos)

        *nos=k;

//    sscanf(&sLine[0], "%d", iTime);

}

int write_command(unsigned short *words, int toklen)

{

    int i, iTime;

    int ret=0;

  static int iCount=0;

    if (g_iReeval)

        get_reeval_line(NULL, NULL);    // read line and skip

    else {

        int pos;

        char sString[32];

        fgetpos (g_fp_log, (fpos_t*)&pos);

        if (pos>30*1000*1000) {

            fclose(g_fp_log);

            sprintf(sString, "dx10_%06d.log", iCount++);

            remove(sString);

            rename("dx10.log", sString);

            g_fp_log=fopen("dx10.log", "w");

        }

        iTime=msec();

        fprintf(g_fp_log, "%d d01", iTime);

        for(i=0; i<toklen; i++)

            fprintf(g_fp_log, " %04x", words[i]);

        fprintf(g_fp_log, "\n");

        ret=usb_bulk_write(g_Dev, 0x01, (char*)words, toklen*2, 1000);

    }

    return ret;

}

void read_one_answer(void)      // read from the actual read index

{

    int i, iTime;

    if (g_iReeval) {

        get_reeval_line(&g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0], &g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos);  // data line

        get_reeval_line(NULL, NULL);    // skip pipe 0x00

    } else {

        while (g_iInterrupt0x81_index_write == g_iInterrupt0x81_index_read);   // wait, till a new interrupt has been written

// write BACK data from interruption log

    fprintf(g_fp_log, "//%d\n", g_sInterrupt0x81[g_iInterrupt0x81_index_read].fuel);

        iTime = g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81;

        fprintf(g_fp_log, "%d b81", iTime);

        for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

            fprintf(g_fp_log, " %04x", g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i]);

        fprintf(g_fp_log, "\n");

        iTime = g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x00;

        fprintf(g_fp_log, "%d b00 %04x\n", iTime, g_sInterrupt0x81[g_iInterrupt0x81_index_read].ret0x00);

    }

}

void read_data(void)      // read from the actual data index

{

    int i, j, iTime;

    if (g_iReeval) {

        get_reeval_line(&g_sData0x82[g_iData0x82_index].buff[0], &g_sData0x82[g_iData0x82_index].nos);  // data line

        get_reeval_line(NULL, NULL);    // skip pipe 0x00

    } else {

        if ((g_sData0x82[g_iData0x82_index].nos=usb_reap_async(g_sData0x82[g_iData0x82_index].async, 5000)/2) < 0)

            output(EXIT, "error reap02 %d\n", g_iData0x82_index);

// write BACK data

        iTime = msec();

        fprintf(g_fp_log, "%d b82", iTime);

        for(j=0; j<g_sData0x82[g_iData0x82_index].nos; j++)

            fprintf(g_fp_log, " %04x", g_sData0x82[g_iData0x82_index].buff[j]);

        fprintf(g_fp_log, "\n");

        fprintf(g_fp_log, "%d b00 %04x\n", msec(), read_pipe_0x00());

        // submit this transfer and returns immediately

        if (usb_submit_async(g_sData0x82[g_iData0x82_index].async, (char*)&g_sData0x82[g_iData0x82_index].buff[0], BUFFLEN0x82) < 0)

            output(EXIT, "error usb_submit_async:\n%s\n", usb_strerror());

    }

}

void interrupt_routine(void *dummy)

{

    int i, ret, fuel;

    // do once for setup

    for(i=0; i<MAX_STREAM0x81; i++)

        if (usb_bulk_setup_async(g_Dev, &g_sInterrupt0x81[i].async, 0x81) < 0)

            output(EXIT, "ERROR: no setup before interrupt:\n%s\n", usb_strerror());

    // submit this transfer and returns immediately

    for(i=0; i<MAX_STREAM0x81; i++) {

        if (usb_submit_async(g_sInterrupt0x81[i].async, (char*)&g_sInterrupt0x81[i].buff[0], BUFFLEN0x81) < 0)

            output(EXIT, "ERROR: no submit before interrupt:\n%s\n", usb_strerror());

    }

    // endless loop for interrupt

    while (g_bInterrupt) {

        // wait for the transfer to complete (no logging within interrupt)

        ret=usb_reap_async(g_sInterrupt0x81[g_iInterrupt0x81_index_write].async, 5000);

        if ((g_sInterrupt0x81[g_iInterrupt0x81_index_write].nos=ret/2) < 0) {

            if (g_bInterrupt) {

        for(i=0; i<MAX_STREAM0x81; i++)

          output(DBG1, "%d %d %d\n", i, g_sInterrupt0x81[i].time0x81, g_sInterrupt0x81[i].fuel);

                output(EXIT, "ERROR: no response in interrupt %d within time: %d\n"

                     "Perhaps no cable between DX10 and laser\n"

               "  or\n"

               "Replug USB cable\n", g_iInterrupt0x81_index_write, ret);

            } else

                break;

        }

        // store timervalue (log it later)

        g_sInterrupt0x81[g_iInterrupt0x81_index_write].time0x81=msec();

        g_sInterrupt0x81[g_iInterrupt0x81_index_write].ret0x00=read_pipe_0x00();

        g_sInterrupt0x81[g_iInterrupt0x81_index_write].time0x00=msec();

        // submit this transfer and returns immediately

        if (usb_submit_async(g_sInterrupt0x81[g_iInterrupt0x81_index_write].async,

                             (char*)&g_sInterrupt0x81[g_iInterrupt0x81_index_write].buff[0], BUFFLEN0x81) < 0) {

      for(i=0; i<MAX_STREAM0x81; i++)

        output(DBG1, "%d %d %d\n", i, g_sInterrupt0x81[i].time0x81, g_sInterrupt0x81[i].fuel);

            output(EXIT, "ERROR: no submit in interrupt:\n%s\n", usb_strerror());

    }

    fuel=g_iInterrupt0x81_index_write-g_iInterrupt0x81_index_read;

    if (fuel<0)

      fuel+=MAX_STREAM0x81;

    g_sInterrupt0x81[g_iInterrupt0x81_index_write].fuel=fuel;

        g_iInterrupt0x81_index_write = NEXT_RING_INDEX(g_iInterrupt0x81_index_write, MAX_STREAM0x81);

        if (fuel > MAX_STREAM0x81-5) {  // buffer overflow

      for(i=0; i<MAX_STREAM0x81; i++)

        output(DBG1, "%d %d %d\n", i, g_sInterrupt0x81[i].time0x81, g_sInterrupt0x81[i].fuel);

      output(EXIT, "ERROR: missing interrupt\nPerhaps type first <dx10 -b>\n");

        }

    Sleep(1);

    }

}

void evaluate_dynamic(int *offset)

{

    int j;

    if (g_sData0x82[g_iData0x82_index].buff[0] == g_iPacket) {

        if (g_iSync == -1) {

            for(j=1; j<15; j++)

                if (g_sData0x82[g_iData0x82_index].buff[j] >= 0x80)

                    break;

            if (g_iSync>13)

                output(EXIT, "ERROR: no sync\n");

            g_iSync=j+1;

            g_iMode=0;

        }

//

// Structure of datastream from 0x82:

// - First short of every packet is the packet-counter.

// - Then always 5 shorts for 1 distance (every 0,0002 sec = 5000 Hz).

// - Only the fifth short has bit 7 set.

//

// mode| bit. ..98  7654 3210

// ----+---------------------

//   0 | 0000 0000  0?cc cccc      0: always 0

//   1 | 0000 0000  0ccc cccc      1: always 1

//   2 | 0000 0000  0ccc cccc      c: counter (total 22 bit) for laser

//   3 | 0000 0000  0p0i iiii      i: intensity: 00-1F (00=0%, 1A=100%)

//   4 | 0000 0000  1000 qcc?      ?: unknown meaning (bit flickers)

//                                 q: non continuous beam

//                   p: no interference

//

// +----+----+ +----+----+ +----+----+ 

// |00cc|cccc| |cccc|cccc| |cccc|cccc| counter (total 22 bit) for laser

// |  26|5432| |1016|5432| |1054|3210| bit no

// |  42|2222| |2241|1111| |1100|0000| mode-byte

// +----+----+ +----+----+ +----+----+ 

//

        for(j=g_iSync; j<g_sData0x82[g_iData0x82_index].nos; j++) {

            switch(g_iMode++) {

                case 0:

                    g_iUsb+=(g_sData0x82[g_iData0x82_index].buff[j]&0x3F) << 0; // bit 0-5

                    if   (g_sData0x82[g_iData0x82_index].buff[j]&~0x7F)

                        output(WARN, "mode 0: not zero: %04X\n", g_sData0x82[g_iData0x82_index].buff[j]&~0x7F);

                    break;

                case 1:

                    g_iUsb+=(g_sData0x82[g_iData0x82_index].buff[j]&0x7F) << 6;  // bit 6-12

                    if   (g_sData0x82[g_iData0x82_index].buff[j]&~0x7F)

                        output(WARN, "mode 1: not zero: %04X\n", g_sData0x82[g_iData0x82_index].buff[j]&~0x7F);

                    break;

                case 2:

                    g_iUsb+=(g_sData0x82[g_iData0x82_index].buff[j]&0x7F) << 14;   // bit 14-20

                    if   (g_sData0x82[g_iData0x82_index].buff[j]&~0x7F)

                        output(WARN, "mode 2: not zero: %04X\n", g_sData0x82[g_iData0x82_index].buff[j]&~0x7F);

                    break;

                case 3:

                    if   (g_sData0x82[g_iData0x82_index].buff[j]&~0x5F)

                        output(WARN, "mode 3: not zero: %04X\n", g_sData0x82[g_iData0x82_index].buff[j]&~0x5F);

                    if ((g_sData0x82[g_iData0x82_index].buff[j]&0x1F) < 4) // low < 15%

                        output(EXIT, "ERROR: intensity too low\n");

                    break;

                case 4:

                    g_iUsb+=(g_sData0x82[g_iData0x82_index].buff[j]&0x02) << 13-1; // bit 13

                    g_iUsb+=(g_sData0x82[g_iData0x82_index].buff[j]&0x04) << 21-2; // bit 21

                    if  ((g_sData0x82[g_iData0x82_index].buff[j]&~0x0F) != 0x80)

                        output(WARN, "mode 4: not 0x0080: %04X\n", g_sData0x82[g_iData0x82_index].buff[j]&~0x0F);

           if (!((j==g_iSync+4)&&(g_iPacket==0))) {    // for the very first value not output (only store lastusb)

            if ((j==g_iSync+9)&&(g_iPacket==0)) {    // for the second value check direction and offset

              // For the very first time, offset is the 32bit static value.

              // After this calculation, offset is the 32bit value without the last 22bit (which comes from measurement)

              // Take the first two dynamic values (time-distance 1*0,0002) and calculate the value 500 time-steps before.

              // The difference of offset and this calculated value is the start value of offset.

              int off=0;

              if (g_iUsb-g_iLastusb >  DYNAMIC_RANGE/2) off=-DYNAMIC_RANGE;

              if (g_iUsb-g_iLastusb < -DYNAMIC_RANGE/2) off= DYNAMIC_RANGE;

              output(DBG3, "last static value / %5.3f:   %14.6f\n", DYNAMIC_RANGE/WAVES_PER_MM, 1.0*(*offset)/DYNAMIC_RANGE);

              output(DBG3, "calc dyn value :             %14.6f\n", 1.0*((g_iLastusb-off)-(g_iUsb-(g_iLastusb-off))*500)/DYNAMIC_RANGE);

              output(DBG3, "first offset in double:      %14.6f\n", 1.0*((*offset)-((g_iLastusb-off)-(g_iUsb-(g_iLastusb-off))*500))/DYNAMIC_RANGE);

              off=(int)floor(                         1.0*((*offset)-((g_iLastusb-off)-(g_iUsb-(g_iLastusb-off))*500)+DYNAMIC_RANGE/2)/DYNAMIC_RANGE);

              output(DBG3, "first offset:                      %d\n", off);

              *offset=off * DYNAMIC_RANGE;

            }

            if (g_iUsb-g_iLastusb >  DYNAMIC_RANGE/2) *offset-=DYNAMIC_RANGE;

            if (g_iUsb-g_iLastusb < -DYNAMIC_RANGE/2) *offset+=DYNAMIC_RANGE;

            int value=g_iUsb+*offset;

            if  (g_sData0x82[g_iData0x82_index].buff[j]&0x08)  // non continuous beam

              value=(int)(999.9999999*WAVES_PER_MM);

            if (!(--g_iReduce)) {  // measuring always with 5kHz, output with given time-step

              g_iReduce=g_iCount;

              if (g_fp_out)

                fprintf(g_fp_out, "%.4f\t%f\n", (double)g_iPkt_count*g_iCount/STANDARD_MEASURE_FREQUENCY, value/WAVES_PER_MM);

              else

                output(ALL,           "%f\n", value/WAVES_PER_MM);

              g_iPkt_count++;

            }

          }

                    g_iLastusb=g_iUsb;

                    g_iMode=0;

                    g_iUsb=0;

                    break;

                default:

                    output(EXIT, "ERROR: impossible mode\n");

            }

            if (g_iPkt_count >= g_iPkt_max)

        break;

        }

        g_iSync=1;

        g_iPacket++;

    } else

        output(WARN, "ERROR wrong packet number in distance calculation\n");

    output(DBG1, "distadyn: (%f, %d) %f\n", g_iLastusb/WAVES_PER_MM, *offset/DYNAMIC_RANGE, (g_iLastusb+*offset)/WAVES_PER_MM);

    fflush(stdout);

}

int evaluate_static(int iAns, unsigned short *iAnswer, int mode)

{

    int ret;

    if (iAns>13) // length

// iAnswer[ 0] 8000

// iAnswer[ 1] 8010

// skip this:  8010

    if (iAnswer[2]==0xe1) // type1 with: len .... sum FF

    if (iAnswer[3]==0x0e) // length from [00e1 to 00ff]

    if (iAnswer[4]==0xd0) { // type2: measure

// iAnswer[ 5] 0000 0000  s000 000?  s: sign of counter,  ?: after 82

// iAnswer[ 6] 0000 0000  cccc cccc  c(00-FF): counter

// iAnswer[ 7] 0000 0000  cccc cccc  c(00-FF): counter

// iAnswer[ 8] 0000 0000  cccc cccc  c(00-FF): counter

// iAnswer[ 9] 0000 0000  cccc cccc  c(00-FF): counter

// iAnswer[10] 0000 0000  qp01 0000  q: non continuous beam,  p: no interference

// iAnswer[11] 0000 0000  0r00 000b  r: red,  b: booting=>no counter, no intensity

// iAnswer[12] 0000 0000  000? 0000  ?:at p=0 for 4 ticks

// iAnswer[13] 0000 0000  000i iiii  i(00-1F): intensity

// iAnswer[14] 0000 0000  xxxx xxxx  sum of iAnswer[2]-iAnswer[13]

// iAnswer[15] 0000 0000  1111 1111  00ff

        if ((mode==0)||(mode==1)) {

            int ret = (iAnswer[6]<<24)|(iAnswer[7]<<16)|(iAnswer[8]<<8)|iAnswer[9];

            if (iAnswer[5]&0x0080)

                ret=-ret;

            if (iAnswer[10]&0x0080) // non continuous beam

                ret=(int)(999.9999999*WAVES_PER_MM);

            if (mode) {

                if (g_fp_out)

                    fprintf(g_fp_out, "%f\t%f\n", 0.0, ret/WAVES_PER_MM);

                else

                    output(ALL, "distance: %11.6f\n", ret/WAVES_PER_MM);

            }

            return ret;

        } else {

            ret = ((iAnswer[5]&~0x80)<<24)|(((iAnswer[10]^0x10)&0x80)<<16)|(iAnswer[11]<<8)|iAnswer[12];

            return (iAnswer[13]&0x1F);

        }

    }

    return 0;

}

int command(int iCommand, unsigned short *iAnswer)

{

    int i, stop, toklen;

    int iAns=0;

    unsigned short answer[32];

    if (!iAnswer)

        iAnswer=answer;

    // write command to usb

    for(toklen=0; g_sTokenlist[iCommand].words[toklen] != END_TOKEN; toklen++);    // toklen: length of tokens

    output(DBG2, "%s ", g_sTokenlist[iCommand].name);

    if(write_command(&g_sTokenlist[iCommand].words[0], toklen)< 0)

        output(EXIT, "ERROR write\n");

    // read complete answer from usb

    for(iAns=0, stop=0; stop<1; ) {

        // read one answer from usb

        read_one_answer();

//

// Seen return values

// ==================

//

// [800x, 8011]     abort, skip further answer or parts of it

// [8000, 8020]     init

// [8000, 8030]     start dynamical measurement

// [8000, 8060]     config?

// [8000, 8040]     stop dynamical measurement, often with 8010 xxxx and/or 8020 0002

// [8000, 8010]     start of data

// [8010, *]        data with expected further data

// [8010, *, ##ff]  normal end of data

// [8020, 0002]     interrupt?

// [*]              not seen yet

//

        // typical return value: 800x 80xx

        if (iAns==0) {

            if ((g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0] & 0xFFFE) == 0x8000) {  // new correct answer

                for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    iAnswer[iAns++]=g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i];        // fill complete answer

                if (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[1]!=0x8010)

                    stop=1;

            // additional data to skip: e.g 8020 0002 or 8010 ... (after 8000 8040 or after abortion)

            } else if (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0]==0x8020) {

                output(DBG1, "skip 8020 at %d (", g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81);

                for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    output(DBG1, " %04X", g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i]);

                output(DBG1, ")\n");

            } else if (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0]==0x8010) {

                output(DBG1, "skip 8010 at %d (", g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81);

                for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    output(DBG1, " %04X", g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i]);

                output(DBG1, ")\n");

            } else {

                output(WARN, "SKIP UNKNOWN at %d! (", g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81);

                for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    output(WARN, " %04X", g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i]);

                output(WARN,")\n");

            }

            fflush(stdout);

        // all data:     (8000 8010) 8010 .... xxFF

        // typical data: (8000 8010) 8010 00E1 00yy ....   ..   .... 00FF

        //                                1    2    3      ..   yy-1 yy

        } else {

            if (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0]==0x8010) {  // korrekte Daten

                for(i=1; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    iAnswer[iAns++]=g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i];          // fill complete answer

                if ((g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i-1] & 0x00FF) == 0xFF) {   // check last word == 0xFF

                    if (iAnswer[2]==0x00e1) {                                                       // if typical answer with type: 0x00E1

                        if ((iAnswer[3]+2==iAns) && (iAnswer[iAns-1]==0x00FF)) {    // stop only, if 0x00FF appears after the correct length

                            int sum=0;

                            for(i=2; i<iAnswer[3]; i++)                             // calculate check sum

                                sum+=iAnswer[i]&0x00FF;

                            if ((sum&0x00FF) != iAnswer[iAns-2])                    // check sum

                                output(WARN, "WARNING: invalid checksum\n");                     

                            stop=1;

                        }

                    } else

                        stop=1;  // stop for the very first answer of DOWN_Initial

                }

            // abortion with: 8000 8011

            } else if ( (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[0]==0x8000) &&

                        (g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[1]==0x8011) ) {

                output(WARN, "abort with 8000 8011 at %d\n", g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81);

                stop=1;

            } else {

                output(WARN, "SKIP UNKNOWN DATA at %d! (", g_sInterrupt0x81[g_iInterrupt0x81_index_read].time0x81);

                for(i=0; i<g_sInterrupt0x81[g_iInterrupt0x81_index_read].nos; i++)

                    output(WARN, " %04X", g_sInterrupt0x81[g_iInterrupt0x81_index_read].buff[i]);

                output(WARN, ")\n");

                stop=1;

            }

            fflush(stdout);

        }

        g_iInterrupt0x81_index_read = NEXT_RING_INDEX(g_iInterrupt0x81_index_read, MAX_STREAM0x81);

    }

  output(DBG2, "  <<<");

  for(i=0; i<iAns; i++)

        if (i<20)

            output(DBG2, " %04x", iAnswer[i]);

        else

            output(DBG9, " %04x", iAnswer[i]);

  output(DBG2, "\n");

    return iAns;

}

void measure_dynamic(int iFirstvalue)

{

    int i, j, iTime;

    output(DBG2, "START MEASURE\n");

    for(i=0; g_iPkt_count<g_iPkt_max; i++) {    // number of packets

        // wait for the transfer to complete

        read_data();

    output(DBG2, "     data");

    for(j=0; j<g_sData0x82[g_iData0x82_index].nos; j++)

            if (j<20)

                output(DBG2, " %04x", g_sData0x82[g_iData0x82_index].buff[j]);

            else

                output(DBG9, " %04x", g_sData0x82[g_iData0x82_index].buff[j]);

    output(DBG2, "\n");

        evaluate_dynamic(&iFirstvalue);

        g_iData0x82_index = NEXT_RING_INDEX(g_iData0x82_index, MAX_STREAM0x82);

        if((i%4)==0)                            // minimal communication during measurement

            command(DOWN_un_Sync, NULL);

        if ( (GetAsyncKeyState(VK_LCONTROL)) || // break this loop with Ctrl

             (GetAsyncKeyState(VK_RCONTROL)) ) break;

    }

}

int main(int argc, char**argv)

{

    int c=0;

    int i;

    int iToken=-1;

    int bAlign=0;

    int bBoot=0;

    int bZero=0;

    int bPoint=0;

  double dTmp;

    g_fp_out=fopen("_out.txt", "w");

    // test of configuration

    if (sizeof(g_sTokenlist)/sizeof(g_sTokenlist[0]) != DOWN_LAST)

        output(EXIT, "error: wrong configuration!\n");

    while (  (c = getopt(argc, argv, "abcpovsht:k:d:i:r")) != -1  ) {    // check options

        switch (c) {

        case 'o':

            g_fp_out=NULL;

            break;

        case 'a':

            bAlign=1;

            break;

        case 'b':

            bBoot=1;

            break;