Changeset 330 in flair-src for trunk/lib/FlairSensorActuator

Timestamp:

09/25/19 15:29:26 (5 years ago)

Author:

Sanahuja Guillaume

Message:

use less bandwidth in vprnlite

Location:

trunk/lib/FlairSensorActuator/src

Files:

• Camera.cpp (modified) (4 diffs)
• SimulatedCamera.cpp (modified) (2 diffs)
• SimulatedCamera.h (modified) (1 diff)
• V4LCamera.cpp (modified) (10 diffs)
• V4LCamera.h (modified) (3 diffs)
• VrpnClient.cpp (modified) (2 diffs)
• VrpnClient.h (modified) (2 diffs)
• VrpnClient_impl.cpp (modified) (7 diffs)
• VrpnObject.h (modified) (2 diffs)
• VrpnObject_impl.cpp (modified) (4 diffs)
• unexported/VrpnClient_impl.h (modified) (2 diffs)

trunk/lib/FlairSensorActuator/src/Camera.cpp

@@ -117 +117 @@
 void Camera::ProcessUpdate(core::io_data* data) {
         if(getFrameworkManager()->IsLogging() && getFrameworkManager()->IsDeviceLogged(this)) {
+    Printf("todo logging and jpeg without opencv\n");
+    /*
                 if(logFormat==LogFormat::JPG) {
                         data->GetMutex();
@@ -143 +145 @@
                         }
                         data->ReleaseMutex();
-                }
+                }*/
         }
         IODevice::ProcessUpdate(data);
@@ -151 +153 @@
         if(filename=="") filename="./"+ObjectName()+"_"+std::to_string(GetTime())+".jpg";
   string::size_type idx = filename.rfind('.');
-
+Printf("todo SavePictureToFile without opencv\n");/*
         if(idx != string::npos) {
                 Printf("saving %s\n", filename.c_str());
@@ -169 +171 @@
         } else {
                 Warn("saving %s no file extension!\n", filename.c_str());
-        }
+        }*/
 }
 
 void Camera::SaveRawPictureToFile(string filename) const {
-  Printf("saving %s, size %i\n", filename.c_str(), output->img->imageSize);
+  Printf("saving %s, size %i\n", filename.c_str(), output->GetDataType().GetSize());
   std::ofstream pFile;
   pFile.open(filename);
   output->GetMutex();
-  pFile.write(output->img->imageData, output->img->imageSize);
+  pFile.write(output->buffer, output->GetDataType().GetSize());
   output->ReleaseMutex();
 

trunk/lib/FlairSensorActuator/src/SimulatedCamera.cpp

@@ -22 +22 @@
 #include <SharedMem.h>
 #include <sstream>
+#include <string.h>
 
 using std::string;
@@ -40 +41 @@
 
   shmemReadBuf=(char*)malloc(buf_size);
-  output->img->imageData = shmemReadBuf;
+  output->buffer = shmemReadBuf;
 
   shmem = new SharedMem((Thread *)this,ShMemName(modelId, deviceId), buf_size, SharedMem::Type::producerConsumer);

trunk/lib/FlairSensorActuator/src/SimulatedCamera.h

@@ -16 +16 @@
 #include <Camera.h>
 #include <Thread.h>
-#include <cxcore.h>
 
 namespace flair {

trunk/lib/FlairSensorActuator/src/V4LCamera.cpp

@@ -23 +23 @@
 #include <cvimage.h>
 #include <FrameworkManager.h>
+#include <fcntl.h>
 #include <linux/videodev2.h>
+
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <cstring>
+#include <sys/mman.h>
+
+
+#define DEFAULT_V4L_BUFFERS 4
 
 using std::string;
@@ -37 +46 @@
     : Thread(getFrameworkManager(), name, priority),
       Camera(name, width, height, format) {
-  capture = cvCaptureFromCAM(camera_index);
-  if (capture < 0)
-    Thread::Err("cvCaptureFromCAM error\n");
-
-  if (cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, width)<0)
-    Thread::Err("cvSetCaptureProperty error\n");
-  if (cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, height)<0)
-    Thread::Err("cvSetCaptureProperty error\n");
-
+  
+  string deviceName="/dev/video"+std::to_string(camera_index);
+  device = open(deviceName.c_str(), O_RDWR | O_NONBLOCK);
+  if (device == -1) {
+     Thread::Err("Cannot open %s\n");
+  }
+    
+  //get v4l2_format
+  struct v4l2_format form;
+  form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  xioctl (device, VIDIOC_G_FMT,&form);
+  
+  //set width, height and format
   if (format == cvimage::Type::Format::UYVY) {
-    if (cvSetCaptureProperty(capture, CV_CAP_PROP_FORMAT, V4L2_PIX_FMT_UYVY)<0)
-      Thread::Err("cvSetCaptureProperty error\n");
+    form.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; 
   } else if (format == cvimage::Type::Format::YUYV) {
-    if (cvSetCaptureProperty(capture, CV_CAP_PROP_FORMAT, V4L2_PIX_FMT_YUYV) <
-        0)
-      Thread::Err("cvSetCaptureProperty error\n");
+    form.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 
   } else {
     Thread::Err("format not supported\n");
   }
-
+  
+  form.fmt.pix.width = width; 
+  form.fmt.pix.height = height;
+  form.fmt.win.chromakey = 0;
+  form.fmt.win.field = V4L2_FIELD_ANY;
+  form.fmt.win.clips = 0;
+  form.fmt.win.clipcount = 0;
+  form.fmt.pix.field = V4L2_FIELD_ANY;
+  xioctl (device, VIDIOC_S_FMT, &form);
+  
+  /* This is just a technicality, but all buffers must be filled up before any
+   staggered SYNC is applied.  SO, filler up. (see V4L HowTo) */
+
+  AllocBuffers();
+
+  for (int bufferIndex = 0; bufferIndex < ((int)requestbuffers.count);++bufferIndex) {
+    struct v4l2_buffer buf;
+
+    memset(&buf, 0, sizeof (v4l2_buffer));
+
+    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buf.memory      = V4L2_MEMORY_MMAP;
+    buf.index       = (unsigned long)bufferIndex;
+
+    if (-1 == xioctl (device, VIDIOC_QBUF, &buf)) {
+        Thread::Err("VIDIOC_QBUF xioctl\n");
+        break;
+    }
+  }
+
+  // enable the streaming
+  v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  if (-1 == xioctl (device, VIDIOC_STREAMON,&type)) {
+      Thread::Err("VIDIOC_STREAMON xioctl\n");
+  }
+
+
+  // skip first frame. it is often bad -- this is unnotied in traditional apps,
+  //  but could be fatal if bad jpeg is enabled
+  GrabFrame();
+    
+    
+    
   // station sol
   gain = new DoubleSpinBox(GetGroupBox()->NewRow(), "gain:", 0, 1, 0.1);
@@ -85 +137 @@
 void V4LCamera::Run(void) {
   Time cam_time, new_time, fpsNow, fpsPrev;
-  IplImage *img; // raw image
+  char* buffer; // raw image
   int fpsCounter = 0;
 
   // init image old
-  if (!cvGrabFrame(capture)) {
-    Printf("Could not grab a frame\n");
-  }
+  GrabFrame();
   cam_time = GetTime();
   fpsPrev = cam_time;
@@ -97 +147 @@
   while (!ToBeStopped()) {
     //check for ps3eye deconnection in hds uav
-    if(cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH)<0) {
-      Thread::Warn("camera disconnected\n");
-      hasProblems=true;
+    if(hasProblems==false) {
+      struct v4l2_format form;
+      form.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+      xioctl(device, VIDIOC_G_FMT,&form);
+      if(xioctl (device, VIDIOC_G_FMT,&form)<0) {
+        Thread::Warn("camera disconnected\n");
+        hasProblems=true;
+      }
     }
     
@@ -127 +182 @@
       SetHue(hue->Value());
     if (sharpness->ValueChanged() == true)
-      cvSetCaptureProperty(capture, CV_CAP_PROP_SHARPNESS, sharpness->Value());
+      SetProperty(V4L2_CID_SHARPNESS, sharpness->Value());
     if (autogain->ValueChanged() == true) {
       if (autogain->Value() == true) {
@@ -147 +202 @@
     }
     if (awb->ValueChanged() == true)
-      cvSetCaptureProperty(capture, CV_CAP_PROP_AWB, awb->Value());
+      SetProperty(V4L2_CID_AUTO_WHITE_BALANCE, awb->Value());
 
     // cam pictures
-    img = cvRetrieveRawFrame(capture);
-    if (!cvGrabFrame(capture)) {
-      Printf("Could not grab a frame\n");
-    }
+    buffer = RetrieveRawFrame();
+    GrabFrame();
     new_time = GetTime();
     
@@ -163 +216 @@
 
     output->GetMutex();
-    output->img->imageData = img->imageData;
+    output->buffer = buffer;
     output->ReleaseMutex();
 
@@ -172 +225 @@
   }
 
-  cvReleaseCapture(&capture);
+  close(device);
+}
+
+void V4LCamera::GrabFrame(void) {
+    unsigned int count;
+
+    count = 1;
+
+    while (count-- > 0) {
+        for (;;) {
+            fd_set fds;
+            struct timeval tv;
+            int r;
+
+            FD_ZERO (&fds);
+            FD_SET (device, &fds);
+
+            /* Timeout. */
+            tv.tv_sec = 2;
+            tv.tv_usec = 0;
+
+            r = select (device+1, &fds, NULL, NULL, &tv);
+
+            if (-1 == r) {
+                if (EINTR == errno) continue;
+                Thread::Err("select\n");
+            }
+
+            if (0 == r) {
+                Thread::Err("select timeout\n");
+                /* end the infinite loop */
+                break;
+            }
+
+            if (read_frame_v4l2 ()) break;
+        }
+    }
+}
+
+int V4LCamera::read_frame_v4l2(void) {
+  struct v4l2_buffer buf;
+  memset(&buf, 0, sizeof (v4l2_buffer));
+  
+
+    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buf.memory = V4L2_MEMORY_MMAP;
+
+    if (-1 == xioctl (device, VIDIOC_DQBUF, &buf)) {
+        switch (errno) {
+        case EAGAIN:
+            return 0;
+
+        case EIO:
+            /* Could ignore EIO, see spec. */
+
+            /* fall through */
+
+        default:
+            /* display the error and stop processing */
+            Thread::Err("VIDIOC_DQBUF xioctl\n");
+            return 1;
+        }
+   }
+
+   if(buf.index >= requestbuffers.count) {
+     Thread::Err("buf.index >= requestbuffers.count\n");
+   }
+   
+#ifdef USE_TEMP_BUFFER
+   memcpy(capture->buffers[MAX_V4L_BUFFERS].start, 
+          capture->buffers[buf.index].start, 
+          capture->buffers[MAX_V4L_BUFFERS].length );
+   capture->bufferIndex = MAX_V4L_BUFFERS;
+   //printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n", 
+   //     buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);
+#else
+   bufferIndex = buf.index;
+#endif
+
+   if (-1 == xioctl (device, VIDIOC_QBUF, &buf)) {
+       Thread::Err ("VIDIOC_QBUF xioctl\n");
+   }
+
+   return 1;
+}
+
+int V4LCamera::AllocBuffers(void) {
+   memset(&requestbuffers, 0, sizeof (v4l2_requestbuffers));
+   
+   unsigned int buffer_number = DEFAULT_V4L_BUFFERS;
+
+   try_again:
+   
+   requestbuffers.count = buffer_number;
+   requestbuffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+   requestbuffers.memory = V4L2_MEMORY_MMAP;
+
+   if (-1 == xioctl (device, VIDIOC_REQBUFS, &requestbuffers)) {
+       if (EINVAL == errno) {
+         Thread::Err("not support memory mapping not supportted\n");
+       } else {
+         Thread::Err ("VIDIOC_REQBUFS xioctl\n");
+       }
+       return -1;
+   }
+
+   if (requestbuffers.count < buffer_number) {
+       if (buffer_number == 1) {
+        Thread::Err("Insufficient buffer memory\n");
+        return -1;
+       } else {
+        buffer_number--;
+        Thread::Warn ("Insufficient buffer memory, decreasing buffers\n");
+        goto try_again;
+       }
+   }
+
+   for (int n_buffers = 0; n_buffers < requestbuffers.count; ++n_buffers) {
+       struct v4l2_buffer buf;
+
+       memset(&buf, 0, sizeof (v4l2_buffer));
+
+       buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+       buf.memory = V4L2_MEMORY_MMAP;
+       buf.index = n_buffers;
+
+       if (-1 == xioctl (device, VIDIOC_QUERYBUF, &buf)) {
+           Thread::Err("VIDIOC_QUERYBUF xioctl\n");
+           return -1;
+       }
+
+       buffers[n_buffers].length = buf.length;
+       buffers[n_buffers].start =
+         mmap (NULL /* start anywhere */,
+               buf.length,
+               PROT_READ | PROT_WRITE /* required */,
+               MAP_SHARED /* recommended */,
+               device, buf.m.offset);
+
+       if (MAP_FAILED == buffers[n_buffers].start) {
+           Thread::Err("mmap\n");
+           return -1;
+       }
+   }
+
+  //todo: verifier cette alloc, pas de double buffeinrg?
+  //peut on initialiser l'image dans le constrcteur de la camera?
+   
+   output->buffer=output->allocFunction(output->dataType.GetSize());
+   return 1;
+};
+
+char *V4LCamera::RetrieveRawFrame(void) {
+  
+  /* [FD] this really belongs here */
+  if (ioctl(device, VIDIOCSYNC, &mmaps[bufferIndex].frame) == -1) {
+    Thread::Err("Could not SYNC to video stream. %s\n", strerror(errno));
+  }
+
+  /* Now get what has already been captured as a IplImage return */
+  if (output->dataType.GetFormat() == cvimage::Type::Format::YUYV || output->dataType.GetFormat() == cvimage::Type::Format::UYVY) {
+    #ifdef USE_TEMP_BUFFER
+    capture->frame.imageData=(char*)capture->buffers[capture->bufferIndex].start;
+    #else
+Printf("frame is not allocated\n");
+    memcpy((char *)frame,(char *)buffers[bufferIndex].start,output->GetDataType().GetSize());
+    #endif
+  } else {
+    Thread::Err("palette %d not supported for raw output\n",output->dataType.GetFormat());
+  }
+
+  return(frame);
 }
 
@@ -180 +404 @@
 
 void V4LCamera::SetAutoGain(bool value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_AUTOGAIN, value);
+  SetProperty(V4L2_CID_AUTOGAIN, value);
 }
 
@@ -188 +412 @@
 
 void V4LCamera::SetGain(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_GAIN, value);
+  SetProperty(V4L2_CID_GAIN, value);
 }
 
 void V4LCamera::SetExposure(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_EXPOSURE, value);
+  SetProperty(V4L2_CID_EXPOSURE, value);
 }
 
 void V4LCamera::SetBrightness(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_BRIGHTNESS, value);
+  SetProperty(V4L2_CID_BRIGHTNESS, value);
 }
 
 void V4LCamera::SetSaturation(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_SATURATION, value);
+  SetProperty(V4L2_CID_SATURATION, value);
 }
 
 void V4LCamera::SetHue(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_HUE, value);
+  SetProperty(V4L2_CID_HUE, value);
 }
 
 void V4LCamera::SetContrast(float value) {
-  cvSetCaptureProperty(capture, CV_CAP_PROP_CONTRAST, value);
+  SetProperty(V4L2_CID_CONTRAST, value);
+}
+
+float V4LCamera::GetProperty(int property) {
+  //get min and max value
+  struct v4l2_queryctrl queryctrl;
+  queryctrl.id = property;
+  if(xioctl (device, VIDIOC_QUERYCTRL,&queryctrl)==-1) return -1;
+  int min = queryctrl.minimum;
+  int max = queryctrl.maximum;
+ 
+  //set value
+  struct v4l2_control control;
+  memset (&control, 0, sizeof (v4l2_control));
+  control.id = property;
+  if(xioctl (device,VIDIOC_G_CTRL, &control)==-1) return -1;
+  
+  return ((float)control.value - min + 1) / (max - min);
+}
+
+void V4LCamera::SetProperty(int property,float value) {
+  //get min and max value
+  struct v4l2_queryctrl queryctrl;
+  queryctrl.id = property;
+  xioctl (device, VIDIOC_QUERYCTRL,&queryctrl);
+  int min = queryctrl.minimum;
+  int max = queryctrl.maximum;
+ 
+  //set value
+  struct v4l2_control control;
+  memset (&control, 0, sizeof (v4l2_control));
+  control.id = property;
+  control.value = (int)(value * (max - min) + min);
+  xioctl (device,VIDIOC_S_CTRL, &control);
+}
+
+int V4LCamera::xioctl( int fd, int request, void *arg) {
+  int r;
+
+  do r = ioctl (fd, request, arg);
+  while (-1 == r && EINTR == errno);
+
+  return r;
 }
 

trunk/lib/FlairSensorActuator/src/V4LCamera.h

@@ -16 +16 @@
 #include <Thread.h>
 #include "Camera.h"
-#include <highgui.h>
+//todo use pimpl and remove this
+#include <linux/videodev2.h>
+#include <libv4l1-videodev.h>
+#define MAX_V4L_BUFFERS 10
 
 namespace flair {
@@ -138 +141 @@
   */
   void Run(void);
-
-  CvCapture *capture;
-
+  
+  int device;
   gui::Tab *sensor_tab;
   gui::DoubleSpinBox *bright, *exposure, *gain, *contrast, *hue, *sharpness,*sat;
@@ -146 +148 @@
   gui::Label *fps;
   bool hasProblems;
+  static int xioctl( int fd, int request, void *arg);
+  void SetProperty(int property,float value);
+  float GetProperty(int property);
+  void GrabFrame(void);
+  int read_frame_v4l2(void);
+  char *RetrieveRawFrame(void);
+  int AllocBuffers(void);
+  struct video_mmap *mmaps;
+  int bufferIndex;
+  struct v4l2_requestbuffers requestbuffers;
+  struct buffer {
+    void *  start;
+    size_t  length;
+  };
+  buffer buffers[MAX_V4L_BUFFERS + 1];
+  char* frame;
 };
 } // end namespace sensor

trunk/lib/FlairSensorActuator/src/VrpnClient.cpp

@@ -36 +36 @@
         
 VrpnClient::VrpnClient(string name,
-                       string address, uint8_t priority)
+                       string address, uint8_t priority,ConnectionType_t connectionType)
     : Thread(getFrameworkManager(), name, priority) {
         if (singleton != NULL) {
@@ -45 +45 @@
   }
   
-  pimpl_ = new VrpnClient_impl(this, name, address);
+  pimpl_ = new VrpnClient_impl(this, name, address,connectionType);
 }
 
-
-VrpnClient::VrpnClient(std::string name,
-             uint16_t port,  uint8_t priority)
-  : Thread(getFrameworkManager(), name, priority) {
-        if (singleton != NULL) {
-    SimpleWarn("VrpnClient should be instanced only one time!\n");
-    SimpleWarn("Next calls to GetVrpnClient() will return the first created VrpnClient (%s)\n",singleton->ObjectName().c_str());
-  } else {
-    singleton = this;
-  }
-
-  pimpl_ = new VrpnClient_impl(this, name, port);
-}             
-             
 VrpnClient::VrpnClient(string name,
                        SerialPort *serialport, uint16_t us_period,

trunk/lib/FlairSensorActuator/src/VrpnClient.h

@@ -42 +42 @@
 
 public:
+  typedef enum { Vrpn, VrpnLite, Xbee } ConnectionType_t;
+
   /*!
   * \brief Constructor
   *
-  * Construct a VrpnClient. Connection is done by IP to a vrpn server.
+  * Construct a VrpnClient. Connection is done by IP to a vrpn server or vrpnlite server (see tools/VrpnLite in flair-src)
   *
   * \param name name
   * \param address server address
   * \param priority priority of the Thread
+  * \param connection connection type: Vrpn or VrpnLite
   */
   VrpnClient(std::string name,
-             std::string address,  uint8_t priority);
-
-  /*!
-  * \brief Constructor
-  *
-  * Construct a VrpnClient. Connection is done by IP to a vrpn-lite server (see tools/VrpnLite in flair-src)
-  *
-  * \param name name
-  * \param port server port
-  * \param priority priority of the Thread
-  */
-  VrpnClient(std::string name,
-             uint16_t port,  uint8_t priority);
+             std::string address,  uint8_t priority,ConnectionType_t connectionType=Vrpn);
              
   /*!
@@ -100 +91 @@
   gui::TabWidget *GetTabWidget(void) const;
   
-  typedef enum { Vrpn, VrpnLite, Xbee } ConnectionType_t;
-  
   ConnectionType_t ConnectionType(void) const;
 

trunk/lib/FlairSensorActuator/src/VrpnClient_impl.cpp

@@ -40 +40 @@
 
 VrpnClient_impl::VrpnClient_impl(VrpnClient *self, string name,
-                                 std::string address) {
+                                 std::string address,flair::sensor::VrpnClient::ConnectionType_t connectionType) {
   this->self = self;
   this->address = address;
+  this->connectionType = connectionType;
   isConnected=false;
-  connectionType=VrpnClient::Vrpn;
-
-  connection = vrpn_get_connection_by_name(address.c_str());
+  
+  if(connectionType==VrpnClient::Vrpn) {
+    connection = vrpn_get_connection_by_name(address.c_str());
+    Printf("Connecting to VRPN server on %s\n",address.c_str());
+  } else if(connectionType==VrpnClient::VrpnLite) {
+    dataSocket =new UdpSocket(getFrameworkManager(), "data_socket", address);
+    Printf("Connecting to VRPN-lite server on %s\n",address.c_str());
+  } else {
+    self->Err("Bad connection type, try using naother constructor\n");
+  }
 
   CommonConstructor(name);
-  
-  Printf("Connecting to VRPN server on %s\n",address.c_str());
-}
-
-VrpnClient_impl::VrpnClient_impl(VrpnClient *self, string name,
-                                 uint16_t port) {
-  this->self = self;
-        isConnected=false;
-  connectionType=VrpnClient::VrpnLite;
-
-  dataSocket =new UdpSocket(getFrameworkManager(), "data_socket", port);
-
-  CommonConstructor(name);
-  
-  Printf("Connecting to VRPN-lite server on port %i\n",port);
-}
+}
+
+
 
 VrpnClient_impl::VrpnClient_impl(VrpnClient *self, string name,
@@ -132 +127 @@
     trackables.push_back(obj);
     mutex->ReleaseMutex();
+  } else if (connectionType==VrpnClient::VrpnLite) {
+    if(liteObjects.size()<0xffff) {
+      liteObject_t tmp;
+      tmp.vrpnobject = obj;
+      tmp.id = liteObjects.size();
+      mutex->GetMutex();
+      liteObjects.push_back(tmp);
+      mutex->ReleaseMutex();
+      //Printf("%i %s\n",tmp.id,obj->self->ObjectName().c_str());
+      
+      char char_array[obj->self->ObjectName().length() + 2];//id coded on 16bits 
+      strcpy(char_array, obj->self->ObjectName().c_str()); 
+      uint16_t* idPtr=(uint16_t*)&char_array[obj->self->ObjectName().length()];
+      *idPtr=tmp.id;
+      dataSocket->HostToNetwork((char*)idPtr,sizeof(uint16_t));
+      dataSocket->SendMessage(char_array,obj->self->ObjectName().length() + 2);
+    }else {
+      self->Warn("too much trackables for vrpnlite connection, not adding %s\n",obj->self->ObjectName().c_str());
+    }
   } else {
-    self->Warn("AddTrackable called but not in vrpn mode\n");
+    self->Warn("AddTrackable called but not in vrpn mode nor in vrpnlite mode\n");
   }
 }
@@ -146 +160 @@
     mutex->ReleaseMutex();
   } else {
-    self->Warn("AddTrackable called but not in vrpnlite nor in xbee mode\n");
+    self->Warn("AddTrackable called but not in xbee mode\n");
   }
 }
@@ -153 +167 @@
   mutex->GetMutex();
   if (connectionType==VrpnClient::Vrpn) {
-    for (vector<VrpnObject_impl *>::iterator it = trackables.begin();
-         it < trackables.end(); it++) {
+    for (vector<VrpnObject_impl *>::iterator it = trackables.begin();it < trackables.end(); it++) {
       if (*it == obj) {
         trackables.erase(it);
@@ -162 +175 @@
   }
   if (connectionType==VrpnClient::VrpnLite || connectionType==VrpnClient::Xbee) {
-    for (vector<liteObject_t>::iterator it = liteObjects.begin();
-         it < liteObjects.end(); it++) {
+    for (vector<liteObject_t>::iterator it = liteObjects.begin();it < liteObjects.end(); it++) {
       if ((*it).vrpnobject == obj) {
         liteObjects.erase(it);
@@ -243 +255 @@
             //printf("%lld\n",GetTime()/(1000*1000));
             mutex->GetMutex();
-            for (unsigned int i = 0; i < trackables.size(); i++)
-                trackables.at(i)->tracker->mainloop();
+            for (unsigned int i = 0; i < trackables.size(); i++) {
+             // Printf("tracker %i\n",i);
+              trackables.at(i)->tracker->mainloop();
+              //Printf("tracker %i ok\n",i);
+            }
             mutex->ReleaseMutex();
         } else {
@@ -251 +266 @@
         }
     }else if(connectionType==VrpnClient::VrpnLite) {
-      vrpn_TRACKERCB t;
-      float pos[3];
-      float quat[4];
+      mutex->GetMutex();
+    
+      int16_t pos[3];
+      int16_t quat[4];
       Time time;
-      uint8_t id;
-      char datas[sizeof(id) + sizeof(pos)+sizeof(quat)+ sizeof(time)];
+      char datas[liteObjects.size()*(sizeof(pos)+sizeof(quat))+ sizeof(time)];
+      char *datasPtr=datas;
+      
       int rcv=dataSocket->RecvMessage(datas,sizeof(datas),50*1000*1000);
-      if(rcv!=sizeof(datas)) continue;  
-      id = datas[0];
-      memcpy(pos, datas+sizeof(id), sizeof(pos));
-      memcpy(quat, datas +sizeof(id)+ sizeof(pos), sizeof(quat));
-      memcpy(&time, datas+sizeof(id) + sizeof(pos)+sizeof(quat), sizeof(time));
-      
-      for(int i=0;i<3;i++) dataSocket->NetworkToHost((char*)(&pos[i]),sizeof(pos[i]));
-      for(int i=0;i<4;i++) dataSocket->NetworkToHost((char*)(&quat[i]),sizeof(quat[i]));
+      if(rcv!=sizeof(datas)) {
+        if(rcv>0) Printf("discarding message (size %i/%i)\n",rcv,sizeof(datas));
+        mutex->ReleaseMutex();
+        continue;  
+      }
+      
+      memcpy(&time, datasPtr+sizeof(datas)-sizeof(time), sizeof(time));
       dataSocket->NetworkToHost((char*)(&time),sizeof(time));
-
-      mutex->GetMutex();
-      if (id < liteObjects.size()) {
-        for (int i = 0; i < 3; i++) t.pos[i] = pos[i];
+      
+      for (vector<liteObject_t>::iterator it = liteObjects.begin();it < liteObjects.end(); it++) {
+        memcpy(pos, datasPtr, sizeof(pos));
+        datasPtr+=sizeof(pos);
+        memcpy(quat,datasPtr, sizeof(quat));
+        datasPtr+=sizeof(quat);
+        
+        for(int i=0;i<3;i++) dataSocket->NetworkToHost((char*)(&pos[i]),sizeof(pos[i]));
+        for(int i=0;i<4;i++) dataSocket->NetworkToHost((char*)(&quat[i]),sizeof(quat[i]));
+        
+        vrpn_TRACKERCB t;
+        for (int i = 0; i < 3; i++) t.pos[i] = ConvertPosition(pos[i]);
         // warning: t.quat is defined as (qx,qy,qz,qw), which is different from
         // flair::core::Quaternion
-        t.quat[0] = quat[1];
-        t.quat[1] = quat[2];
-        t.quat[2] = quat[3];
-        t.quat[3] = quat[0];
+        t.quat[0] = ConvertQuaternion(quat[1]);
+        t.quat[1] = ConvertQuaternion(quat[2]);
+        t.quat[2] = ConvertQuaternion(quat[3]);
+        t.quat[3] = ConvertQuaternion(quat[0]);
         t.msg_time.tv_sec=time/((Time)1000000000);
         t.msg_time.tv_usec=(time%((Time)1000000000))/((Time)1000);
         //Printf("%i %lld %lld %lld\n",id,time,t.msg_time.tv_sec,t.msg_time.tv_usec);
-        VrpnObject_impl::handle_pos(liteObjects.at(id).vrpnobject, t);
-      }
+        VrpnObject_impl::handle_pos((void*)(it->vrpnobject), t);
+      }
+      
       mutex->ReleaseMutex();
     }
   }
 }
+
+float VrpnClient_impl::ConvertPosition(int16_t value) const {
+  return (float)value/1000.;
+}
+
+float VrpnClient_impl::ConvertQuaternion(int16_t value) const {
+  return (float)value/32767.;
+}

trunk/lib/FlairSensorActuator/src/VrpnObject.h

@@ -50 +50 @@
   * \brief Constructor
   *
-  * Construct a VrpnObject. Connection is done by IP. (vrpn)
+  * Construct a VrpnObject. Connection is done by IP with vrpn or vrpnlite (see tools/VrpnLite in flair-src)
   *
   * \param name VRPN object name, should be the same as defined in the server
@@ -62 +62 @@
   * \brief Constructor
   *
-  * Construct a VrpnObject. Connection is done by xbee or vrpnlite (see tools/VrpnLite in flair-src)
+  * Construct a VrpnObject. Connection is done by xbee 
   *
   * \param name name
-  * \param id VRPN object id, should be the same as defined in the xbee bridge or vrpnlite tool
+  * \param id VRPN object id, should be the same as defined in the xbee bridge
   * \param tab Tab for the user interface
   * \param client VrpnClient of the connection, if unspecified, use the default one

trunk/lib/FlairSensorActuator/src/VrpnObject_impl.cpp

@@ -51 +51 @@
     self->Err("erreur aucun identifiant specifie pour la connexion Xbee\n");
   }
-  if (id == -1 && GetVrpnClient()->ConnectionType()==VrpnClient::VrpnLite) {
-    self->Err("erreur aucun identifiant specifie pour la connexion VrpnLite\n");
+  if (id != -1 && GetVrpnClient()->ConnectionType()==VrpnClient::VrpnLite) {
+    self->Err("identifiant pour la connexion ignore car inutile en mode VrpnLite\n");
   }
   if (id != -1 && GetVrpnClient()->ConnectionType()==VrpnClient::Vrpn) {
@@ -94 +94 @@
     parent->pimpl_->AddTrackable(this);
   } else if(GetVrpnClient()->ConnectionType()==VrpnClient::VrpnLite){
-    parent->pimpl_->AddTrackable(this, id);
+    parent->pimpl_->AddTrackable(this);
   }
   
@@ -191 +191 @@
 
   caller->output->SetDataTime(time,deltaTime);
+  //Printf("%s data filled\n",caller->self->ObjectName().c_str());
   caller->output->ReleaseMutex();
 
@@ -199 +200 @@
   caller->state->SetValueNoMutex(2, 0, Euler::ToDegree(euler.yaw));
   caller->state->ReleaseMutex();
-
+//Printf("%s process\n",caller->self->ObjectName().c_str());
   caller->self->ProcessUpdate(caller->output);
-}
+  //Printf("%s process ok\n",caller->self->ObjectName().c_str());
+}

trunk/lib/FlairSensorActuator/src/unexported/VrpnClient_impl.h

@@ -48 +48 @@
 public:
   VrpnClient_impl(flair::sensor::VrpnClient *self, std::string name,
-                  std::string address);
+                  std::string address,flair::sensor::VrpnClient::ConnectionType_t connectionType);
   VrpnClient_impl(flair::sensor::VrpnClient *self, std::string name,
                   flair::core::SerialPort *serialport, uint16_t us_period);
-  VrpnClient_impl(flair::sensor::VrpnClient *self, std::string name,
-                  uint16_t port);
+  
   ~VrpnClient_impl();
   void AddTrackable(VrpnObject_impl *obj);    // normal
@@ -67 +66 @@
 private:
   void CommonConstructor(std::string name);
+  float ConvertPosition(int16_t value) const;
+  float ConvertQuaternion(int16_t value) const;
   flair::sensor::VrpnClient *self;
   flair::core::Mutex *mutex;