alnaosim/alnaosim/alnaosim.h

#ifndef ALNAOSIM_H
#define ALNAOSIM_H
#include <qi/macro.hpp>

#ifdef alnaosim_EXPORTS
# define ALNAOSIM_API QI_EXPORT_API
#elif defined(alnaosim_IMPORTS)
# define ALNAOSIM_API QI_IMPORT_API
#else
# define ALNAOSIM_API
#endif

#include <string>
#include <vector>

namespace Sim
{

  class AngleActuator;
  class AngleSensor;
  class AngleSpeedActuator;
  class AngleSpeedSensor;
  class BumperSensor;
  class TactileSensor;
  class CameraSensor;
  class CoupledActuator;
  class CoupledSensor;
  class DepthInfraredSensor;
  class FSRSensor;
  class InertialSensor;
  class SonarSensor;
  class Model;
  class TorqueActuator;
  class TorqueSensor;
  class WheelTorqueActuator;
  class WheelVelocityActuator;
  class WheelVelocitySensor;
  class LEDActuator;

class ALNAOSIM_API HALInterface
{
  public:
    HALInterface(const Model* model, int NAOqiId = 9559);
    ~HALInterface();

    float fetchAngleActuatorValue(const AngleActuator* angleActuator);
    float fetchCoupledActuatorValue(const CoupledActuator* coupledActuator);
    float fetchTorqueActuatorValue(const TorqueActuator* torqueActuator);
    float fetchAngleSpeedActuatorValue(
      const AngleSpeedActuator* angleSpeedActuator);
    float fetchWheelTorqueActuatorValue(
      const WheelTorqueActuator* wheelTorqueActuator);
    float fetchWheelVelocityActuatorValue(
      const WheelVelocityActuator* wheelVelocityActuator);
    float fetchLEDActuatorValue(const LEDActuator* ledActuator);

    float fetchAngleActuatorStiffness(const AngleActuator* angleActuator);
    float fetchCoupledActuatorStiffness(const CoupledActuator* coupledActuator);
    float fetchTorqueActuatorStiffness(const TorqueActuator* torqueActuator);
    float fetchAngleSpeedActuatorStiffness(
      const AngleSpeedActuator* angleSpeedActuator);
    float fetchWheelTorqueActuatorStiffness(
      const WheelTorqueActuator* wheelTorqueActuator);
    float fetchWheelVelocityActuatorStiffness(
      const WheelVelocityActuator* wheelVelocityActuator);

    bool sendAngleSensorValue(
      const AngleSensor* angleSensor, float value);
    bool sendCoupledSensorValue(
      const CoupledSensor* coupledSensor, float value);
    bool sendTorqueSensorValue(
      const TorqueSensor* torqueSensor, float value);
    bool sendAngleSpeedSensorValue(
      const AngleSpeedSensor* angleSpeedSensor, float value);
    bool sendWheelVelocitySensorValue(
      const WheelVelocitySensor* wheelVelocitySensor, float value);

    bool sendCameraSensorValue(
      const CameraSensor* cameraSensor, const unsigned char* img);
    bool sendFSRSensorValue(
      const FSRSensor* fsrSensor, float value);
    bool sendBumperSensorValue(
      const BumperSensor* bumperSensor, float value);
    bool sendTactileSensorValue(
      const TactileSensor* tactileSensor, float value);
    bool sendDepthInfraredSensorValue(
      const DepthInfraredSensor* depthInfraredSensor, float value);


    bool sendInertialSensorValues(
      const InertialSensor* inertialSensor, std::vector<const float*> values);
    bool sendSonarSensorValues(
      const SonarSensor* sonarSensor, std::vector<const float*> values);
    bool sendInertialSensorValues(
      const InertialSensor* inertialSensor, std::vector<float> values);
    bool sendSonarSensorValues(
      const SonarSensor* sonarSensor, std::vector<float> values);
    bool sendSonarSensorValue(const SonarSensor* sonarSensor, float value);

    std::string activeCamera();
    int cameraBufferSize();
    void cameraBufferSize(
      const CameraSensor* camera,
      int* cameraBufferSize,
      int* width,
      int* height);
    int cameraBufferSize(const CameraSensor* camera);
    class HALInterfaceImpl* a_impl;
};

}
#endif // ALNAOSIM_H