Representations/Perception/SensorData.h

Go to the documentation of this file.

/**
 * @file SensorData.h
 * 
 * Declaration of class SensorData
 */ 

#ifndef __SensorData_h_
#define __SensorData_h_

#include "Tools/Streams/InOut.h"
#include "Tools/Streams/Streamable.h"

/**
* A class representing a sensor data vector. 
*/
class SensorData : public Streamable
{
  void serialize(In* in, Out* out)
  {
    STREAM_REGISTER_BEGIN();
    STREAM(data[neckTilt]);
    STREAM(data[headPan]);
    STREAM(data[headTilt]);

    STREAM(data[backR]);
    STREAM(data[backF]);
    STREAM(data[headPsdNear]);
    STREAM(data[mouth]);
    STREAM(data[chin]);

    STREAM(data[legFL1]); 
    STREAM(data[legFL2]); 
    STREAM(data[legFL3]);
    STREAM(data[pawFL]);

    STREAM(data[legHL1]);
    STREAM(data[legHL2]); 
    STREAM(data[legHL3]);
    STREAM(data[pawHL]);

    STREAM(data[legFR1]);
    STREAM(data[legFR2]);
    STREAM(data[legFR3]);
    STREAM(data[pawFR]);

    STREAM(data[legHR1]);
    STREAM(data[legHR2]);
    STREAM(data[legHR3]);
    STREAM(data[pawHR]);

    STREAM(data[tailPan]);
    STREAM(data[tailTilt]);

    STREAM(data[wlan]);
    STREAM(data[backM]);
    STREAM(data[accelerationX]);
    STREAM(data[accelerationY]);
    STREAM(data[accelerationZ]);

    STREAM(data[head]);
    STREAM(data[headPsdFar]);
    STREAM(data[bodyPsd]);
///////////
    STREAM(refValue[neckTilt]);
    STREAM(refValue[headPan]);
    STREAM(refValue[headTilt]);

    STREAM(refValue[backR]);
    STREAM(refValue[backF]);
    STREAM(refValue[headPsdNear]);
    STREAM(refValue[mouth]);
    STREAM(refValue[chin]);

    STREAM(refValue[legFL1]); 
    STREAM(refValue[legFL2]); 
    STREAM(refValue[legFL3]);
    STREAM(refValue[pawFL]);

    STREAM(refValue[legHL1]);
    STREAM(refValue[legHL2]); 
    STREAM(refValue[legHL3]);
    STREAM(refValue[pawHL]);

    STREAM(refValue[legFR1]);
    STREAM(refValue[legFR2]);
    STREAM(refValue[legFR3]);
    STREAM(refValue[pawFR]);

    STREAM(refValue[legHR1]);
    STREAM(refValue[legHR2]);
    STREAM(refValue[legHR3]);
    STREAM(refValue[pawHR]);

    STREAM(refValue[tailPan]);
    STREAM(refValue[tailTilt]);

    STREAM(refValue[wlan]);
    STREAM(refValue[backM]);
    STREAM(refValue[accelerationX]);
    STREAM(refValue[accelerationY]);
    STREAM(refValue[accelerationZ]);

    STREAM(refValue[head]);
    STREAM(refValue[headPsdFar]);
    STREAM(refValue[bodyPsd]);

    STREAM(frameNumber);

    STREAM_REGISTER_FINISH();
  }
public:
  /**
  * constructs a SensorData.
  */ 
  SensorData();

  /**
  * deconstructs a SensorData.
  */
  ~SensorData();

  enum sensors 
  {
    // head: ERS-7
    neckTilt,
    headPan,
    headTilt,

    // ERS-210
    headBack, 
    headFront,
    psd, 
    mouth,
    chin,
    legFL1, legFL2, legFL3, pawFL,
    legHL1, legHL2, legHL3, pawHL,
    legFR1, legFR2, legFR3, pawFR,
    legHR1, legHR2, legHR3, pawHR,
    tailPan, tailTilt,
    thermo,
    back,
    accelerationX, accelerationY, accelerationZ,
    numOfSensor_ERS210,
    
    // ERS-7
    head = numOfSensor_ERS210,
    headPsdFar,
    bodyPsd,
    numOfSensor_ERS7,

    // synonyms
    headTilt210 = neckTilt,
    headPan210 = headPan,
    headRoll210 = headTilt,
    headPsdNear = psd,
    backF = headFront, 
    backM = back,
    backR = headBack,
    wlan = thermo
  };

  /** The sensor data value */
  long data[numOfSensor_ERS7];

  /** Sensor data reference values.
   * Only valid for joint sensors. */
  long refValue[numOfSensor_ERS7];

  /** The frame number of that sensor data. */
  unsigned long frameNumber; 

  void init();

  /** returns the name of a sensor */
  static const char* getSensorName(sensors sensor)
  {
    switch (sensor)
    {
    case neckTilt: return "neckTilt (headTilt210)";
    case headTilt: return "headTilt (headRoll210)";
    case headBack: return "head/backRear";
    case headFront: return "head/backFront";
    case psd: return "headPsd(Near)";
    case thermo: return "thermo/wlan";
    case back: return "back(Middle)";
    default: return getSensorNameERS7(sensor);
    }
  }

  /** returns the name of a sensor of the ERS-210 */
  static const char* getSensorNameERS210(sensors sensor)
  {
    switch (sensor)
    {
    case headTilt210: return "headTilt210";
    case headPan210: return "headPan210";
    case headRoll210: return "headRoll210";
    case headBack: return "headBack";
    case headFront: return "headFront";
    case psd: return "psd";
    case mouth: return "mouth";
    case chin: return "chin";
    case legFL1: return "legFL1";
    case legFL2: return "legFL2";
    case legFL3: return "legFL3";
    case pawFL: return "pawFL";
    case legHL1: return "legHL1";
    case legHL2: return "legHL2";
    case legHL3: return "legHL3";
    case pawHL: return "pawHL";
    case legFR1: return "legFR1";
    case legFR2: return "legFR2";
    case legFR3: return "legFR3";
    case pawFR: return "pawFR";
    case legHR1: return "legHR1";
    case legHR2: return "legHR2";
    case legHR3: return "legHR3";
    case pawHR: return "pawHR";
    case tailPan: return "tailPan";
    case tailTilt: return "tailTilt";
    case thermo: return "thermo";
    case back: return "back";
    case accelerationX: return "accelerationX";
    case accelerationY: return "accelerationY";
    case accelerationZ: return "accelerationZ";
    default: return "unknown sensor";
    }
  }

  /** returns the name of a sensor of the ERS-7 */
  static const char* getSensorNameERS7(sensors sensor)
  {
    switch (sensor)
    {
    case headPan: return "headPan";
    case headTilt: return "headTilt";
    case neckTilt: return "neckTilt";
    case backR: return "backRear";
    case backF: return "backFront";
    case headPsdNear: return "headPsdNear";
    case wlan: return "wlan";
    case backM: return "backMiddle";
    case head: return "head";
    case headPsdFar: return "headPsdFar";
    case bodyPsd: return "bodyPsd";
    default: return getSensorNameERS210(sensor);
    }
  }
};

/**
 * Streaming operator that writes a SensorData to a stream.
 * @param stream The stream to write on.
 * @param sensorData The SensorData object.
 * @return The stream.
 */ 
//Out& operator<<(Out& stream, const SensorData& sensorData);

/**
 * Streaming operator that reads a SensorData from a stream.
 * @param stream The stream to read from.
 * @param sensorData The SensorData object.
 * @return The stream.
 */ 
//In& operator>>(In& stream, SensorData& sensorData);

#endif //__SensorData_h_

---