sotest.c

 
/* sotest
 
command line test program for socan
*/
 
#include <stdio.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
 
#include <socan.h>
 
#include <socan_util.h>
 
/* ----------------------------------------------
 * constants
 * ---------------------------------------------- */
 
#define VERSION "1.0"
 
/* ----------------------------------------------
 * types
 * ---------------------------------------------- */
 
typedef enum { T_CHECK=2, T_REMOTE=4,
               T_TIMESTAMP=8,
               T_STATS=16,
               T_CONSISTENCE=32,
               T_IGNORE_OLD=64
             } testflags;
 
enum options {
          HELP,
              INTERFACE,
          LEAVE,
          RWTEST,
              WRITE,
              WRITE_LATER,
              WRITE_LATER_W,
              WRITE_INHIBIT,
              WRITE_RTR,
              READ,
              READ_NOW,
              QUEUE_READ,
              TRACE,
              ERRPRINTLEVEL,
              REALTIME,
              BITRATE,
              LOOP,
              LOOPDELAY,
              SLEEP,
              QUIET,
              TIMESTAMP,
              STATS,
              MAXLOSSRATE,
          SIZE,
          COUNT,
          CHECK,
          REMOTE,
          CONSISTENCE,
          IGNORE_OLD,
             };
 
enum commands {
              CMD_NOTHING,
          CMD_RWTEST,
          CMD_BITRATE,
              CMD_WRITE,
              CMD_WRITE_LATER,
              CMD_WRITE_LATER_W,
              CMD_WRITE_INHIBIT,
              CMD_WRITE_RTR,
              CMD_READ,
              CMD_READ_NOW,
              CMD_QUEUE_READ,
             };
 
/* ----------------------------------------------
 * tests
 * ---------------------------------------------- */
 
static void test_bitrate(int port)
  {
    socan_rc rc;
    unsigned int bitrate;
 
    rc= socan_port_bitrate((unsigned char) port, &bitrate);
    if (socan_rc_is_error(rc))
      {
        printf("sotest.c line %d: socan_port_bitrate returned an error: %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
        printf("test-abort!\n");
        return;
      }
    printf("bitrate of port %d is %u\n", port, bitrate);
  }
 
 
static void test_simple_rw(int object1, int port1, int object2, int port2,
                   int w_timeout, int r_timeout,
                   int flag)
  {
    socan_hdl hdl;
    socan_rc rc;
    unsigned char wbuf[8];
    unsigned char rbuf[8];
    unsigned long ts;
    int i;
 
    printf("opening driver :\n");
    hdl= socan_open();
 
    if (hdl==NULL)
      {
        printf("opening of driver failed\n");
        return;
      };
 
    printf("8 bytes will be written, content of these 8 bytes:\n");
    printf("1 2 3 4 5 6 7 8\n");
 
    printf("set write-mode for object %d, port %d ...",object1, port1);
    printf("(timeout %d)\n", w_timeout);
 
    rc= socan_add_obj(hdl, port1, object1, 8, w_timeout, SOCAN_WRITE);
    if (socan_rc_is_error(rc))
      {
        printf("sotest.c line %d: socan_add_obj returned an error: %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
        printf("test-abort!\n");
        socan_close(hdl);
        return;
      }
    else
      printf("done\n");
 
    printf("set read-mode for object %d, port %d ...",object2, port2);
    printf("(timeout %d)\n", r_timeout);
 
    rc= socan_add_obj(hdl, port2, object2, 8, r_timeout, SOCAN_READ);
    if (socan_rc_is_error(rc))
      {
        printf("sotest.c line %d: socan_add_obj returned an error: %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
        printf("test-abort!\n");
        socan_close(hdl);
        return;
      }
    else
      printf("done\n");
 
    for (i=1; i<=8; i++)
      wbuf[i-1]=i;
 
    if (flag & T_TIMESTAMP)
      {
        printf("time now : %lu\n", timestamp_us());
      }
 
    printf("now writing the data...");
    rc= socan_write(hdl, port1, object1, wbuf);
    if (rc!=SOCAN_OK)
      {
        printf("sotest.c line %d: socan_write returned %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
      }
    printf("done\n");
    if (flag & T_TIMESTAMP)
      {
        rc= socan_obj_ts(port1, object1, &ts);
        if (rc!=SOCAN_OK)
          {
            printf("sotest.c line %d: socan_obj_ts returned %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
          }
        printf("timestamp: %lu\n", ts);
      }
 
    printf("now reading the data...");
    rc= socan_read(hdl, port2, object2, rbuf);
    if (rc!=SOCAN_OK)
      {
        printf("sotest.c line %d: socan_read returned %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
      }
    printf("done\n");
    if (flag & T_TIMESTAMP)
      {
        rc= socan_obj_ts(port2, object2, &ts);
        if (rc!=SOCAN_OK)
          {
            printf("sotest.c line %d: socan_obj_ts returned %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
          }
        printf("timestamp: %lu\n", ts);
      }
 
    printf("message-content:\n");
    nice_dump(rbuf,  8, 0);
 
    printf("closing driver...\n");
    if (!socan_close(hdl))
      {
        printf("closing failed !\n");
        return;
      };
  }
 
/* the usage of the counter is adjusted to a little-endian machine ! */
static void test_write(int object, int port, unsigned int timeout,
                       unsigned long inhibit_tm,
                   int loops,
                       double loopdelay,
                       double sleep,
                       double leave,
               int quietlevel,
               int write_cmd,
               int countsize, int countstart,
               int flag)
  {
    socan_hdl hdl;
    unsigned long counter;
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
    socan_obj_type objtype;
    long loopdelay_long= (loopdelay==0) ? 0 : (long)(loopdelay*1000+0.5);
 
    int i;
    int l;
    char ch;
    int  scale;
    bool timed= (write_cmd==CMD_WRITE_INHIBIT);
    bool busy_wait= (write_cmd==CMD_WRITE_LATER_W);
    bool write_rtr_frame= (write_cmd==CMD_WRITE_RTR);
    unsigned long timeval;
    socan_rc rc;
    const char *func_name;
    int waitcount=0;
    int errcount=0;
    int loops_got= loops;
    unsigned long start_time_ms, end_time_ms;
 
    switch (write_cmd)
      {
        case CMD_WRITE_INHIBIT:
          func_name= "socan_write_inhibit";
          break;
        case CMD_WRITE_LATER:
        case CMD_WRITE_LATER_W:
        case CMD_WRITE_RTR:
          func_name= "socan_writelater";
          break;
        case CMD_WRITE:
          func_name= "socan_write";
          break;
        default:
          printf("internal error line %d\n", __LINE__);
          return;
      }
 
    counter=countstart;
 
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
    printf("opening driver :\n");
    hdl= socan_open();
    if (hdl==NULL)
      {
        printf("opening of driver failed\n");
        return;
      };
 
    printf("defining write-object...\n");
    if (write_rtr_frame)
      objtype= SOCAN_READ_RTR;
    else
      {
        if (flag & T_REMOTE)
          objtype= SOCAN_WRITE_RTR;
        else
          objtype= SOCAN_WRITE;
      }
    rc= socan_add_obj(hdl, port, object, countsize, timeout, objtype);
    if (socan_rc_is_error(rc))
      {
        printf("sotest.c line %d: socan_add_obj returned an error: %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
        printf("test-abort!\n");
        socan_close(hdl);
        return;
      }
    else
      printf("done\n");
    if (timed)
      {
        rc= socan_set_inhibit(port, object, inhibit_tm);
        if (socan_rc_is_error(rc))
          {
            printf("sotest.c line %d: socan_set_inhibit returned "
                   "an error: %d (%s)\n", __LINE__, rc, socan_str_rc(rc));
            printf("test-abort!\n");
            socan_close(hdl);
            return;
          }
      }
 
    /* supported write functions here:
     * CMD_WRITE_ : socan_write
     * CMD_WRITE_LATER: socan_writelater
     * CMD_WRITE_INHIBIT: socan_write_inhibit
     * CMD_WRITE_RTR: socan_writelater
     */
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    start_time_ms= timestamp_ms();
    for(; loops>0; loops--)
      {
        if (loopdelay_long)
          mldelay(loopdelay_long);
        if (flag & T_CONSISTENCE)
          {
            unsigned char b= (unsigned char) counter;
            for(i=0; i<countsize; cbuf[i++]= b);
              /* int converted to byte   ^^^^ !*/
          }
        else
          {
            /* native endianess: */
            memcpy(cbuf, &counter, countsize);
          };
        if (quietlevel>=0)
          { if (quietlevel > 0)
              if ((--l)<=0)
                { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          { if (flag & T_CONSISTENCE)
              printf("consistency test with byte %lu\n", counter & 0xFF);
            else
              { printf("writing %lu, %d bytes on %d\n",
                       counter, countsize, object);
              };
          };
      w_again:
        switch (write_cmd)
          {
            case CMD_WRITE_INHIBIT:
              timeval= inhibit_tm;  /* reset the inhibit-time parameter*/
              rc= socan_write_inhibit(hdl, port, object, cbuf, &timeval);
              break;
            case CMD_WRITE_LATER:
            case CMD_WRITE_LATER_W:
            case CMD_WRITE_RTR:
              rc= socan_writelater(hdl, port, object, cbuf);
              break;
            case CMD_WRITE:
              rc= socan_write(hdl, port, object, cbuf);
              break;
          }
        if (rc!= SOCAN_OK)
          {
            if (busy_wait)
              if (rc == SOCAN_WAIT) /* we have to busy-wait... */
                {
                  waitcount++;
                  goto w_again;
                }
 
            if (timed)
              if (rc == SOCAN_WAIT) /* we have to wait... */
                {
                  waitcount++;
                  micdelay(timeval);
                  goto w_again;
                };
            if (socan_rc_is_error(rc))
              {
                errcount++;
                printf("sotest.c line %d: %s returned an error: %d (%s)\n",
                       __LINE__, func_name, rc, socan_str_rc(rc));
              }
            else
              printf("%s return code: %d (%s)\n", func_name,
                      rc, socan_str_rc(rc));
          };
        counter++;
      };
    end_time_ms= timestamp_ms();
    if (quietlevel>0)
      printf("\n");
 
    if (flag & T_STATS)
      {
        double dt= (end_time_ms-start_time_ms)/1000.0;
        double wait_rate= ((double)waitcount) / loops_got;
        printf("dt: %f  loops_got: %d\n",dt, loops_got); /*@@@*/
        printf("statistic:\n");
        printf("sent: %d\n", loops_got);
        printf("run-time: %.2f s\n", dt);
        printf("objects / s : %.1f\n", loops_got/dt);
        printf("ms / object : %.3f\n", 1000*dt/loops_got);
        printf("wait-rate: %.3f %%\n", wait_rate*100);
        printf("errors: %d\n", errcount);
      }
 
    if (leave!=0)
      {
        printf("sleeping %f seconds...\n", leave);
        mldelay((long)(leave*1000+0.5));
      }
 
    printf("\nclosing driver...\n");
    if (!socan_close(hdl))
      {
        printf("closing failed !\n");
        return;
      };
  }
 
static void test_read(int object, int port, unsigned int timeout,
                  int loops,
                      double loopdelay,
                      double sleep,
                      double leave,
                      double maxlossrate,
                  int quietlevel, bool readnow,
                  int countsize, int flag)
  {
    socan_hdl hdl;
    socan_obj_type objtype;
    long loopdelay_long= (loopdelay==0) ? 0 : (long)(loopdelay*1000+0.5);
    int  rc;
    int  mask;
    int  scale, i, l;
    unsigned long c,count= 0;
    char ch;
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
    int lostcount=0;
    int errcount=0;
    int loops_got= loops;
    double loss_rate;
    unsigned long start_time_ms, end_time_ms;
    bool started= false;
 
    if (countsize>=sizeof(int))
      mask= 0xFFFFFFFF;
    else
      mask= 0xFFFFFFFF >> ((sizeof(int)-countsize)*8);
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
    printf("opening driver :\n");
    hdl= socan_open();
    if (hdl==NULL)
      {
        printf("opening of driver failed\n");
        return;
      };
 
    printf("defining read-object...\n");
    if (flag & T_REMOTE)
      objtype= SOCAN_READ_RTR;
    else
      objtype= SOCAN_READ;
    rc= socan_add_obj(hdl, port, object, countsize, timeout, objtype);
    if (socan_rc_is_error(rc))
      {
        printf("sotest.c line %d: socan_add_obj returned an error: %d (%s)\n",
               __LINE__, rc, socan_str_rc(rc));
        printf("test-abort!\n");
        socan_close(hdl);
        return;
      }
    else
      printf("done\n");
 
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    for(; loops>0; loops--)
      {
        if (loopdelay_long)
          mldelay(loopdelay_long);
        if (readnow)
          rc= socan_readnow(hdl, port, object, cbuf);
        else
          rc= socan_read(hdl, port, object, cbuf);
        if (!started)
          {
            start_time_ms= timestamp_ms();
            started= true;
          }
        if (quietlevel>=0)
          { if (quietlevel>0)
              if ((--l)<=0)
                { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          { printf("received data:\n");
            nice_dump(cbuf, countsize, 0);
          };
        if (rc != SOCAN_OK)
          {
            switch(rc)
              {
                case SOCAN_OLD:
                  if (!(flag & T_IGNORE_OLD))
                    printf("\nread return-code: %d (%s)\n",
                           rc, socan_str_rc(rc));
                  break;
                case SOCAN_LOST:
                  lostcount+=1;
                  if (quietlevel>=0)
                    {
                      if (quietlevel>0)
                        {
                          putchar('L');
                          fflush(stdout);
                        }
                    }
                  else
                    printf("\nread return-code: %d (%s)\n",
                           rc, socan_str_rc(rc));
                  break;
                default:
                  errcount+=1;
                  printf("\nread error-code: %d (%s)\n",
                         rc, socan_str_rc(rc));
                  break;
              }
          };
        if (flag & T_CHECK)
          {
            if (flag & T_CONSISTENCE)
              {
                c= cbuf[0];
                for (i=1; i<countsize; i++)
                  if (c!= cbuf[i])
                    {
                      printf("INCONSISTENT DATA!\n");
                      printf("received data:\n");
                      nice_dump(cbuf, countsize, 0);
                      break;
                    };
              }
            else
              {
                c=0;
                memcpy(&c, cbuf, countsize);
                if (c != count)
                  {
                    if ((c>count) || (countsize>1))
                      {
                        if (quietlevel>=0)
                          printf("[%lx,%lx]",c,count);
                        else
                          printf("%lu messages missed, got:%lu expected:%lu\n",
                                 c-count, c, count);
                      }
                    else
                      printf("messages repeated, got:%lu, expected:%lu\n",
                             c, count);
                    count=c;
                  };
                count++;
                count&= mask;
              };
          };
      } /* for */
    end_time_ms= timestamp_ms();
    if (quietlevel>0)
      printf("\n");
 
    loss_rate= ((double)lostcount) / loops_got;
    if (flag & T_STATS)
      {
        double dt= (end_time_ms-start_time_ms)/1000.0;
        printf("statistic:\n");
        printf("received: %d\n", loops_got);
        printf("run-time: %.1f s\n", dt);
        printf("objects / s : %.1f\n", loops_got/dt);
        printf("ms / object : %.2f\n", 1000*dt/loops_got);
        if (maxlossrate<0)
          {
            printf("lost: %d\n", lostcount);
            printf("loss-rate: %.4f\n", loss_rate);
          }
        else
          {
            if (loss_rate <= maxlossrate)
              printf("loss-rate <= %.4f\n", maxlossrate);
            else
              {
                printf("lost: %d\n", lostcount);
                printf("loss-rate %.4f > %.4f\n",
                       loss_rate, maxlossrate);
              }
          }
        printf("errors: %d\n", errcount);
      }
    else
      if ((loss_rate > maxlossrate) && (maxlossrate>=0))
        printf("loss-rate %.4f > %.4f\n",
               loss_rate, maxlossrate);
 
    if (leave!=0)
      {
        printf("sleeping %f seconds...\n", leave);
        mldelay((long)(leave*1000+0.5));
      }
 
    printf("closing driver...\n");
    if (!socan_close(hdl))
      {
        printf("closing failed !\n");
        return;
      };
  }
 
static void test_queue_read(int port_, unsigned int timeout, int *ids, int id_no,
                            int loops,
                            double loopdelay,
                            double sleep,
                            double leave,
                            double maxlossrate,
                            int quietlevel,
                        int countsize, int flag)
  {
    socan_hdl hdl;
 
    char cbuf[8]= {0, 0, 0, 0, 0, 0, 0, 0}; /* counter is at byte 4 ! */
    int rc, i;
    int mask;
 
    unsigned long c;
    char ch;
    int  scale;
    int l;
    unsigned char port;
    unsigned short cob;
    unsigned long *count= NULL;
    long loopdelay_long= (loopdelay==0) ? 0 : (long)(loopdelay*1000+0.5);
    int *receivecount=NULL;
    int *lostcount=NULL;
    int *errcount=NULL;
    double loss_rate;
    unsigned long start_time_ms, end_time_ms;
    bool started= false;
    int *iptr;
 
    if (id_no <=0)
      {
        printf("wrong id_no: %d\n", id_no);
        return;
      }
    count= calloc(id_no, sizeof(unsigned long));
    receivecount= calloc(id_no, sizeof(unsigned long));
    lostcount= calloc(id_no, sizeof(unsigned long));
    errcount= calloc(id_no, sizeof(unsigned long));
 
    if (countsize>=sizeof(int))
      mask= 0xFFFFFFFF;
    else
      mask= 0xFFFFFFFF >> ((sizeof(int)-countsize)*8);
 
    if (sleep!=0)
      {
        printf("sleeping %f seconds...\n", sleep);
        mldelay((long)(sleep*1000+0.5));
      }
 
    printf("opening driver :\n");
    hdl= socan_open();
    if (hdl==NULL)
      {
        printf("opening of driver failed\n");
        return;
      };
 
    printf("defining read-objects...\n");
 
    for(i=0; i<id_no; i++)
      {
        /* for now, no support for RTR objects here: */
        rc= socan_add_obj(hdl, port_, ids[i], countsize, timeout, SOCAN_READ);
        if (socan_rc_is_error(rc))
          {
            printf("sotest.c line %d: socan_add_obj returned an error: %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
            printf("test-abort!\n");
            socan_close(hdl);
            return;
          }
        rc= socan_use_queue(port_, ids[i]);
        if (socan_rc_is_error(rc))
          {
            printf("sotest.c line %d: socan_use_queue returned "
                   "an error: %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
            printf("test-abort!\n");
            socan_close(hdl);
            return;
          }
        rc= socan_new_user_area(port_, ids[i], sizeof(i), (void*)(&iptr));
        if (socan_rc_is_error(rc))
          {
            printf("sotest.c line %d: socan_new_user_area returned "
                   "an error: %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
            printf("test-abort!\n");
            socan_close(hdl);
            return;
          }
        *iptr= i;
      }
 
    scale=0;
    eval_quietlevel(quietlevel, &scale, &ch, &l);
 
    start_time_ms= timestamp_ms();
    for(; loops>0; loops--)
      {
        if (loopdelay_long)
          mldelay(loopdelay_long);
        rc= socan_queue_read(hdl, &port, &cob, cbuf);
        if (!started)
          {
            start_time_ms= timestamp_ms();
            started= true;
          }
        if (SOCAN_OK!= socan_user_area(port, cob, (void*)(&iptr)))
          {
            printf("sotest.c line %d: socan_user_area returned "
                   "an error: %d (%s)\n",
                   __LINE__, rc, socan_str_rc(rc));
            printf("test-abort!\n");
            socan_close(hdl);
            return;
          }
        /* *iptr is now the object index */
 
        receivecount[*iptr]++;
 
        if (quietlevel>=0)
          {
            if (quietlevel>0)
              if ((--l)<=0)
                if (ch)
                  { l= scale; putchar(ch); fflush(stdout); };
          }
        else
          {
            printf("received on %d: data:\n", cob);
            nice_dump(cbuf, countsize, 0);
          };
        if (rc != SOCAN_OK)
          { 
            switch(rc)
              {
                case SOCAN_LOST:
                  lostcount[*iptr]+=1;
                  if (quietlevel>=0)
                    {
                      if (quietlevel>0)
                        {
                          putchar('L');
                          fflush(stdout);
                        }
                    }
                  else
                    printf("\nread return-code: %d (%s)\n",
                           rc, socan_str_rc(rc));
                  break;
                default:
                  errcount[*iptr]+=1;
                  printf("\nread error-code: %d (%s)\n",
                         rc, socan_str_rc(rc));
                  break;
              }
          };
 
        if (flag & T_CHECK)
          {
            if (flag & T_CONSISTENCE)
              {
                c= cbuf[0];
                for (i=1; i<countsize; i++)
                  if (c!= cbuf[i])
                    {
                      printf("INCONSISTENT DATA!\n");
                      printf("received data:\n");
                      nice_dump(cbuf, countsize, 0);
                      break;
                    };
              }
            else
              {
                c=0;
                memcpy(&c, cbuf, countsize);
                if (c != count[*iptr])
                  {
                    if ((c>count[*iptr]) || (countsize>1))
                      {
                        if (quietlevel>=0)
                          printf("[%d:%lx,%lx]",cob,c,count[*iptr]);
                        else
                          printf("cob %d: %lu messages missed, "
                                 "got:%lu expected:%lu\n",
                                 cob, c-count[*iptr], c, count[*iptr]);
                      }
                    else
                      printf("cob %d: messages repeated, "
                             "got:%lu, expected:%lu\n",
                             cob, c, count[*iptr]);
                    count[*iptr]=c;
                  };
                count[*iptr]++;
                count[*iptr]&= mask;
              };
          };
 
      }; /* for */
    end_time_ms= timestamp_ms();
 
    if (quietlevel>0)
      printf("\n");
 
    double dt= (end_time_ms-start_time_ms)/1000.0;
    for(i=0; i<id_no; i++)
      {
        if (flag & T_STATS)
          {
            loss_rate= ((double)lostcount[i]) / receivecount[i];
            printf("\nstatistic cob %d:\n", ids[i]);
            printf("received: %d\n", receivecount[i]);
            printf("run-time: %.1f s\n", dt);
            printf("objects / s : %.1f\n", receivecount[i]/dt);
            printf("ms / object : %.2f\n", 1000*dt/receivecount[i]);
            if (maxlossrate<0)
              {
                printf("lost: %d\n", lostcount[i]);
                printf("loss-rate: %.4f\n", loss_rate);
              }
            else
              {
                if (loss_rate <= maxlossrate)
                  printf("loss-rate <= %.4f\n", maxlossrate);
                else
                  {
                    printf("lost: %d\n", lostcount[i]);
                    printf("loss-rate %.4f > %.4f\n",
                           loss_rate, maxlossrate);
                  }
              }
            printf("errors: %d\n", errcount[i]);
          }
        else
          if ((loss_rate > maxlossrate) && (maxlossrate>=0))
            printf("loss-rate %.4f > %.4f\n",
                   loss_rate, maxlossrate);
      }
 
    free(count);
    free(errcount);
    free(lostcount);
 
    if (leave!=0)
      {
        printf("sleeping %f seconds...\n", leave);
        mldelay((long)(leave*1000+0.5));
      }
 
    printf("\nclosing driver...\n");
    if (!socan_close(hdl))
      {
        printf("closing failed !\n");
        return;
      };
  }
 
/* ----------------------------------------------
 * main
 * ---------------------------------------------- */
 
void print_help(void)
  {
    printf(" **** sotest %s ****\n", VERSION);
    printf("the socan test program\n"
           "usage:\n"
           "sotest {options}\n"
           "options:\n"
           " **************** Configuration*****************\n"
           " --interface,-i INTERFACE \n"
           "        Use INTERFACE for CAN communication, this option\n"
           "        can be given more than once to use more than one\n"
           "        interface.\n"
           " --realtime READER-PRIORITY WRITER-PRIORITY\n"
           "        Use given realtime priorities for reader and writer\n"
           "        thread.\n"
           " --leave [SECONDS]\n"
           "        for all functions that define CAN-objects, hold the\n"
           "        program just before close() is performed. All CAN\n"
           "        objects remain defined. End the program with CRTL-C in\n"
           "        this case\n"
           " --trace,-t LEVEL\n"
           "        set trace level, LEVEL is an integer 0..2 (default 0)\n"
           " --errprintlevel,-E LEVEL\n"
           "        set errprint level, LEVEL is an integer 0..3 (default 1)\n"
           " *************** command options ***************\n"
           " --loop {no of loops}\n"
           "        run read, write, readnow or readmany in loop-mode\n"
           " --loopdelay {delay}\n"
           "        delay each loop by the given number of seconds.\n"
           "        seconds may be a floating point number.\n"
           " --sleep {seconds}\n"
           "        sleep a number of seconds before starting the test.\n"
           "        seconds may be a floating point number.\n"
           " --quiet,-q {level}\n"
           "        Run read, write, readnow or readmany in quiet-mode\n"
           "        level may be 1 .. 5, meaning that each 10**(level-1)\n"
           "        events print a single character on the screen.\n"
           "        Level 0 means no printing at all.\n"
           " --timestamp\n"
           "        Print a the timestamp for each sent or received\n"
           "        CAN object."
           " --stats\n"
           "        run read, readnow or readmany in statistic mode.\n"
           "        Print number of transmits and errors.\n"
           " --maxlossrate [number]\n"
           "        print a warning when the ratio of lost CAN objects for\n"
           "        read functions is bigger than [number].\n"
           " --check\n"
           "        check sequence in --read, (must be used together with\n"
           "        --write in another sotest-task\n"
           " --size,-s [bytes]\n"
           "        use [bytes] bytes to transfer and receive data\n"
           " --count [number]\n"
           "        use [number] as initial number to write with -w\n"
           " --consistence\n"
           "        send alternating 8 bytes of 0xFF or 0x00 to test data\n"
           "        consistence\n"
           " --remote \n"
           "        do remote-read or remote-write, implemented for\n"
           "        --write and --read\n"
           " --ignore_old \n"
           "        ignore the SOCAN_OLD-flag \n"
           "\n");
    printf(" ***************data transmission commands****************\n"
           " --rwtest [object1] [port1] [object2] [port2] "
                    "[write-timeout] [read-timeout]\n"
           "        make a write-object (object1,port1) and a read-object\n"
           "        (object2,port2) with a timeout set for the 2nd object\n"
           "        then write 8 bytes (values 1 to 8) and read the 2nd\n"
           "        object (read immediately) and return the results\n"
           " --write,-w [object] [port] [timeout]\n"
           "        write data (a running counter)\n"
           " --writelater [object] [port] [timeout]\n"
           "        similar to write, but writelater returns immediately,\n"
           "        without waiting for the actual access of the CAN-bus.\n"
           "        Note: writelater returns only errors that are valid for\n"
           "              the PREVIOUS writelater !!!\n"
           " --writelater-w [object] [port] [timeout]\n"
           "        the same as --writelater but do silently retry to write\n"
           "        when the driver returns a SOCAN_WAIT status.\n"
           " --writeinhibit [object] [port] [timeout] [inhibit-time]\n"
           "        similar to writelater, but the CAN-object gets a timestamp\n"
           "        when it is transmitted. Inhibit-time is the minumum\n"
           "        time that has to pass before a new object is sent. This\n"
           "        concerns only writeinhibit combined with the loop-command.\n"
           "        In this case only about every [inhibit-time]\n"
           "        microseconds new data will be sent (note that the unit\n"
           "        for this parameter is microseconds, not milliseconds\n"
           " --writertr [object] [port] [timeout]\n"
           "        Just write an RTR frame on a CAN object.\n"
           " --read,-r [object] [port] [timeout]\n"
           "        read data from an object (blocking).\n"
           " --readnow [object] [port] [timeout]\n"
           "        read data from an object (immediately).\n"
           " --queue-read [port] [timeout] [object] {[object]}\n"
           "        read more than one object via the signal-function in \n"
           "        conjunction with the new queue-read operation\n"
           "        together with --remote, all objects will be remote-read\n"
           "        objects\n"
           "\n");
    printf(" ******************** miscellaneous tests ****************\n"
           " --bitrate [port]\n"
           "        get bitrate of a port\n");
  }
 
 
#define MAX_INTERFACES 4
 
int main( int argc, char *argv[])
 
  {
    static option options[]=
      {
    { "-h"             , HELP },
    { "--help"         , HELP },
    { "-i"             , INTERFACE },
    { "--interface"    , INTERFACE },
    { "--leave"        , LEAVE},
    { "--realtime"     , REALTIME},
    { "--bitrate"      , BITRATE},
    { "--rwtest"       , RWTEST},
    { "-w"             , WRITE},
    { "--write"        , WRITE},
    {  "--writelater"  , WRITE_LATER},
    {  "--writelater-w", WRITE_LATER_W},
    {  "--writeinhibit", WRITE_INHIBIT},
    {  "--writertr"    , WRITE_RTR},
    { "-r"             , READ},
    { "--read"         , READ},
    { "--readnow"      , READ_NOW},
    { "--queue-read"   , QUEUE_READ},
    { "--loop"         , LOOP},
    { "--loopdelay"    , LOOPDELAY},
    { "--sleep"        , SLEEP},
    { "-q"             , QUIET},
    { "--quiet"        , QUIET},
    { "--timestamp"    , TIMESTAMP},
    { "--stats"        , STATS},
        { "--maxlossrate"  , MAXLOSSRATE},
    { "--check"        , CHECK},
    { "-s"             , SIZE},
    { "--size"         , SIZE},
    { "--count"        , COUNT},
    { "--remote"       , REMOTE},
    { "--consistence"  , CONSISTENCE},
    { "--ignore_old"   , IGNORE_OLD},
    { "-t"             , TRACE},
    { "--trace"        , TRACE},
    { "-E"             , ERRPRINTLEVEL},
    { "--errprintlevel", ERRPRINTLEVEL},
      };
    int opt_no= sizeof(options) / sizeof(option);
    enum commands operation=CMD_NOTHING;
 
    char *interfaces[MAX_INTERFACES];
    int interface_no=0;
    int n[45], i, l, tracelevel= -1, errprintlevel= -1;
    int     flag=0;
    int     loops=1;
    double  sleep= 0;
    double  leave= 0;
    double  maxlossrate= -1;
    double  loopdelay= 0;
    int     quietlevel=-1;
    int     countsize  =sizeof(int);
    int     countstart=0;
    int     last_valid_n;
    int     rc, opt_index;
    int     rt_prios[]= {-1, -1};
    int     opt;
    char    *st;
 
    if (argc<2)
      my_exit("error, option/command missing\n");
 
    opt_index= 1;
    while(opt_index<argc)
      {
        opt= match(argc, argv, &opt_index, options, opt_no);
    switch (opt)
      { 
            case -1:
                 my_exit("unknown option: %s\n", argv[opt_index]);
            case HELP:
         print_help();
                 return 0;
            case INTERFACE:
                 if (match_st(argc, argv, &opt_index, &st))
                   my_exit("interface name missing!\n");
                 if (interface_no >= MAX_INTERFACES)
                   my_exit("too many interfaces given (more than %d)\n",
                           MAX_INTERFACES);
                 interfaces[interface_no++]= st;
             break;
            case REALTIME:
             for(i=0; i<=1; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(rt_prios[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case LEAVE:
                 rc= match_float(argc, argv, &opt_index, &leave);
                 if (rc==-1)
                   my_exit("the leave parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the leave parameter is is not a number!\n");
                 if (leave < 0)
                   my_exit("the leave parameter must be positive\n");
                 break;
            case TRACE:
                 rc= match_int(argc, argv, &opt_index, &tracelevel);
                 if (rc==-1)
                   my_exit("the tracelevel parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the tracelevel parameter is is not a number!\n");
                 if (tracelevel<0)
                   my_exit("trace level must be positive\n"
                           "(input was %d)\n", tracelevel);
                 break;
            case ERRPRINTLEVEL:
                 rc= match_int(argc, argv, &opt_index, &errprintlevel);
                 if (rc==-1)
                   my_exit("the errprintlevel parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the errprintlevel parameter is is not a number!\n");
                 if (errprintlevel<0)
                   my_exit("errprintlevel must be positive\n"
                           "(input was %d)\n", errprintlevel);
                 break;
            case CHECK:
                 flag|= T_CHECK;
                 break;
            case REMOTE:
                 flag|= T_REMOTE;
                 break;
            case CONSISTENCE:
                 /* implies the check-flag, too */
                 flag|= (T_CONSISTENCE | T_CHECK);
                 /* countsize is changed to 8 !!! */
                 countsize= 8;
                 break;
            case IGNORE_OLD:
                 flag|= T_IGNORE_OLD;
                 break;
            case LOOP:
                 rc= match_int(argc, argv, &opt_index, &loops);
                 if (rc==-1)
                   my_exit("the loop parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the loop parameter is is not a number!\n");
                 if (loops<1)
                   my_exit("loop-parameter should be greater than zero!\n"
                           "(input was %ld)\n", loops);
                 break;
            case LOOPDELAY:
                 rc= match_float(argc, argv, &opt_index, &loopdelay);
                 if (rc==-1)
                   my_exit("the loopdelay parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the loopdelay parameter is is not a number!\n");
                 break;
            case SLEEP:
                 rc= match_float(argc, argv, &opt_index, &sleep);
                 if (rc==-1)
                   my_exit("the sleep parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the sleep parameter is is not a number!\n");
                 break;
            case QUIET:
                 rc= match_int(argc, argv, &opt_index, &quietlevel);
                 if (rc==-1)
                   my_exit("the quiet parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the quiet parameter is is not a number!\n");
                 if ((quietlevel<0) || (quietlevel>5))
                   my_exit("only quiet-levels 0 to 5 are allowed\n"
                           "(input was %d)\n", quietlevel);
                 break;
            case TIMESTAMP:
                 flag|= T_TIMESTAMP;
                 break;
            case STATS:
                 flag|= T_STATS;
                 break;
            case MAXLOSSRATE:
                 rc= match_float(argc, argv, &opt_index, &maxlossrate);
                 if (rc==-1)
                   my_exit("the max loss rate parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the max loss rate parameter is is not a number!\n");
                 break;
            case SIZE:
                 rc= match_int(argc, argv, &opt_index, &countsize);
                 if (rc==-1)
                   my_exit("the count parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the count parameter is is not a number!\n");
         if ((countsize<1) || (countsize>8))
           my_exit("[bytes]-parameter must be between 1 and 8 !!\n");
                 break;
            case COUNT:
                 rc= match_int(argc, argv, &opt_index, &countstart);
                 if (rc==-1)
                   my_exit("the countstart parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the countstart parameter is is not a number!\n");
         if ((countstart<0))
           my_exit("[count]-parameter must be greater than 0 !!\n");
                 break;
            case BITRATE:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
             operation=CMD_BITRATE;
                 rc= match_int(argc, argv, &opt_index, &(n[0]));
                 if (rc==-1)
                   my_exit("the port parameter is missing!\n");
                 if (rc==-2)
                   my_exit("the port parameter is is not a number!\n");
                 break;
            case RWTEST:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
             operation=CMD_RWTEST;
             for(i=0; i<=5; i++)
               {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case WRITE:
            case WRITE_LATER:
            case WRITE_LATER_W:
            case WRITE_INHIBIT:
            case WRITE_RTR:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
                 switch (opt)
                   {
                     case WRITE:
                       operation=CMD_WRITE; break;
                     case WRITE_LATER:
                       operation=CMD_WRITE_LATER; break;
                     case WRITE_LATER_W:
                       operation=CMD_WRITE_LATER_W; break;
                     case WRITE_INHIBIT:
                       operation=CMD_WRITE_INHIBIT; break;
                     case WRITE_RTR:
                       operation=CMD_WRITE_RTR; break;
                   }
                 l=2;
                 if (operation==CMD_WRITE_INHIBIT)
                   l=3; /* one more parameter */
             for(i=0; i<=l; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case READ:
            case READ_NOW:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
                 switch (opt)
                   {
                     case READ:
                       operation=CMD_READ; break;
                     case READ_NOW:
                       operation=CMD_READ_NOW; break;
                   }
             for(i=0; i<=2; i++)
                   {
                     rc= match_int(argc, argv, &opt_index, &(n[i]));
                     if (rc==-1)
                       my_exit("error, argument missing\n");
                     if (rc==-2)
                       my_exit("error, argument is not a number\n");
           };
                 break;
            case QUEUE_READ:
             if (operation!=CMD_NOTHING)
                   my_exit("contradicting options\n");
             operation= CMD_QUEUE_READ;
                 rc=0;
             last_valid_n=-1;
             while ((rc==0) && (last_valid_n<21))
               {
                     last_valid_n++;
                     rc= match_int(argc, argv, &opt_index, &(n[last_valid_n]));
                     switch(last_valid_n)
                       {
                         case 0:
                           if (rc!=0)
                             my_exit("error, port missing\n");
                           break;
                         case 1:
                           if (rc!=0)
                             my_exit("error, timeout missing\n");
                           break;
                         case 2:
                           if (rc!=0)
                             my_exit("error, first object-id missing\n");
                           break;
                         default:
                           if (rc!=0)
                             last_valid_n--;
                           break;
                       }
           };
                 break;
      }; /* switch */
      }; /* while */
    if (interface_no==0)
      {
        printf("Error, no interfaces defined\n");
        return 1;
      }
    if (!init_socan(interfaces, interface_no,
                    tracelevel, errprintlevel,
                    rt_prios[0], rt_prios[1]))
      return 1;
 
    switch(operation)
      {
        case CMD_NOTHING:
             printf("error, no command given\n");
             return 1;
    case CMD_BITRATE:
         test_bitrate(n[0]);
         break;
    case CMD_RWTEST:
         test_simple_rw(n[0], n[1], n[2], n[3], n[4], n[5],
                    flag);
         break;
    case CMD_WRITE:
        case CMD_WRITE_LATER:
        case CMD_WRITE_LATER_W:
        case CMD_WRITE_INHIBIT:
        case CMD_WRITE_RTR:
         test_write(n[0], n[1], n[2], n[3],
                loops, loopdelay, sleep, leave, quietlevel,
                operation,
                countsize,countstart,
                    flag);
         break;
        case CMD_READ:
        case CMD_READ_NOW:
         test_read(n[0], n[1], n[2],
                   loops, loopdelay, sleep, leave,
                       maxlossrate, quietlevel,
                   (operation==CMD_READ_NOW),
                   countsize, flag);
         break;
    case CMD_QUEUE_READ:
         test_queue_read(n[0], n[1], n+2, last_valid_n-1,
                     loops, loopdelay, sleep, leave, maxlossrate,
                         quietlevel, countsize, flag);
         break;
      }
    return(0);
  }