update Sick S300

.gitignore

@@ -5,3 +5,7 @@ Makefile-BRICS_OODL.mk
 .dep.inc
 nbproject
 CMakeFiles
+/sick-s300/OODL_SickS300_plot
+/log.txt
+/hokuyo-urg/OODL_HokuyoURG_test
+/hokuyo-urg/libOODL_HokuyoURG.a

CMakeLists.txt

@@ -18,20 +18,18 @@ ENDIF(NOT DEFINED BOOST_LOG_PATH)
 
 
 IF(NOT DEFINED SELECTED_DRIVER)
-  add_subdirectory(hokuyo-urg)
-  add_subdirectory(sick-lms-2xx)
-  add_subdirectory(sick-ld)
-  add_subdirectory(sick-s300)
-#  add_subdirectory(monocular-camera)
+ # add_subdirectory(hokuyourg)
+ # add_subdirectory(sicklms2xx)
+ # add_subdirectory(sickld)
+  add_subdirectory(sicks300)
+#  add_subdirectory(monocularcamera)
+#add_subdirectory(sicks300test)
 
- # add_subdirectory(mesa-swissranger)
- # add_subdirectory(pmd-camcube)
+ # add_subdirectory(mesaswissranger)
+ # add_subdirectory(pmdcamcube)
 ENDIF(NOT DEFINED SELECTED_DRIVER)
 
 
 IF(DEFINED SELECTED_DRIVER)
   add_subdirectory(${SELECTED_DRIVER})
 ENDIF(DEFINED SELECTED_DRIVER)
-
-
-

generic-laser-scanner/LaserScanner.h

@@ -8,9 +8,12 @@
  * \date
  */
 #include <string>
+#include "generic/Errors.h"
+#include "generic/Logger.h"
+#include "generic/Units.h"
 #include "generic-laser-scanner/LaserScannerConfiguration.h"
 #include "generic-laser-scanner/LaserScannerData.h"
-#include "generic/Errors.h"
+#include "generic-laser-scanner/LaserScannerDataWithIntensities.h"
 class Errors;
 class LaserScannerConfiguration;
 class LaserScannerData;

generic-monocular-camera/CMakeLists.txt

@@ -3,6 +3,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
 SET(UNICAP_LIB /usr/local/lib)
 SET(SOURCES MonocularCameraConfiguration.cpp)
 SET(LIBNAME MonocularCameraConfiguration)
+SET(COMPILE_C_FLAGS_DEBUG "-Wall -g")
+SET(CMAKE_CXX_FLAGS_DEBUG  "-O0 -g")
 
 
 

generic-monocular-camera/MonocularCameraConfiguration.cpp

@@ -5,32 +5,256 @@
 
 
 
+DeviceConfiguration:: DeviceConfiguration()
+{
+  videoFrameRate.min = 0.0; 
+  videoFrameRate.max = 0.0; 
+  videoGammaValue.min = 0.0; 
+  videoGammaValue.max = 0.0; 
+  videoSharpnessValue.min = 0.0;
+  videoSharpnessValue.max = 0.0;
+  lensFocus.min = 0.0;
+  lensFocus.max = 0.0;
+  lensZoom.min = 0.0; 
+  lensZoom.max = 0.0; 
+  lensIris.min = 0.0; 
+  lensIris.max = 0.0; 
+  returnStatus = STATUS_FAILURE;
+}
+
+
+DeviceConfiguration::~DeviceConfiguration()
+{
+
+}
+
+
+bool DeviceConfiguration::getVideoFrameRate(double &rate)
+{
+
+
+
+}
+
+
+bool DeviceConfiguration::getVideoGammaValue(double &gamma)
+{
+
+}
+
+bool DeviceConfiguration::getVideoSharpnessValue(double &sharpness)
+{
+
+}
+
+bool DeviceConfiguration::getLensFocus(double &focus)
+{
+
+
+}
+
+bool DeviceConfiguration::getLensZoom(double &zoom)
+{
+
+
+}
+
+bool DeviceConfiguration::getLensIris(double &iris)
+{
+
+
+}
+
+
+bool DeviceConfiguration::setVideoFrameRate(double &rate)
+{
+
+
+}
+
+
+bool DeviceConfiguration::setVideoGammaValue(double &gamma)
+{
+
+
+}
+
+bool DeviceConfiguration::setVideoSharpnessValue(double &sharpness)
+{
+
+
+}
+
+
+bool DeviceConfiguration::setLensFocus(double &focus)
+{
+
+
+}
+
+
+bool DeviceConfiguration::setLensZoom(double &zoom)
+{
+
+
+}
+
+bool DeviceConfiguration::setLensIris(double &iris)
+{
+
+
+}
+
+
+
+ColorExposureConfiguration::ColorExposureConfiguration()
+{
+
+}
+
+ColorExposureConfiguration::~ColorExposureConfiguration()
+{
+
+
+}
+
+bool ColorExposureConfiguration::getHueValue(double &hue)
+{
+
+}
+
+bool ColorExposureConfiguration::getChromaValue(double &chroma)
+{
+
+}
+
+
+bool ColorExposureConfiguration::getSaturationValue(double &saturation)
+{
+
+}
+
+bool ColorExposureConfiguration::getColorTemperatureValue(double &temp)
+{
+
+}
+
+bool ColorExposureConfiguration::getWhiteBalanceUValue(double &uValue)
+{
+
+}
+
+bool ColorExposureConfiguration::getWhiteBalanceVValue(double &vValue)
+{
+
+}
+
+bool ColorExposureConfiguration::getBrightnessValue(double &brightness)
+{
+
+}
+
+bool ColorExposureConfiguration::getGainControlValue(double &gain)
+{
+
+}
+
+bool ColorExposureConfiguration::getShutterTime(double &sTime)
+{
+
+}
+
+bool ColorExposureConfiguration::getExposureTime(double &eTime)
+{
+
+}
+
+bool ColorExposureConfiguration::setHueValue(double &hue)
+{
+
+}
+
+bool ColorExposureConfiguration::setChromaValue(double &chroma)
+{
+
+}
+
+bool ColorExposureConfiguration::setSaturationValue(double &saturation)
+{
+
+}
+
+bool ColorExposureConfiguration::setColorTemperatureValue(double &temp)
+{
+
+}
+
+bool ColorExposureConfiguration::setWhiteBalanceUValue(double &uValue)
+{
+
+}
+
+bool ColorExposureConfiguration::setWhiteBalanceVValue(double &vValue)
+{
+
+}
+
+bool ColorExposureConfiguration::setBrightnessValue(double &brightness)
+{
+
+}
+
+bool ColorExposureConfiguration::setGainControlValue(double &gain)
+{
+
+}
+
+bool ColorExposureConfiguration::setShutterTime(double &sTime)
+{
+
+}
+
+bool ColorExposureConfiguration::setExposureTime(double &eTime)
+{
+
+}
+
+
+
 MonocularCameraConfiguration::MonocularCameraConfiguration()
 {
-   deviceConfig = new unicap_property_t;
-   device = new unicap_device_t;
-   returnStatus = STATUS_FAILURE;
-   deviceID = "";
-   deviceNodeID = "";
-   devicePluginType = "";
+
 
 }
 
 
+MonocularCameraConfiguration::MonocularCameraConfiguration(unicap_device_t *device, unicap_handle_t *handle)
+{
+  deviceConfig = device;
+  handleConfig = handle;
+  returnStatus = STATUS_FAILURE;
+  deviceID = "";
+  deviceNodeID = "";
+  devicePluginType = "";
+  colExpConfiguration = new ColorExposureConfiguration;
+  devConfiguration = new DeviceConfiguration;
+  propertyConfig = new unicap_property_t;
+}
+
 bool MonocularCameraConfiguration::getDeviceName(std::string &deviceId)
 {
   if(SUCCESS(returnStatus))
   {
-    deviceID = device->identifier;
+    deviceID = deviceConfig->identifier;
     deviceId = deviceID;
     return true;
   }
   else
   {
-    returnStatus = unicap_enumerate_devices(NULL, device,0);
+    returnStatus = unicap_enumerate_devices(NULL, deviceConfig,0);
     if(SUCCESS(returnStatus))
     {
-      deviceID = device->identifier;
+      deviceID = deviceConfig->identifier;
       deviceId = deviceID; 
       return true;
     }
@@ -50,17 +274,17 @@ bool MonocularCameraConfiguration::getDeviceNodeID(std::string &deviceNodeId)
 {
   if(SUCCESS(returnStatus))
   {
-    deviceNodeID = device->device;
+    deviceNodeID = deviceConfig->device;
     deviceNodeId = deviceNodeID; 
     return true;
   }
 
   else
   {
-    returnStatus = unicap_enumerate_devices(NULL, device,0); 
+    returnStatus = unicap_enumerate_devices(NULL, deviceConfig,0); 
     if(SUCCESS(returnStatus))
     {
-      deviceNodeID = device->device;
+      deviceNodeID = deviceConfig->device;
       deviceNodeId = deviceNodeID; 
       return true;
     }
@@ -79,16 +303,16 @@ bool MonocularCameraConfiguration::getDevicePluginType(std::string &pluginName)
 
   if(SUCCESS(returnStatus))
   {
-    devicePluginType = device->cpi_layer;
+    devicePluginType = deviceConfig->cpi_layer;
     pluginName = devicePluginType; 
     return true;
   }
   else
   {
-    returnStatus = unicap_enumerate_devices(NULL, device,0);
+    returnStatus = unicap_enumerate_devices(NULL, deviceConfig,0);
     if(SUCCESS(returnStatus))
     {
-      devicePluginType = device->cpi_layer;
+      devicePluginType = deviceConfig->cpi_layer;
       pluginName = devicePluginType; 
       return true;
     }
@@ -105,12 +329,14 @@ bool MonocularCameraConfiguration::getDevicePluginType(std::string &pluginName)
 
 bool MonocularCameraConfiguration::getDeviceFullInfoVector()
 {
-  returnStatus = unicap_enumerate_devices(NULL, device, 0);
+  returnStatus = unicap_enumerate_devices(NULL, deviceConfig, 0);
 
 }
 
 MonocularCameraConfiguration::~MonocularCameraConfiguration()
 {
-  delete deviceConfig;
-  delete device;
+  delete colExpConfiguration;
+  delete devConfiguration;
+  delete propertyConfig;
+
 }