Changeset 50 in flair-dev for trunk/include/FlairSensorActuator


Ignore:
Timestamp:
05/31/17 15:54:26 (7 years ago)
Author:
Sanahuja Guillaume
Message:

doc

Location:
trunk/include/FlairSensorActuator
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • 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};
Note: See TracChangeset for help on using the changeset viewer.