Changeset 50 in flair-dev for trunk/include


Ignore:
Timestamp:
May 31, 2017, 3:54:26 PM (4 years ago)
Author:
Sanahuja Guillaume
Message:

doc

Location:
trunk/include
Files:
1 added
79 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/FlairCore/AhrsData.h

    r13 r50  
    121121  *
    122122  */
    123   void SetAngularRates(const Vector3D &angularRates);
     123  void SetAngularRates(const Vector3Df &angularRates);
    124124
    125125  /*!
     
    131131  *
    132132  */
    133   Vector3D GetAngularRates(void) const;
     133  Vector3Df GetAngularRates(void) const;
    134134
    135135  /*!
     
    143143  */
    144144  void GetQuaternionAndAngularRates(Quaternion &quaternion,
    145                                     Vector3D &angularRates) const;
     145                                    Vector3Df &angularRates) const;
    146146
    147147  /*!
     
    155155  */
    156156  void SetQuaternionAndAngularRates(const Quaternion &quaternion,
    157                                     const Vector3D &angularRates);
     157                                    const Vector3Df &angularRates);
    158158
    159159  const Type &GetDataType() const { return dataType; }
     
    182182  *
    183183  */
    184   Vector3D angularRates;
     184  Vector3Df angularRates;
    185185
    186186  Type dataType;
  • trunk/include/FlairCore/GpsData.h

    r30 r50  
    1919
    2020  class IODataElement;
    21   class Vector3D;
    2221
    2322/*! \class GpsData
     
    4241      size += UInt8Type.GetSize(); // FixQuality_t
    4342      size += 5*floatType.GetSize();//e,n,u,ve,vn
     43      size += 3*floatType.GetSize();//pdop,hdop,vdop
    4444      return size;
    4545    }
     
    6363    EastVelocity /*! east velocity*/,
    6464    NorthVelocity /*! north velocity*/,
     65    Pdop /* dilution of precision*/,
     66    Hdop /* horizontal dilution of precision*/,
     67    Vdop /* vertical dilution of precision*/,
    6568  } PlotableData_t;
    6669
     
    215218  */
    216219  void SetFixQuality(FixQuality_t fixQuality);
     220 
     221  /*!
     222  * \brief Get dilution of precision
     223  *
     224  * This method is mutex protected.
     225  *
     226  * \param pDop dilution of precision
     227  * \param hDop horizontal dilution of precision
     228  * \param vDop vertical dilution of precision
     229  *
     230  */
     231  void GetDop(float &pDop, float &hDop,float &vDop) const;
     232
     233  /*!
     234  * \brief Set dilution of precision
     235  *
     236  * This method is mutex protected.
     237  *
     238  * \param pDop dilution of precision
     239  * \param hDop horizontal dilution of precision
     240  * \param vDop vertical dilution of precision
     241  *
     242  */
     243  void SetDop(float pDop, float hDop,float vDop);
    217244
    218245  Type const &GetDataType() const { return dataType; }
     
    235262  uint8_t numberOfSatellites;
    236263  FixQuality_t fixQuality;
    237   float east,north,up,eastVelocity,northVelocity;
     264  float east,north,up,eastVelocity,northVelocity,pDop,hDop,vDop;
    238265};
    239266
  • trunk/include/FlairCore/I2cPort.h

    r13 r50  
    9595};
    9696} // end namespace core
    97 } // end namespace framework
     97} // end namespace flair
    9898
    9999#endif // I2CPORT_H
  • trunk/include/FlairCore/IODataElement.h

    r13 r50  
    5656
    5757} // end namespace core
    58 } // end namespace framework
     58} // end namespace flair
    5959
    6060#endif // IODATAELEMENT_H
  • trunk/include/FlairCore/IODevice.h

    r44 r50  
    110110  */
    111111  void OutputToShMem(bool enabled);
     112 
     113  /*!
     114  * \brief is device ready
     115  *
     116  * Use it check if a device is ready or not.
     117  * See also setIsReady.
     118  *
     119  * \return true if device is ready
     120  */
     121  bool IsReady(void) const;
    112122
    113123  // TODO: these 2 method should be pure virtual
     
    115125  virtual DataType const &GetOutputDataType() const;
    116126
    117         protected:
    118             /*!
    119             * \brief Process the childs of type IODevice, and log if needed
    120             *
    121             * This method must be called after computing datas;
    122             * generally at the end of the reimplemented UpdateFrom or after acquiring datas in case of a sensor. \n
    123             * It will call UpdateFrom methods of each child of type IODevice,
    124             * and log all datas (this IODevice and its childs)
    125             * if logging is enabled (see SetDataToLog(), AddDeviceToLog(),
    126             * FrameworkManager::StartLog and FrameworkManager::AddDeviceToLog). \n
    127             * If a thread is waiting on this IODevice (see Thread::WaitUpdate), it will be resumed.
    128             *
    129             * \param data data to process
    130             */
    131             void ProcessUpdate(io_data* data);
     127  protected:
     128    /*!
     129    * \brief Process the childs of type IODevice, and log if needed
     130    *
     131    * This method must be called after computing datas;
     132    * generally at the end of the reimplemented UpdateFrom or after acquiring datas in case of a sensor. \n
     133    * It will call UpdateFrom methods of each child of type IODevice,
     134    * and log all datas (this IODevice and its childs)
     135    * if logging is enabled (see SetDataToLog(), AddDeviceToLog(),
     136    * FrameworkManager::StartLog and FrameworkManager::AddDeviceToLog). \n
     137    * If a thread is waiting on this IODevice (see Thread::WaitUpdate), it will be resumed.
     138    *
     139    * \param data data to process
     140    */
     141    void ProcessUpdate(io_data* data);
     142   
     143    /*!
     144    * \brief set is ready
     145    *
     146    * Sets if the device is ready or not. By default the IODevice is not ready.\n
     147    * See also isReady.
     148    *
     149    * \param status status
     150    */
     151    void SetIsReady(bool status);
    132152
    133153private:
  • trunk/include/FlairCore/ImuData.h

    r13 r50  
    104104  *
    105105  */
    106   Vector3D GetRawAcc(void) const;
     106  Vector3Df GetRawAcc(void) const;
    107107
    108108  /*!
     
    114114  *
    115115  */
    116   Vector3D GetRawMag(void) const;
     116  Vector3Df GetRawMag(void) const;
    117117
    118118  /*!
     
    124124  *
    125125  */
    126   Vector3D GetRawGyr(void) const;
     126  Vector3Df GetRawGyr(void) const;
    127127
    128128  /*!
     
    136136  *
    137137  */
    138   void GetRawAccMagAndGyr(Vector3D &rawAcc, Vector3D &rawMag,
    139                           Vector3D &rawGyr) const;
     138  void GetRawAccMagAndGyr(Vector3Df &rawAcc, Vector3Df &rawMag,
     139                          Vector3Df &rawGyr) const;
    140140
    141141  /*!
     
    147147  *
    148148  */
    149   void SetRawAcc(const Vector3D &rawAcc);
     149  void SetRawAcc(const Vector3Df &rawAcc);
    150150
    151151  /*!
     
    157157  *
    158158  */
    159   void SetRawMag(const Vector3D &rawMag);
     159  void SetRawMag(const Vector3Df &rawMag);
    160160
    161161  /*!
     
    167167  *
    168168  */
    169   void SetRawGyr(const Vector3D &rawGyr);
     169  void SetRawGyr(const Vector3Df &rawGyr);
    170170
    171171  /*!
     
    179179  *
    180180  */
    181   void SetRawAccMagAndGyr(const Vector3D &rawAcc, const Vector3D &rawMag,
    182                           const Vector3D &rawGyr);
     181  void SetRawAccMagAndGyr(const Vector3Df &rawAcc, const Vector3Df &rawMag,
     182                          const Vector3Df &rawGyr);
    183183
    184184  Type const &GetDataType() const { return dataType; }
     
    199199  *
    200200  */
    201   Vector3D rawAcc;
     201  Vector3Df rawAcc;
    202202
    203203  /*!
     
    205205  *
    206206  */
    207   Vector3D rawGyr;
     207  Vector3Df rawGyr;
    208208
    209209  /*!
     
    211211  *
    212212  */
    213   Vector3D rawMag;
     213  Vector3Df rawMag;
    214214
    215215  void Queue(char **dst, const void *src, size_t size) const;
  • trunk/include/FlairCore/OneAxisRotation.h

    r13 r50  
    1515
    1616#include <GroupBox.h>
     17#include <Vector3D.h>
    1718
    1819class OneAxisRotation_impl;
     
    2425
    2526namespace core {
    26 class Vector3D;
    2727class Euler;
    2828class Quaternion;
     
    5757  * \brief Compute rotation
    5858  *
    59   * \param vector Vector3D to rotate
     59  * \param vector Vector3Df to rotate
    6060  */
    61   void ComputeRotation(core::Vector3D &vector) const;
     61  template <typename T> void ComputeRotation(core::Vector3D<T> &vector) const;
    6262
    6363  /*!
     
    8181  */
    8282  void ComputeRotation(core::RotationMatrix &matrix) const;
     83 
     84  /*!
     85  * \brief Get angle
     86  *
     87  * \return angle in radians
     88  */
     89  float GetAngle() const;
     90  int GetAxis() const;
    8391
    8492private:
  • trunk/include/FlairCore/Quaternion.h

    r13 r50  
    1313#define QUATERNION_H
    1414
     15#include <Vector3D.h>
     16
    1517namespace flair {
    1618namespace core {
    1719class Euler;
    18 class Vector3D;
    1920class RotationMatrix;
    2021
     
    6263  * \param logarithm output logarithm
    6364  */
    64   void GetLogarithm(Vector3D &logarithm);
     65  void GetLogarithm(Vector3Df &logarithm);
    6566
    6667  /*!
     
    7172  * \return output logarithm
    7273  */
    73   Vector3D GetLogarithm(void);
     74  Vector3Df GetLogarithm(void);
    7475
    7576  /*!
     
    9293  * \return derivative
    9394  */
    94   Quaternion GetDerivative(const Vector3D &angularSpeed) const;
     95  Quaternion GetDerivative(const Vector3Df &angularSpeed) const;
    9596
    9697  /*!
     
    99100  * \param w rotationonal speed
    100101  */
    101   void Derivate(const Vector3D &angularSpeed);
     102  void Derivate(const Vector3Df &angularSpeed);
    102103
    103104  /*!
  • trunk/include/FlairCore/SerialPort.h

    r13 r50  
    8585};
    8686} // end namespace core
    87 } // end namespace framework
     87} // end namespace flair
    8888
    8989#endif // SERIALPORT_H
  • trunk/include/FlairCore/SharedMem.h

    r13 r50  
    3232class SharedMem : public Object {
    3333public:
     34  enum class Type { mutex, producerConsumer };
    3435  /*!
    3536  * \brief Constructor
     
    4041  * \param name name
    4142  * \param size size of the shared memory
     43  * \param blockOnRead if true reading will block if nothing written
    4244  */
    43   SharedMem(const Object *parent, std::string name, size_t size);
     45  SharedMem(const Object *parent, std::string name, size_t size, Type type=Type::mutex);
    4446
    4547  /*!
     
    6567  void Read(char *buf, size_t size) const;
    6668
     69
     70  /*!
     71  * \brief This function should be called when reader starts (in case of a SharedMem of type producerConsumer)
     72  */
     73   void ReaderReady();
    6774private:
    6875  SharedMem_impl *pimpl_;
     76  Type type;
    6977};
    7078
  • trunk/include/FlairCore/Thread.h

    r13 r50  
    176176  */
    177177  bool IsSuspended(void) const;
     178 
     179  /*!
     180  * \brief Is the thread running?
     181  *
     182  * \return true if thread is running (call to Start). A suspended thread is running.
     183  *
     184  */
     185  bool IsRunning(void) const;
    178186
    179187  /*!
  • trunk/include/FlairCore/Vector2D.h

    r13 r50  
    2121* \brief Class defining a 2D vector
    2222*/
     23template <typename T>
    2324class Vector2D {
    2425public:
     
    3132  * \param y
    3233  */
    33   Vector2D(float x = 0, float y = 0);
     34  Vector2D(T x = 0, T y = 0);
    3435
    3536  /*!
     
    7374  * \param max maximum Vector2D value
    7475  */
    75   void Saturate(Vector2D min, Vector2D max);
     76  void Saturate(Vector2D<T> min, Vector2D<T> max);
    7677
    7778  /*!
     
    9293  * \param value saturation Vector2D value
    9394  */
    94   void Saturate(const Vector2D &value);
     95  void Saturate(const Vector2D<T> &value);
    9596
    9697  /*!
     
    106107  * \brief x
    107108  */
    108   float x;
     109  T x;
    109110
    110111  /*!
    111112  * \brief y
    112113  */
    113   float y;
     114  T y;
    114115
    115   Vector2D &operator=(const Vector2D &vector);
     116  template<typename S> Vector2D<T> &operator=(const Vector2D<S> &vector) {
     117    x = vector.x;
     118    y = vector.y;
     119    return (*this);
     120  }
     121  Vector2D<T> &operator+=(const Vector2D<T> &vector);
     122  Vector2D<T> &operator-=(const Vector2D<T> &vector);
    116123};
     124
     125typedef Vector2D<float> Vector2Df;
    117126
    118127/*! Add
     
    123132* \param vectorB vector
    124133*/
    125 Vector2D operator+(const Vector2D &vectorA, const Vector2D &vectorB);
     134template<typename T> Vector2D<T> operator+(const Vector2D<T> &vectorA, const Vector2D<T> &vectorB);
    126135
    127136/*! Substract
     
    132141* \param vectorB vector
    133142*/
    134 Vector2D operator-(const Vector2D &vectorA, const Vector2D &vectorB);
     143template<typename T> Vector2D<T> operator-(const Vector2D<T> &vectorA, const Vector2D<T> &vectorB);
     144
     145/*! Opposite
     146*
     147* \brief Opposite
     148*
     149* \param vectorA vector
     150*
     151* \return -vectorA
     152*/
     153template<typename T> Vector2D<T> operator-(const Vector2D<T> &vectorA);
    135154
    136155/*! Divid
     
    142161* \return vector/coefficient
    143162*/
    144 Vector2D operator/(const Vector2D &vector, float coeff);
     163template<typename T> Vector2D<T> operator/(const Vector2D<T> &vector, float coeff);
    145164
    146165/*! Multiply
     
    152171* \return coefficient*vector
    153172*/
    154 Vector2D operator*(const Vector2D &vector, float coeff);
     173template<typename T> Vector2D<T> operator*(const Vector2D<T> &vector, float coeff);
    155174
    156175/*! Multiply
     
    162181* \return coefficient*vector
    163182*/
    164 Vector2D operator*(float coeff, const Vector2D &vector);
     183template<typename T> Vector2D<T> operator*(float coeff, const Vector2D<T> &vector);
    165184
    166185} // end namespace core
  • trunk/include/FlairCore/Vector3D.h

    r13 r50  
    1515
    1616#include <stddef.h>
     17#include <Vector2D.h>
    1718
    1819namespace flair {
    1920namespace core {
    20 class Vector2D;
    2121class RotationMatrix;
    2222class Quaternion;
     
    2626* \brief Class defining a 3D vector
    2727*/
     28template <typename T>
    2829class Vector3D {
    2930public:
     
    3738  * \param z
    3839  */
    39   Vector3D(float x = 0, float y = 0, float z = 0);
     40  Vector3D(T x = 0, T y = 0, T z = 0);
    4041
    4142  /*!
     
    4849  * \brief x
    4950  */
    50   float x;
     51  T x;
    5152
    5253  /*!
    5354  * \brief y
    5455  */
    55   float y;
     56  T y;
    5657
    5758  /*!
    5859  * \brief z
    5960  */
    60   float z;
     61  T z;
    6162
    6263  /*!
     
    126127  * \param vector destination
    127128  */
    128   void To2Dxy(Vector2D &vector) const;
     129  void To2Dxy(Vector2D<T> &vector) const;
    129130
    130131  /*!
     
    135136  * \return destination
    136137  */
    137   Vector2D To2Dxy(void) const;
     138  Vector2D<T> To2Dxy(void) const;
    138139
    139140  /*!
     
    157158  * \param max maximum value
    158159  */
    159   void Saturate(const Vector3D &min, const Vector3D &max);
     160  void Saturate(const Vector3D<T> &min, const Vector3D<T> &max);
    160161
    161162  /*!
     
    176177  * \param value saturation Vector3D value
    177178  */
    178   void Saturate(const Vector3D &value);
     179  void Saturate(const Vector3D<T> &value);
    179180
    180181  /*!
     
    188189  void Saturate(float value);
    189190
    190   float &operator[](size_t idx);
    191   const float &operator[](size_t idx) const;
    192   Vector3D &operator=(const Vector3D &vector);
    193   Vector3D &operator+=(const Vector3D &vector);
    194   Vector3D &operator-=(const Vector3D &vector);
     191  T &operator[](size_t idx);
     192  const T &operator[](size_t idx) const;
     193  //Vector3D<T> &operator=(const Vector3D<T> &vector);
     194  template<typename S> Vector3D<T> &operator=(const Vector3D<S> &vector) {
     195    x = vector.x;
     196    y = vector.y;
     197    z = vector.z;
     198    return (*this);
     199  }
     200  Vector3D<T> &operator+=(const Vector3D<T> &vector);
     201  Vector3D<T> &operator-=(const Vector3D<T> &vector);
    195202
    196203private:
    197204};
    198205
     206typedef Vector3D<float> Vector3Df;
     207
    199208/*! Add
    200209*
     
    206215* \return vectorA+vectorB
    207216*/
    208 Vector3D operator+(const Vector3D &vectorA, const Vector3D &vectorB);
     217template<typename T> Vector3D<T> operator+(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB);
    209218
    210219/*! Substract
     
    217226* \return vectorA-vectorB
    218227*/
    219 Vector3D operator-(const Vector3D &vectorA, const Vector3D &vectorB);
     228template<typename T> Vector3D<T> operator-(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB);
    220229
    221230/*! Minus
     
    227236* \return -vector
    228237*/
    229 Vector3D operator-(const Vector3D &vector);
     238template<typename T> Vector3D<T> operator-(const Vector3D<T> &vector);
    230239
    231240/*! Divid
     
    238247* \return vector/coefficient
    239248*/
    240 Vector3D operator/(const Vector3D &vector, float coeff);
     249template<typename T> Vector3D<T> operator/(const Vector3D<T> &vector, float coeff);
    241250
    242251/*! Hadamard product
     
    249258* \return Hadamard product
    250259*/
    251 Vector3D operator*(const Vector3D &vectorA, const Vector3D &vectorB);
     260template<typename T> Vector3D<T> operator*(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB);
    252261
    253262/*! Multiply
     
    260269* \return coefficient*vector
    261270*/
    262 Vector3D operator*(const Vector3D &vector, float coeff);
     271template<typename T> Vector3D<T> operator*(const Vector3D<T> &vector, float coeff);
    263272
    264273/*! Multiply
     
    271280* \return coefficient*vector
    272281*/
    273 Vector3D operator*(float coeff, const Vector3D &vector);
     282template<typename T> Vector3D<T> operator*(float coeff, const Vector3D<T> &vector);
    274283
    275284/*! Cross product
     
    282291* \return cross product
    283292*/
    284 Vector3D CrossProduct(const Vector3D &vectorA, const Vector3D &vectorB);
     293template<typename T> Vector3D<T> CrossProduct(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB);
    285294
    286295/*! Dot product
     
    293302* \return dot product
    294303*/
    295 float DotProduct(const Vector3D &vectorA, const Vector3D &vectorB);
     304template<typename T> float DotProduct(const Vector3D<T> &vectorA, const Vector3D<T> &vectorB);
    296305
    297306} // end namespace core
  • trunk/include/FlairCore/Vector3DSpinBox.h

    r13 r50  
    4444  Vector3DSpinBox(const LayoutPosition *position, std::string name, double min,
    4545                  double max, double step, int decimals = 2,
    46                   core::Vector3D default_value = core::Vector3D(0, 0, 0));
     46                  core::Vector3Df default_value = core::Vector3Df(0, 0, 0));
    4747
    4848  /*!
     
    5757  * \return value
    5858  */
    59   core::Vector3D Value(void) const;
     59  core::Vector3Df Value(void) const;
    6060  // operator core::Vector3D() const;
    6161private:
     
    6868  void XmlEvent(void);
    6969
    70   core::Vector3D box_value;
     70  core::Vector3Df box_value;
    7171};
    7272
  • trunk/include/FlairCore/Vector3Ddata.h

    r13 r50  
    2626* User must manually use the io_data's Mutex to access to Vector3D values.
    2727*/
    28 class Vector3Ddata : public io_data, public Vector3D {
     28class Vector3Ddata : public io_data, public Vector3Df {
    2929public:
    3030  /*!
  • trunk/include/FlairCore/cvmatrix.h

    r13 r50  
    5555  * Construct an io_data representing a CvMat. \n
    5656  * It uses a cvmatrix_descriptor to get size and elements' names. \n
    57   * Names are used for graphs and logs.
     57  * Names are used for graphs and logs. \n
     58  * All values are initialized to 0.
    5859  *
    5960  * \param parent parent
    60   * \param descriptor matrix description
     61  * \param descriptor matrix description, it is safe to destroy it after calling this constructor
    6162  * \param type type of matrix elements
    6263  * \param name name
     
    7172  *
    7273  * Construct an io_data representing a CvMat. \n
    73   * Elements are unamed.
     74  * Elements are unamed. \n
     75  * All values are initialized to 0.
    7476  *
    7577  * \param parent parent
  • trunk/include/FlairFilter/Ahrs.h

    r32 r50  
    1919namespace flair {
    2020  namespace core {
    21     class Euler;
    22     class Vector3D;
    23     class ImuData;
    24     class Quaternion;
    2521    class AhrsData;
    2622  }
     
    174170  /*!
    175171  * \brief Get ahrs datas
    176   *
     172  *
     173  * Can be used by dervied class to fill core::AhrsData
     174  *
    177175  * \param ahrsData ahrs datas
    178176  */
  • trunk/include/FlairFilter/AhrsComplementaryFilter.h

    r16 r50  
    6666            bool isInit;
    6767            core::Quaternion QHat;
    68             core::Vector3D BHat;
     68            core::Vector3Df BHat;
    6969            gui::DoubleSpinBox *ka[3];
    7070            gui::DoubleSpinBox *kb[3];
  • trunk/include/FlairFilter/ButterworthLowPass.h

    r13 r50  
    4848  * \param name name
    4949  * \param order order of the filter
     50  * \param nbRow number of rows of input/output
     51  * \param nbCol number of cols of input/output
    5052  */
    5153  ButterworthLowPass(const IODevice *parent,
    5254                     const gui::LayoutPosition *position, std::string name,
    53                      int order);
     55                     uint32_t order,uint32_t nbRow=1,uint32_t nbCol=1);
    5456
    5557  /*!
     
    6567  * \param name name
    6668  * \param order order of the filter
     69  * \param nbRow number of rows of input/output
     70  * \param nbCol number of cols of input/output
    6771  */
    6872  ButterworthLowPass(const gui::LayoutPosition *position, std::string name,
    69                      int order);
     73                     uint32_t order,uint32_t nbRow,uint32_t nbCol);
    7074
    7175  /*!
  • trunk/include/FlairFilter/EulerDerivative.h

    r13 r50  
    4545  * IODevice::ProcessUpdate is called. \n
    4646  * The optional init_value parameters allow to specify
    47   * the size of the input datas and its inital values.
     47  * the size of the input datas and output inital values.
    4848  * If unspecified, a 1*1 size is used, and values are
    4949  * initialized with 0.
     
    5252  * \param position position to display settings
    5353  * \param name name
    54   * \param init_value initial value
     54  * \param init_value initial value, it is safe to destroy it after calling this constructor
    5555  */
    5656  EulerDerivative(const core::IODevice *parent,
  • trunk/include/FlairFilter/Gx3_25_ahrs.h

    r13 r50  
    3030  * \brief Constructor
    3131  *
    32   * Construct an Ahrs for 3dmgx3-25
     32  * Construct an Ahrs for 3dmgx3-25. It will be child of the FrameworkManager.
    3333  *
    34   * \param parent parent
    3534  * \param name name
    3635  * \param serialport Imu SerialPort
     
    3837  * \param priority priority of the Gx3_25_imu Thread
    3938  */
    40   Gx3_25_ahrs(const core::FrameworkManager *parent, std::string name,
     39  Gx3_25_ahrs(std::string name,
    4140              core::SerialPort *serialport,
    4241              sensor::Gx3_25_imu::Command_t command, uint8_t priority);
     
    4746  */
    4847  ~Gx3_25_ahrs();
    49 
    50   /*!
    51   * \brief Start Gx3_25_imu Thread
    52   *
    53   */
    54   void Start(void);
    5548
    5649private:
  • trunk/include/FlairFilter/LowPassFilter.h

    r13 r50  
    5252  * \param position position to display settings
    5353  * \param name name
    54   * \param init_value initial value
     54  * \param init_value initial value, it is safe to destroy it after calling this constructor
    5555  */
    5656  LowPassFilter(const core::IODevice *parent,
  • trunk/include/FlairFilter/SimuAhrs.h

    r13 r50  
    3030  * \brief Constructor
    3131  *
    32   * Construct a simulation Ahrs.
     32  * Construct a simulation Ahrs. It will be child of the FrameworkManager.
    3333  *
    34   * \param parent parent
    3534  * \param name name
    36   * \param dev_id number id of the simulated Ahrs
     35  * \param modelId Model id
     36  * \param deviceId Ahrs id of the Model
    3737  * \param priority priority of the SimuImu Thread
    3838  */
    39   SimuAhrs(const core::FrameworkManager *parent, std::string name,
    40            uint32_t dev_id, uint8_t priority);
     39  SimuAhrs(std::string name,
     40           uint32_t modelId,uint32_t deviceId, uint8_t priority);
    4141
    4242  /*!
     
    4545  */
    4646  ~SimuAhrs();
    47 
    48   /*!
    49  * \brief Start SimuImu Thread
    50  *
    51  */
    52   void Start(void);
    5347
    5448private:
  • trunk/include/FlairFilter/TrajectoryGenerator1D.h

    r13 r50  
    7272  * \brief Start trajectory
    7373  *
    74   * \param start_pos start position
    75   * \param end_pos end position
     74  * \param startPosition start position
     75  * \param endPosition end position
     76  * \param startVelocity start velocity, should be actual velocity. This value will be saturated
     77  * max velocity defined in GCS.
    7678  */
    77   void StartTraj(float start_pos, float end_pos);
     79  void StartTraj(float startPosition, float endPosition,float startVelocity=0);
    7880
    7981  /*!
  • trunk/include/FlairFilter/TrajectoryGenerator2DCircle.h

    r13 r50  
    1515
    1616#include <IODevice.h>
     17#include <Vector2D.h>
    1718
    1819namespace flair {
    1920namespace core {
    2021class cvmatrix;
    21 class Vector2D;
    2222}
    2323namespace gui {
     
    7272  * \param nb_lap number of laps, -1 for infinite
    7373  */
    74   void StartTraj(const core::Vector2D &start_pos, float nb_lap = -1);
     74  void StartTraj(const core::Vector2Df &start_pos, float nb_lap = -1);
    7575
    7676  /*!
     
    9393  * \param value center position
    9494  */
    95   void SetCenter(const core::Vector2D &value);
     95  void SetCenter(const core::Vector2Df &value);
    9696
    9797  /*!
     
    100100  * \param value center speed
    101101  */
    102   void SetCenterSpeed(const core::Vector2D &value);
     102  void SetCenterSpeed(const core::Vector2Df &value);
    103103
    104104  /*!
     
    117117  * \param point returned position
    118118  */
    119   void GetPosition(core::Vector2D &point) const;
     119  void GetPosition(core::Vector2Df &point) const;
    120120
    121121  /*!
     
    124124  * \param point returned speed
    125125  */
    126   void GetSpeed(core::Vector2D &point) const;
     126  void GetSpeed(core::Vector2Df &point) const;
    127127
    128128  /*!
  • trunk/include/FlairFilter/UavMultiplex.h

    r13 r50  
    1919namespace flair {
    2020namespace core {
    21 class FrameworkManager;
    2221class io_data;
    2322}
     
    4140  * \brief Constructor
    4241  *
    43   * Construct a uav multiplexing
    44   *
    45   * \param parent parent
     42  * Construct a uav multiplexing. It will be child of the FrameworkManager.
     43  *
    4644  * \param name name
    4745  */
    48   UavMultiplex(const core::FrameworkManager *parent, std::string name);
     46  UavMultiplex(std::string name);
    4947
    5048  /*!
  • trunk/include/FlairFilter/X4X8Multiplex.h

    r13 r50  
    5959  * \brief Constructor
    6060  *
    61   * Construct a X4 and X8 multiplexing
     61  * Construct a X4 and X8 multiplexing. It will be child of the FrameworkManager.
    6262  *
    63   * \param parent parent
    6463  * \param name name
    6564  * \param type type
    6665  */
    67   X4X8Multiplex(const core::FrameworkManager *parent, std::string name,
    68                 UavType_t type);
     66  X4X8Multiplex(std::string name, UavType_t type);
    6967
    7068  /*!
  • trunk/include/FlairMeta/HdsX8.h

    r44 r50  
    2424class HdsX8 : public Uav {
    2525public:
    26   HdsX8(std::string name,
     26  HdsX8(std::string name,std::string options="",
    2727        filter::UavMultiplex *multiplex = NULL);
    2828  ~HdsX8();
    2929  void StartSensors(void);
    3030        std::string GetDefaultVrpnAddress(void) const{return "192.168.147.197:3883";}
     31  bool isReadyToFly(void) const;
     32  virtual std::string GetType(void) const{return "hds_x8";}
    3133
    3234private:
  • trunk/include/FlairMeta/MetaDualShock3.h

    r25 r50  
    4040
    4141public:
    42   MetaDualShock3(core::FrameworkManager *parent, std::string name,
     42  MetaDualShock3(std::string name,
    4343                 sensor::TargetController *controller);
    4444  ~MetaDualShock3();
  • trunk/include/FlairMeta/MetaVrpnObject.h

    r44 r50  
    1515
    1616#include <VrpnObject.h>
    17 #include "io_data.h"
     17#include <io_data.h>
     18#include <Vector3D.h>
    1819
    1920namespace flair {
    20         namespace core {
    21                 class Vector3D;
    22                 class FloatType;
    23         }
    2421        namespace gui {
    2522                class DataPlot1D;
     
    5148  gui::DataPlot1D *VzPlot(void) const; // 1,2
    5249  gui::DataPlot2D *XyPlot(void) const;
    53   void GetSpeed(core::Vector3D &speed) const;
     50  void GetSpeed(core::Vector3Df &speed) const;
    5451
    5552private:
     
    6057  gui::DataPlot1D *vx_opti_plot, *vy_opti_plot, *vz_opti_plot;
    6158  gui::Tab *plot_tab;
    62   core::FloatType elementDataType;
    6359};
    6460} // end namespace meta
  • trunk/include/FlairMeta/SimuX4.h

    r44 r50  
    1818namespace flair {
    1919namespace meta {
     20 
    2021/*! \class SimuX4
    2122*
     
    2324*/
    2425class SimuX4 : public Uav {
    25 public:
    26   // simu_id: 0 if simulating only one UAV
    27   //>0 otherwise
    28   SimuX4(std::string name, int simu_id = 0,
    29          filter::UavMultiplex *multiplex = NULL);
    30   ~SimuX4();
    31   void StartSensors(void);
     26  public:
     27    // simu_id: 0 if simulating only one UAV
     28    //>0 otherwise
     29    SimuX4(std::string name, uint32_t simu_id = 0,std::string options="",
     30           filter::UavMultiplex *multiplex = NULL);
     31    ~SimuX4();
     32    void StartSensors(void);
     33    virtual std::string GetType(void) const{return "x4_simu";}
     34
     35  private:
     36    void ReadCameraResolutionOption(std::string options,std::string cameraName,uint16_t &camWidth,uint16_t &camHeight) const;
     37 
    3238};
    3339} // end namespace meta
  • trunk/include/FlairMeta/SimuX8.h

    r44 r50  
    2323*/
    2424class SimuX8 : public Uav {
    25 public:
    26   // simu_id: 0 if simulating only one UAV
    27   //>0 otherwise
    28   SimuX8(std::string name, int simu_id = 0,
    29          filter::UavMultiplex *multiplex = NULL);
    30   ~SimuX8();
    31   void StartSensors(void);
     25  public:
     26    // simu_id: 0 if simulating only one UAV
     27    //>0 otherwise
     28    SimuX8(std::string name, uint32_t simu_id = 0,std::string options="",
     29           filter::UavMultiplex *multiplex = NULL);
     30    ~SimuX8();
     31    void StartSensors(void);
     32    virtual std::string GetType(void) const{return "simu_x8";}
     33 
     34  private:
     35    void ReadCameraResolutionOption(std::string options,std::string cameraName,uint16_t &camWidth,uint16_t &camHeight) const;
     36 
    3237};
    3338} // end namespace meta
  • trunk/include/FlairMeta/Uav.h

    r44 r50  
    1515
    1616#include <Object.h>
     17#include <UsRangeFinder.h>
    1718
    1819namespace flair {
     
    6263  sensor::Camera *GetHorizontalCamera(void) const;
    6364        virtual std::string GetDefaultVrpnAddress(void) const{return "127.0.0.1:3883";}
     65  virtual bool isReadyToFly(void) const { return true;}
     66  virtual std::string GetType(void) const=0;
    6467
    6568protected:
    6669  void SetBldc(const actuator::Bldc *bldc);
    6770  void SetMultiplex(const filter::UavMultiplex *multiplex);
    68   void SetAhrs(const filter::Ahrs *ahrs);
     71  void SetAhrs(const filter::Ahrs *ahrs);//also sets imu (retrieved from the ahrs)
    6972  void SetUsRangeFinder(const sensor::UsRangeFinder *us);
    7073  void SetBatteryMonitor(const sensor::BatteryMonitor *battery);
  • trunk/include/FlairMeta/UavFactory.h

    r44 r50  
    2121#include <Uav.h>
    2222
    23 flair::meta::Uav *CreateUav(std::string name, std::string type,
     23flair::meta::Uav *CreateUav(std::string name, std::string type,std::string options="",
    2424                            flair::filter::UavMultiplex *multiplex = NULL);
    2525
    26 void RegisterUavCreator(flair::meta::Uav*(*func)(std::string name, std::string type,
    27                                    flair::filter::UavMultiplex *multiplex));
     26void RegisterUavCreator(flair::meta::Uav*(*func)(std::string,std::string,std::string,
     27                                   flair::filter::UavMultiplex*));
    2828#endif // UAVFACTORY
  • trunk/include/FlairMeta/UavStateMachine.h

    r44 r50  
    107107  const core::Quaternion &GetCurrentQuaternion(void) const;
    108108
    109   const core::Vector3D &GetCurrentAngularSpeed(void) const;
     109  const core::Vector3Df &GetCurrentAngularSpeed(void) const;
    110110
    111111        void Land(void);
     
    227227
    228228  const sensor::TargetController *GetJoystick(void) const;
     229  MetaDualShock3 *joy;
    229230
    230231  gui::Tab *setupLawTab, *graphLawTab;
     
    266267
    267268  core::Quaternion currentQuaternion;
    268   core::Vector3D currentAngularSpeed;
     269  core::Vector3Df currentAngularSpeed;
    269270
    270271  const core::AhrsData *ComputeReferenceOrientation(void);
     
    297298  filter::Pid *uYaw;
    298299  filter::PidThrust *uZ;
    299 
    300   MetaDualShock3 *joy;
    301300  filter::TrajectoryGenerator1D *altitudeTrajectory;
    302301};
  • trunk/include/FlairMeta/XAir.h

    r44 r50  
    2424class XAir : public Uav {
    2525public:
    26   XAir(std::string name,
     26  XAir(std::string name,std::string options="",
    2727       filter::UavMultiplex *multiplex = NULL);
    2828  ~XAir();
    2929  void StartSensors(void);
    3030        std::string GetDefaultVrpnAddress(void) const{return "192.168.147.197:3883";}
     31  bool isReadyToFly(void) const;
     32  virtual std::string GetType(void) const{return "xair";}
    3133
    3234private:
  • trunk/include/FlairSensorActuator/AfroBldc.h

    r13 r50  
    1818namespace flair {
    1919namespace core {
    20 class FrameworkManager;
    2120class I2cPort;
    2221}
  • trunk/include/FlairSensorActuator/BatteryMonitor.h

    r13 r50  
    2121class Label;
    2222class DoubleSpinBox;
     23class SpinBox;
    2324}
    2425}
     
    5657  *
    5758  */
    58   bool IsBatteryLow(void) const;
     59  bool IsBatteryLow(void);
    5960
    6061  /*!
     
    7778  float batteryvalue;
    7879  gui::DoubleSpinBox *battery_thresh;
     80  gui::SpinBox *thresholdTime;
    7981  gui::Label *battery;
     82  core::Time underThersholdStartTime;
     83  bool isUnderThershold;
    8084};
    8185} // end namespace sensor
  • trunk/include/FlairSensorActuator/BlCtrlV2.h

    r13 r50  
    1818namespace flair {
    1919namespace core {
    20 class FrameworkManager;
    2120class I2cPort;
    2221}
  • trunk/include/FlairSensorActuator/BlCtrlV2_x4_speed.h

    r13 r50  
    2525namespace core {
    2626class cvmatrix;
    27 class FrameworkManager;
    2827class I2cPort;
    2928}
     
    4443
    4544public:
    46   BlCtrlV2_x4_speed(core::FrameworkManager *parent, std::string name,
     45  BlCtrlV2_x4_speed(std::string name,
    4746                    core::I2cPort *i2cport, uint8_t base_address,
    4847                    uint8_t priority);
  • trunk/include/FlairSensorActuator/Bldc.h

    r13 r50  
    1919namespace flair {
    2020namespace core {
    21 class FrameworkManager;
    2221class cvmatrix;
    2322}
     
    186185};
    187186} // end namespace actuator
    188 } // end namespace framewor
     187} // end namespace flair
    189188#endif // BLDC_H
  • trunk/include/FlairSensorActuator/Camera.h

    r47 r50  
    4343  *
    4444  * Construct a Camera.
    45   *
    46   * \param parent parent
     45  * It will be child of the FrameworkManager.
     46        *
    4747  * \param name name
    4848  * \param width width
     
    5050  * \param format image format
    5151  */
    52   Camera(const core::FrameworkManager *parent, std::string name, uint16_t width,
     52  Camera(std::string name, uint16_t width,
    5353         uint16_t height, core::cvimage::Type::Format format);
    5454
  • trunk/include/FlairSensorActuator/EmulatedController.h

    r26 r50  
    2121namespace flair {
    2222    namespace core {
    23         class FrameworkManager;
    2423        class cvmatrix;
    2524    }
     
    3938    class EmulatedController : public TargetController {
    4039    public:
    41         EmulatedController(const core::FrameworkManager* parent,std::string name,uint8_t priority=0);
     40        EmulatedController(std::string name,uint8_t priority=0);
    4241        ~EmulatedController();
    4342        enum class ButtonType : uint16_t {
  • trunk/include/FlairSensorActuator/Gx3_25_imu.h

    r36 r50  
    5050  * \brief Constructor
    5151  *
    52   * Construct a Gx3_25_imu.
     52  * Construct a Gx3_25_imu. It will be child of the FrameworkManager.
    5353  *
    54   * \param parent parent
    5554  * \param name name
    5655  * \param serialport SerialPort
     
    5857  * \param priority priority of the Thread
    5958  */
    60   Gx3_25_imu(const core::FrameworkManager *parent, std::string name,
     59  Gx3_25_imu(std::string name,
    6160             core::SerialPort *serialport, Command_t command, uint8_t priority);
    6261
  • trunk/include/FlairSensorActuator/HokuyoUTM30Lx.h

    r13 r50  
    2424namespace core {
    2525class cvmatrix;
    26 class FrameworkManager;
    2726class SerialPort;
    2827class Mutex;
     
    4746 *
    4847 * Construct a Hokuyo UTM30-Lx.
    49  *
    50  * \param parent parent
     48 * It will be child of the FrameworkManage
     49 *
    5150 * \param name name
    5251 * \param serialport serialport
    5352 * \param priority priority of the Thread
    5453 */
    55   HokuyoUTM30Lx(const core::FrameworkManager *parent, std::string name,
     54  HokuyoUTM30Lx(std::string name,
    5655                core::SerialPort *serialport, uint8_t priority);
    5756  void getMesure(int startStep, int endStep, int clusterCount, int interval,
     
    168167};
    169168} // end namespace sensor
    170 } // end namespace framewor
     169} // end namespace flair
    171170#endif // HOKUYOUTM30LX_H
  • trunk/include/FlairSensorActuator/HostEthController.h

    r13 r50  
    2626namespace flair {
    2727namespace core {
    28 class FrameworkManager;
    2928class cvmatrix;
    3029class TcpSocket;
    31 class Socket;
     30class UdpSocket;
    3231class Mutex;
    3332}
     
    5655class HostEthController : public core::Thread, public core::IODevice {
    5756public:
    58   HostEthController(const core::FrameworkManager *parent, std::string name,
     57  HostEthController(std::string name,
    5958                    std::string address, int port, uint32_t period = 10,
    6059                    uint32_t _bitsPerAxis = 7, uint8_t priority = 0);
     
    6564  std::string controllerName;
    6665  core::TcpSocket *controlSocket; // connection to the target
    67   core::Socket *dataSocket;
     66  core::UdpSocket *dataSocket;
    6867  std::string targetAddress;
    6968  int targetPort;
  • trunk/include/FlairSensorActuator/Imu.h

    r36 r50  
    1515
    1616#include <IODevice.h>
     17#include <Vector3D.h>
    1718
    1819namespace flair {
     
    4950  *
    5051  * Construct an Imu.
     52        * It will be child of the FrameworkManager.
    5153  *
    52   * \param parent parent
    5354  * \param name name
    5455  */
    55   Imu(const core::FrameworkManager *parent, std::string name);
     56  Imu(std::string name);
    5657
    5758  /*!
     
    7172  */
    7273  ~Imu();
     74 
     75  /*!
     76  * \brief Get IMU datas
     77  *
     78  * \return ImuData
     79  */
     80  const core::ImuData *GetDatas(void) const;
     81
    7382
    7483  /*!
     
    121130
    122131  /*!
    123   * \brief UpdateImu
     132  * \brief ApplyRotation
    124133  *
    125   * The reimplemented class must call this function as soon as IMU datas are
    126   *available. \n
     134  * The reimplemented class must call this function to rotate IMU datas, before filling the ImuData. \n
    127135  * It handles the data rotation if it was defined.
    128136  *
     137  * \param vector vector to apply rotation to
    129138  */
    130   void UpdateImu();
     139  void ApplyRotation(core::Vector3Df& vector);
     140 
     141  /*!
     142  * \brief ApplyRotation
     143  *
     144  * The reimplemented class must call this function to rotate IMU datas, before filling the ImuData. \n
     145  * It handles the data rotation if it was defined.
     146  *
     147  * \param quaternion quaternion to apply rotation to
     148  */
     149  void ApplyRotation(core::Quaternion& quaternion);
    131150
    132151  /*!
    133152  * \brief Get imu datas
    134153  *
     154  * Can be used by dervied class to fill core::ImuData
     155  *
    135156  * \param imuData imu datas
    136157  */
  • trunk/include/FlairSensorActuator/LaserRangeFinder.h

    r13 r50  
    4242  *
    4343  * Construct a Laser Range Finder.
     44        * It will be child of the FrameworkManager
    4445  *
    45   * \param parent parent
    4646  * \param name name
    4747  */
    48   LaserRangeFinder(const core::FrameworkManager *parent, std::string name);
     48  LaserRangeFinder(std::string name);
    4949  /*!
    5050  * \brief Constructor
     
    129129};
    130130} // end namespace sensor
    131 } // end namespace framewor
     131} // end namespace flair
    132132#endif // LASERRANGEFINDER_H
  • trunk/include/FlairSensorActuator/Mb800.h

    r32 r50  
    1919namespace flair {
    2020namespace core {
    21 class FrameworkManager;
    2221class SerialPort;
    2322}
     
    3635  *
    3736  * Construct a Mb800.
    38   *
    39   * \param parent parent
     37  * It will be child of the FrameworkManager.
     38        *
    4039  * \param name name
    4140  * \param serialport serialport
     
    4342  * \param priority priority of the Thread
    4443  */
    45   Mb800(const core::FrameworkManager *parent, std::string name,
     44  Mb800(std::string name,
    4645        core::SerialPort *serialport, NmeaGps::NMEAFlags_t NMEAFlags,
    4746        uint8_t priority);
     
    7574};
    7675} // end namespace sensor
    77 } // end namespace framewor
     76} // end namespace flair
    7877#endif // MB800_H
  • trunk/include/FlairSensorActuator/NmeaGps.h

    r32 r50  
    1515
    1616#include <IODevice.h>
     17#include <Vector3D.h>
    1718#include <nmea/nmea.h>
    1819
     
    2122    class FrameworkManager;
    2223    class GeoCoordinate;
    23     class Vector3D;
    2424    class GpsData;
    2525  }
     
    5353    VTG = 0x02, /*!< VTG */
    5454    GST = 0x04, /*!< GST */
     55    GSA = 0x08, /*!< GSA */
    5556  };
    5657
     
    5960  *
    6061  * Construct a NmeaGps.
     62  *     It will be child of the FrameworkManager.
     63        *
     64  * \param name name
     65  * \param NMEAFlags NMEA sentances to enable
     66  */
     67  NmeaGps(std::string name,
     68      NMEAFlags_t NMEAFlags);
     69
     70  /*!
     71  * \brief Constructor
     72  *
     73  * Construct a NmeaGps. \n
     74  * This contructor must only be called for a simulated device.
    6175  *
    6276  * \param parent parent
    6377  * \param name name
    64   * \param NMEAFlags NMEA sentances to enable
    65   */
    66   NmeaGps(const core::FrameworkManager *parent, std::string name,
    67       NMEAFlags_t NMEAFlags);
    68 
    69   /*!
    70   * \brief Constructor
    71   *
    72   * Construct a NmeaGps. \n
    73   * This contructor must only be called for a simulated device.
    74   *
    75   * \param parent parent
    76   * \param name name
    7778  */
    7879  NmeaGps(const core::IODevice *parent, std::string name);
     
    168169  * \param point to store position
    169170  */
    170   void GetEnu(core::Vector3D *point);
     171  void GetEnu(core::Vector3Df *point);
    171172
    172173protected:
     
    222223};
    223224} // end namespace sensor
    224 } // end namespace framewor
     225} // end namespace flair
    225226#endif // NMEAGPS_H
  • trunk/include/FlairSensorActuator/Novatel.h

    r32 r50  
    3636  *
    3737  * Construct a Novatel.
     38        * It will be child of the FrameworkManager.
    3839  *
    39   * \param parent parent
    4040  * \param name name
    4141  * \param serialport serialport
     
    4343  * \param priority priority of the Thread
    4444  */
    45   Novatel(const core::FrameworkManager *parent, std::string name,
     45  Novatel(std::string name,
    4646          core::SerialPort *serialport, NmeaGps::NMEAFlags_t NMEAFlags,
    4747          uint8_t priority);
     
    7575};
    7676} // end namespace sensor
    77 } // end namespace framewor
     77} // end namespace flair
    7878#endif // Novatel_H
  • trunk/include/FlairSensorActuator/Ps3Eye.h

    r13 r50  
    1717
    1818namespace flair {
    19 namespace core {
    20 class cvimage;
    21 class FrameworkManager;
    22 }
    23 namespace gui {
    24 class GridLayout;
    25 class DoubleSpinBox;
    26 class CheckBox;
    27 }
    28 }
    29 
    30 namespace flair {
    3119namespace sensor {
    3220/*! \class Ps3Eye
     
    4129  *
    4230  * Construct a Ps3Eye.
     31        * It will be child of the FrameworkManager.
    4332  *
    44   * \param parent parent
    4533  * \param name name
    4634  * \param camera_index index of the camera, ie /dev/videox
    4735  * \param priority priority of the Thread
    4836  */
    49   Ps3Eye(const core::FrameworkManager *parent, std::string name,
     37  Ps3Eye(std::string name,
    5038         int camera_index, uint8_t priority);
    5139
  • trunk/include/FlairSensorActuator/RadioReceiver.h

    r13 r50  
    1919namespace flair {
    2020namespace core {
    21 class FrameworkManager;
    2221class cvmatrix;
    2322}
     
    4140  *
    4241  * Construct a RadioReceiver.
     42        * It will be child of the FrameworkManager.
    4343  *
    44   * \param parent parent
    4544  * \param name name
    4645  * \param nb_channels number of supported channels
    4746  */
    48   RadioReceiver(const core::FrameworkManager *parent, std::string name,
     47  RadioReceiver(std::string name,
    4948                unsigned int nb_channels);
    5049
  • trunk/include/FlairSensorActuator/SimuBldc.h

    r13 r50  
    4646  * \param name name
    4747  * \param motors_count number of motors
    48   * \param dev_id device id
     48  * \param modelId Model id
     49  * \param deviceId Bldc id of the Model
    4950  */
    5051  SimuBldc(const core::IODevice *parent, gui::Layout *layout, std::string name,
    51            uint8_t motors_count, uint32_t dev_id);
     52           uint8_t motors_count, uint32_t modelId,uint32_t deviceId);
    5253
    5354  /*!
     
    5960  * \param name name
    6061  * \param motors_count number of motors
    61   * \param dev_id device id
     62  * \param modelId Model id
     63  * \param deviceId Bldc id of the Model
    6264  */
    6365  SimuBldc(const core::Object *parent, std::string name, uint8_t motors_count,
    64            uint32_t dev_id);
     66           uint32_t modelId,uint32_t deviceId);
    6567
    6668  /*!
     
    107109  */
    108110  void SetMotors(float *value);
    109 
     111 
     112  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    110113  core::SharedMem *shmem;
    111114  gui::DoubleSpinBox *k;
  • trunk/include/FlairSensorActuator/SimuCamera.h

    r13 r50  
    1919
    2020namespace flair {
    21 namespace core {
    22 class SharedMem;
    23 }
    24 namespace gui {
    25 class SpinBox;
    26 }
     21  namespace core {
     22    class SharedMem;
     23  }
    2724}
    2825
     
    3936  *
    4037  * Construct a SimuCamera. Control part.
     38        * It will be child of the FrameworkManager.
    4139  *
    42   * \param parent parent
    4340  * \param name name
    4441  * \param width width
    4542  * \param height height
    4643  * \param channels number of channels
    47   * \param dev_id device id
     44  * \param modelId Model id
     45  * \param deviceId Camera id of the Model
    4846  * \param priority priority of the Thread
    4947  */
    50   SimuCamera(const core::FrameworkManager *parent, std::string name,
    51              uint16_t width, uint16_t height, uint8_t channels, uint32_t dev_id,
     48  SimuCamera(std::string name,
     49             uint16_t width, uint16_t height, uint8_t channels, uint32_t modelId,uint32_t deviceId,
    5250             uint8_t priority);
    5351
     
    6361  * \param height height
    6462  * \param channels number of channels
    65   * \param dev_id device id
     63  * \param modelId Model id
     64  * \param deviceId Camera id of the Model
    6665  */
    6766  SimuCamera(const core::IODevice *parent, std::string name, uint16_t width,
    68              uint16_t height, uint8_t channels, uint32_t dev_id);
     67             uint16_t height, uint8_t channels, uint32_t modelId,uint32_t deviceId);
    6968
    7069  /*!
     
    9897  */
    9998  void UpdateFrom(const core::io_data *data){};
     99 
     100  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    100101
    101   gui::SpinBox *data_rate;
    102102  size_t buf_size;
    103   IplImage *img;
     103  char* shmemReadBuf;
    104104};
    105105} // end namespace sensor
  • trunk/include/FlairSensorActuator/SimuGps.h

    r34 r50  
    1919namespace flair {
    2020  namespace core {
    21     class FrameworkManager;
    2221    class SharedMem;
    2322  }
     
    4039  *
    4140  * Construct a simulation GPS. Control part.
    42   *
    43   * \param parent parent
     41  * It will be child of the FrameworkManager.
     42        *
    4443  * \param name name
    4544  * \param NMEAFlags NMEA sentances to enable
    46   * \param deviceId device id
     45  * \param modelId Model id
     46  * \param deviceId Gps id of the Model
    4747  * \param priority priority of the Thread
    4848  */
    49   SimuGps(const core::FrameworkManager *parent, std::string name,
    50           NmeaGps::NMEAFlags_t NMEAFlags, uint32_t deviceId,uint8_t priority);
     49  SimuGps(std::string name,
     50          NmeaGps::NMEAFlags_t NMEAFlags, uint32_t modelId,uint32_t deviceId,uint8_t priority);
    5151
    5252  /*!
     
    5858  * \param parent parent
    5959  * \param name name
    60   * \param deviceId device id
     60  * \param modelId Model id
     61  * \param deviceId Gps id of the Model
    6162  */
    62   SimuGps(const core::IODevice *parent, std::string name, uint32_t deviceId);
     63  SimuGps(const core::IODevice *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    6364
    6465  /*!
     
    9394    float vn;
    9495  } gps_states_t;
     96 
     97  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    9598
    9699  core::SharedMem *shmem;
     
    99102};
    100103} // end namespace sensor
    101 } // end namespace framewor
     104} // end namespace flair
    102105#endif // SIMUGPS_H
  • trunk/include/FlairSensorActuator/SimuImu.h

    r32 r50  
    3939  *
    4040  * Construct a SimuImu. Control part.
     41        * It will be child of the FrameworkManager.
    4142  *
    42   * \param parent parent
    4343  * \param name name
    44   * \param dev_id device id
     44  * \param modelId Model id
     45  * \param deviceId Imu id of the Model
    4546  * \param priority priority of the Thread
    4647  */
    47   SimuImu(const core::FrameworkManager *parent, std::string name,
    48           uint32_t dev_id, uint8_t priority);
     48  SimuImu(std::string name,
     49          uint32_t modelId,uint32_t deviceId, uint8_t priority);
    4950
    5051  /*!
     
    5657  * \param parent parent
    5758  * \param name name
    58   * \param dev_id device id
     59  * \param modelId Model id
     60  * \param deviceId Imu id of the Model
    5961  */
    60   SimuImu(const core::IODevice *parent, std::string name, uint32_t dev_id);
     62  SimuImu(const core::IODevice *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    6163
    6264  /*!
     
    9395    float wz;
    9496  } imu_states_t;
     97 
     98  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    9599
    96100  gui::SpinBox *dataRate;
  • trunk/include/FlairSensorActuator/SimuLaser.h

    r13 r50  
    3838  *
    3939  * Construct a SimuUs. Control part.
     40        * It will be child of the FrameworkManager.
    4041  *
    41   * \param parent parent
    4242  * \param name name
    43   * \param dev_id device id
     43  * \param modelId Model id
     44  * \param deviceId LaserRangeFinder id of the Model
    4445  * \param priority priority of the Thread
    4546  */
    46   SimuLaser(const core::FrameworkManager *parent, std::string name,
    47             uint32_t dev_id, uint8_t priority);
     47  SimuLaser(std::string name,
     48            uint32_t modelId,uint32_t deviceId, uint8_t priority);
    4849
    4950  /*!
     
    5556  * \param parent parent
    5657  * \param name name
    57   * \param dev_id device id
     58  * \param modelId Model id
     59  * \param deviceId LaserRangeFinder id of the Model
    5860  */
    59   SimuLaser(const core::IODevice *parent, std::string name, uint32_t dev_id);
     61  SimuLaser(const core::IODevice *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    6062
    6163  /*!
     
    8991  */
    9092  void Run(void);
    91 
     93 
     94  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    9295  gui::SpinBox *data_rate;
    9396};
  • trunk/include/FlairSensorActuator/SimuUs.h

    r13 r50  
    3838  *
    3939  * Construct a SimuUs. Control part.
     40        * It will be child of the FrameworkManager.
    4041  *
    41   * \param parent parent
    4242  * \param name name
    43   * \param dev_id device id
     43  * \param modelId Model id
     44  * \param deviceId UsRangeFinder id of the Model
    4445  * \param priority priority of the Thread
    4546  */
    46   SimuUs(const core::FrameworkManager *parent, std::string name,
    47          uint32_t dev_id, uint8_t priority);
     47  SimuUs(std::string name,
     48         uint32_t modelId,uint32_t deviceId, uint8_t priority);
    4849
    4950  /*!
     
    5556  * \param parent parent
    5657  * \param name name
    57   * \param dev_id device id
     58  * \param modelId Model id
     59  * \param deviceId UsRangeFinder id of the Model
    5860  */
    59   SimuUs(const core::IODevice *parent, std::string name, uint32_t dev_id);
     61  SimuUs(const core::IODevice *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    6062
    6163  /*!
     
    8991  */
    9092  void Run(void);
    91 
     93 
     94  std::string ShMemName(uint32_t modelId,uint32_t deviceId);
    9295  gui::SpinBox *data_rate;
    9396};
  • trunk/include/FlairSensorActuator/Srf08.h

    r32 r50  
    1919namespace flair {
    2020namespace core {
    21 class FrameworkManager;
    2221class I2cPort;
    2322}
    2423namespace gui {
    2524class SpinBox;
    26 ;
    2725}
    2826}
     
    4139  *
    4240  * Construct a SRF08 sensor
     41        * It will be child of the FrameworkManager.
    4342  *
    44   * \param parent parent
    4543  * \param name name
    4644  * \param i2cport i2c port
     
    4846  * \param priority priority of the Thread
    4947  */
    50   Srf08(const core::FrameworkManager *parent, std::string name,
     48  Srf08(std::string name,
    5149        core::I2cPort *i2cport, uint16_t address, uint8_t priority);
    5250
  • trunk/include/FlairSensorActuator/TargetController.h

    r13 r50  
    4949class TargetController : public core::Thread, public core::IODevice {
    5050public:
    51   TargetController(const core::FrameworkManager *parent, std::string name,
    52                    uint8_t priority = 0);
     51  TargetController(std::string name,uint8_t priority = 0);
    5352  ~TargetController();
    5453  // void DrawUserInterface();
  • trunk/include/FlairSensorActuator/TargetEthController.h

    r25 r50  
    2929class cvmatrix;
    3030class TcpSocket;
    31 class Socket;
     31class UdpSocket;
    3232}
    3333namespace gui {
     
    4747class TargetEthController : public TargetController {
    4848public:
    49   TargetEthController(const core::FrameworkManager *parent, std::string name,
     49  TargetEthController(std::string name,
    5050                      uint16_t port, uint8_t priority = 0);
    5151  ~TargetEthController();
     
    7878  int listeningPort;
    7979  core::TcpSocket *controlSocket = NULL;
    80   core::Socket *dataSocket;
     80  core::UdpSocket *dataSocket;
    8181  std::string *axisName = NULL;
    8282  std::string *buttonName = NULL;
  • trunk/include/FlairSensorActuator/UsRangeFinder.h

    r13 r50  
    4444  *
    4545  * Construct a UsRangeFinder. Control part.
    46   *
    47   * \param parent parent
     46        * It will be child of the FrameworkManager.
     47        *
    4848  * \param name name
    4949  */
    50   UsRangeFinder(const core::FrameworkManager *parent, std::string name);
     50  UsRangeFinder(std::string name);
    5151
    5252  /*!
  • trunk/include/FlairSensorActuator/V4LCamera.h

    r13 r50  
    2121namespace core {
    2222class cvimage;
    23 class FrameworkManager;
    2423}
    2524namespace gui {
    26 class GridLayout;
    2725class DoubleSpinBox;
    2826class CheckBox;
     
    4341  *
    4442  * Construct a Camera.
     43        * It will be child of the FrameworkManager.
    4544  *
    46   * \param parent parent
    4745  * \param name name
    4846  * \param camera_index camera index
     
    5250  * \param priority priority of the Thread
    5351  */
    54   V4LCamera(const core::FrameworkManager *parent, std::string name,
     52  V4LCamera(std::string name,
    5553            uint8_t camera_index, uint16_t width, uint16_t height,
    5654            core::cvimage::Type::Format format, uint8_t priority);
     
    6159  */
    6260  ~V4LCamera();
     61 
     62    //hack for ps3eye in hds uav
     63  //TODO: put this in ps3eye class
     64  bool HasProblems(void);
    6365
    6466protected:
     
    118120  */
    119121  virtual void SetContrast(float value);
    120 
     122 
    121123private:
    122124  /*!
     
    140142
    141143  gui::Tab *sensor_tab;
    142   gui::DoubleSpinBox *bright, *exposure, *gain, *contrast, *hue, *sharpness,
    143       *sat;
     144  gui::DoubleSpinBox *bright, *exposure, *gain, *contrast, *hue, *sharpness,*sat;
    144145  gui::CheckBox *autogain, *awb, *autoexposure;
    145146  gui::Label *fps;
     147  bool hasProblems;
    146148};
    147149} // end namespace sensor
  • trunk/include/FlairSensorActuator/VrpnClient.h

    r44 r50  
    4949  * \param name name
    5050  * \param address server address
    51   * \param us_period Thread period in us
    5251  * \param priority priority of the Thread
    5352  */
    5453  VrpnClient(std::string name,
    55              std::string address, uint16_t us_period, uint8_t priority);
     54             std::string address, uint8_t priority);
    5655
    5756  /*!
  • trunk/include/FlairSensorActuator/VrpnObject.h

    r44 r50  
    1616
    1717#include <IODevice.h>
     18#include <Vector3D.h>
    1819#include <stdint.h>
    1920
     
    2122        namespace core {
    2223                class cvmatrix;
    23                 class Vector3D;
    24                 class Euler;
    2524                class Quaternion;
    2625        }
     
    101100
    102101  /*!
    103   * \brief Get Euler angles
    104   *
    105   * \param euler output datas
    106   */
    107   void GetEuler(core::Euler &euler) const;
    108 
    109   /*!
    110102  * \brief Get Quaternion
    111103  *
     
    118110  * \param point output datas
    119111  */
    120   void GetPosition(core::Vector3D &point) const;
     112  void GetPosition(core::Vector3Df &point) const;
    121113
    122114  /*!
     
    124116  *
    125117  * Matrix is of type float and as follows: \n
    126   * (0,0) roll (rad) \n
    127   * (1,0) pitch (rad) \n
    128   * (2,0) yaw (rad) \n
    129   * (3,0) x \n
    130   * (4,0) y \n
    131   * (5,0) z \n
     118  * (0,0) q0 \n
     119  * (1,0) q1 \n
     120  * (2,0) q2 \n
     121        * (3,0) q3 \n
     122  * (4,0) x \n
     123  * (5,0) y \n
     124  * (6,0) z \n
    132125  *
    133   * \return Output metrix
     126  * \return Output matrix
    134127  */
    135128  core::cvmatrix *Output(void) const;
     
    138131  * \brief State matrix
    139132  *
     133        * Used for plotting on ground station. \n
    140134  * Matrix is of type float and as follows: \n
    141135  * (0,0) roll (deg) \n
     
    143137  * (2,0) yaw (deg) \n
    144138  *
    145   * \return State metrix
     139  * \return State matrix
    146140  */
    147141  core::cvmatrix *State(void) const;
     
    178172  void UpdateFrom(const core::io_data *data){};
    179173
    180   void mainloop(void);
    181174  class VrpnObject_impl *pimpl_;
    182175};
  • trunk/include/FlairSimulator/Castle.h

    r13 r50  
    2323class Castle : public Gui {
    2424public:
    25   Castle(const flair::simulator::Simulator *parent, int app_width,
     25  Castle(int app_width,
    2626         int app_height, int scene_width, int scene_height,
    2727         std::string media_path);
  • trunk/include/FlairSimulator/FixedCamera.h

    r44 r50  
    2626class FixedCamera : public VisualizationCamera {
    2727public:
    28   FixedCamera(std::string name,core::Vector3D position,core::Vector3D lookat=core::Vector3D(0,0,0),float rotateSpeed = -3.0f, float zoomSpeed = .05f);
     28  FixedCamera(std::string name,core::Vector3Df position,core::Vector3Df lookat=core::Vector3Df(0,0,0),float rotateSpeed = -3.0f, float zoomSpeed = .05f);
    2929  ~FixedCamera();
    3030
  • trunk/include/FlairSimulator/Gui.h

    r34 r50  
    1919
    2020#include <Object.h>
     21#include <Vector3D.h>
    2122#include <EDriverTypes.h>
    2223#include <vector3d.h>
     
    3637namespace core {
    3738class Object;
    38 class Vector3D;
    3939class Euler;
    4040class Quaternion;
     
    4848namespace flair {
    4949namespace simulator {
    50 class Simulator;
    5150
    52 class Gui : public core::Object {
     51class Gui: public core::Object {
    5352  friend class ::Simulator_impl;
    5453  friend class VisualizationCamera;
    5554
    5655public:
    57   Gui(const Simulator *parent, std::string name, int app_width, int app_height,
     56  Gui(std::string name, int app_width, int app_height,
    5857      int scene_width, int scene_height, std::string media_path,
    5958      irr::video::E_DRIVER_TYPE driver_type = irr::video::EDT_OPENGL);
     
    126125* \return vector in irrlicht coordinates
    127126*/
    128 irr::core::vector3df ToIrrlichtCoordinates(core::Vector3D vect);
     127template<typename T>  irr::core::vector3df ToIrrlichtCoordinates(core::Vector3D<T> vect);
    129128
    130129/*!
     
    137136* \return vector in simulator coordinates
    138137*/
    139 core::Vector3D ToSimulatorCoordinates(irr::core::vector3df vect);
     138core::Vector3Df ToSimulatorCoordinates(irr::core::vector3df vect);
    140139
    141140/*!
  • trunk/include/FlairSimulator/Man.h

    r13 r50  
    3434namespace flair {
    3535namespace simulator {
    36 class Simulator;
    3736
    3837class Man : private Model {
    3938public:
    40   Man(const Simulator *parent, std::string name);
     39  Man(std::string name,uint32_t modelId);
    4140  ~Man();
    4241
  • trunk/include/FlairSimulator/Model.h

    r34 r50  
    5151namespace flair {
    5252namespace simulator {
    53 class Simulator;
    5453class FollowMeCamera;
    5554
     
    6564
    6665public:
    67   Model(const Simulator *parent, std::string name);
     66  Model(std::string name,uint32_t modelId);
    6867  virtual ~Model();
    6968
    7069  typedef struct simu_state {
    7170    core::Quaternion Quat;
    72     core::Vector3D W;
    73     core::Vector3D Pos;
    74     core::Vector3D Vel;
     71    core::Vector3Df W;
     72    core::Vector3D<double> Pos;
     73    core::Vector3D<double> Vel;
    7574  } simu_state_t;
    7675
     
    9392#endif
    9493  gui::TabWidget *GetTabWidget(void) const;
     94  int GetId(void) const;
    9595
    9696protected:
    9797  DiscreteTimeVariable<simu_state_t, 3> state;
    98   float dT(void) const;
     98  double dT(void) const;
    9999  virtual void CalcModel(void) = 0;
    100100#ifdef GL
  • trunk/include/FlairSimulator/Parser.h

    r34 r50  
    1919
    2020#include <Gui.h>
     21#include <Vector3D.h>
    2122#include <libxml/parser.h>
    2223#include <libxml/tree.h>
    23 
    24 namespace flair {
    25   namespace core {
    26     class Vector3D;
    27   }
    28 }
     24#include <SColor.h>
    2925
    3026namespace flair {
     
    3834  */
    3935public:
    40   Parser(Simulator *parent, int app_width, int app_height, int scene_width,
     36  Parser(int app_width, int app_height, int scene_width,
    4137         int scene_height, std::string media_path, std::string xmlFile);
    4238  ~Parser();
     
    4541  xmlDoc *doc;
    4642  std::string media_path;
    47   Simulator *parent;
    4843  void processElements(xmlNode *a_node);
    4944  void processObjects(xmlNode *a_node);
    5045  void processParams(xmlNode *a_node);
     46        irr::video::SColor getScolor(xmlNode *mesh_node);
    5147  irr::core::vector3df getMeshVect(xmlNode *mesh_node, xmlChar *param);
    5248  irr::core::vector3df getSceneVect(xmlNode *mesh_node, xmlChar *param,
    5349                                    bool isScale = false);
    54   core::Vector3D getMeshVector3D(xmlNode *mesh_node, xmlChar *param);
     50  core::Vector3Df getMeshVector3D(xmlNode *mesh_node, xmlChar *param);
    5551};
    5652}
  • trunk/include/FlairSimulator/SimuCameraGL.h

    r13 r50  
    5151  // top left origin
    5252  SimuCameraGL(const simulator::Model *parent, std::string name, int width,
    53                int height, int x, int y, int dev_id);
     53               int height, int x, int y, uint32_t modelId,uint32_t deviceId);
    5454  ~SimuCameraGL();
    5555  //! Sets the value of the near clipping plane. (default: 1.0f)
     
    6767                                  irr::scene::ISceneManager *newManager = 0);
    6868  void getImage(void);
    69   void putImage(char *pixels);
     69  void putImage(char *pixels,core::Time imageTime);
    7070  irr::scene::ICameraSceneNode *camera;
    7171  irr::scene::ISceneManager *smgr;
  • trunk/include/FlairSimulator/SimuLaserGL.h

    r13 r50  
    3838class SimuLaserGL : public SimuLaser, public SensorGL {
    3939public:
    40   SimuLaserGL(const simulator::Model *parent, std::string name, int dev_id);
     40  SimuLaserGL(const simulator::Model *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    4141  ~SimuLaserGL();
    4242
  • trunk/include/FlairSimulator/SimuUsGL.h

    r13 r50  
    3838class SimuUsGL : public SimuUs, public SensorGL {
    3939public:
    40   SimuUsGL(const simulator::Model *parent, std::string name, int dev_id);
     40  SimuUsGL(const simulator::Model *parent, std::string name, uint32_t modelId,uint32_t deviceId);
    4141  ~SimuUsGL();
    4242
  • trunk/include/FlairSimulator/Simulator.h

    r13 r50  
    1919
    2020#include <FrameworkManager.h>
     21#include <Vector3D.h>
    2122#include <stdint.h>
    2223
    2324class Simulator_impl;
     25class Model_impl;
    2426
    2527namespace flair {
    2628namespace core {
    2729class Quaternion;
    28 class Vector3D;
    2930}
    3031}
     
    3637
    3738class Simulator : public core::FrameworkManager {
    38   friend class Model;
     39  friend class ::Model_impl;
    3940  friend class Gui;
    4041  friend class GenericObject;
     
    5253  // coordinate, around z axis
    5354  core::Quaternion ToVRPNReference(core::Quaternion quat_in);
    54   core::Vector3D ToVRPNReference(core::Vector3D point_in);
     55  core::Vector3D<double> ToVRPNReference(core::Vector3D<double> point_in);
    5556
    5657private:
  • trunk/include/FlairSimulator/X4.h

    r34 r50  
    1919
    2020#include <Model.h>
    21 #include <stdint.h>
    22 #include <stdio.h>
    2321
    2422namespace flair {
     
    3432}
    3533
    36 #ifdef GL
    37 namespace irr {
    38 namespace scene {
    39 class IMesh;
    40 }
    41 }
    42 #endif
    43 
    4434namespace flair {
    4535namespace simulator {
    46 class Simulator;
    4736class Blade;
    48 class MeshSceneNode;
    4937
    5038class X4 : public Model {
    5139public:
    52   X4(const Simulator *parent, std::string name, int dev_id);
     40  X4(std::string name, uint32_t modelId);
    5341  ~X4();
    5442#ifdef GL
     
    5745
    5846protected:
    59   irr::scene::IMesh *red_arm, *black_arm, *motor;
    60   MeshSceneNode *fl_arm, *fr_arm, *rl_arm, *rr_arm;
    61   MeshSceneNode *fl_motor, *fr_motor, *rl_motor, *rr_motor;
    6247  Blade *fl_blade, *fr_blade, *rl_blade, *rr_blade;
    6348  core::Mutex *motor_speed_mutex;
  • trunk/include/FlairSimulator/X8.h

    r34 r50  
    1919
    2020#include <Model.h>
    21 #include <stdint.h>
    2221
    2322namespace flair {
     
    3332}
    3433
    35 #ifdef GL
    36 namespace irr {
    37 namespace scene {
    38 class IMesh;
    39 }
    40 }
    41 #endif
    42 
    4334namespace flair {
    4435namespace simulator {
    45 class Simulator;
    4636class Blade;
    47 class MeshSceneNode;
    4837
    4938class X8 : public Model {
    5039public:
    51   X8(const Simulator *parent, std::string name, int dev_id);
     40  X8(std::string name, uint32_t modelId);
    5241  ~X8();
    5342  virtual void Draw(void);
     
    5645protected:
    5746#ifdef GL
    58   irr::scene::IMesh *red_arm, *black_arm, *motor;
    59   MeshSceneNode *fl_arm, *fr_arm, *rl_arm, *rr_arm;
    60   MeshSceneNode *tfl_motor, *tfr_motor, *trl_motor, *trr_motor;
    61   MeshSceneNode *bfl_motor, *bfr_motor, *brl_motor, *brr_motor;
    6247  Blade *tfl_blade, *tfr_blade, *trl_blade, *trr_blade;
    6348  Blade *bfl_blade, *bfr_blade, *brl_blade, *brr_blade;
  • trunk/include/FlairVisionFilter/OpticalFlowSpeed.h

    r44 r50  
    3131    * \brief Optical flow speed calculation
    3232    *
    33     * Speed is the mean of all optical flow values.
     33    * Speed is the mean of all optical flow values divided by the delta time between images.
    3434    */
    3535    class OpticalFlowSpeed : public core::IODevice
     
    6767            * \brief Output matrix
    6868            *
    69             * Matrix is of sze (2,1). \n
     69            * Matrix is of size (2,1). \n
    7070            * First line is speed along x axis. \n
    7171            * Second line is speed along y axis. \n
Note: See TracChangeset for help on using the changeset viewer.