MultiSenseChannel.hh

Go to the documentation of this file.

#ifndef LibMultiSense_MultiSenseChannel_hh
#define LibMultiSense_MultiSenseChannel_hh

#include <stdint.h>
#include <string>
#include <vector>

#include "MultiSenseTypes.hh"

namespace crl {
namespace multisense {

class MULTISENSE_API Channel {
public:

    static Channel* Create(const std::string& sensorAddress);

    static void Destroy(Channel *instanceP);

    virtual ~Channel() {};

    static const char *statusString(Status status);


    virtual Status addIsolatedCallback(image::Callback callback,
                                       DataSource      imageSourceMask,
                                       void           *userDataP=NULL) = 0;

    virtual Status addIsolatedCallback(lidar::Callback callback,
                                       void           *userDataP=NULL) = 0;

    virtual Status addIsolatedCallback(pps::Callback   callback,
                                       void           *userDataP=NULL) = 0;

    virtual Status addIsolatedCallback(imu::Callback   callback,
                                       void           *userDataP=NULL) = 0;


    virtual Status removeIsolatedCallback(image::Callback callback) = 0;

    virtual Status removeIsolatedCallback(lidar::Callback callback) = 0;

    virtual Status removeIsolatedCallback(pps::Callback   callback) = 0;

    virtual Status removeIsolatedCallback(imu::Callback   callback) = 0;

    virtual void  *reserveCallbackBuffer()                 = 0;

    virtual Status releaseCallbackBuffer(void *referenceP) = 0;

    virtual Status networkTimeSynchronization(bool enabled) = 0;

    virtual Status startStreams     (DataSource mask)  = 0;

    virtual Status stopStreams      (DataSource mask)  = 0;

    virtual Status getEnabledStreams(DataSource& mask) = 0;


    virtual Status startDirectedStream(const DirectedStream& stream) = 0;

    virtual Status startDirectedStreams(const std::vector<DirectedStream>& streams) = 0;

    virtual Status stopDirectedStream (const DirectedStream& stream) = 0;

    virtual Status getDirectedStreams (std::vector<DirectedStream>& streams) = 0;

    virtual Status maxDirectedStreams (uint32_t& maximum) = 0;

    virtual Status setTriggerSource    (TriggerSource s)                    = 0;

    virtual Status setMotorSpeed       (float rpm)                          = 0;

    virtual Status getLightingConfig   (lighting::Config& c)                = 0;

    virtual Status setLightingConfig   (const lighting::Config& c)          = 0;

    virtual Status getLightingSensorStatus (lighting::SensorStatus& status) = 0;

    virtual Status getSensorVersion    (VersionType& version)               = 0;

    virtual Status getApiVersion       (VersionType& version)               = 0;

    virtual Status getVersionInfo      (system::VersionInfo& v)             = 0;

    virtual Status getImageConfig      (image::Config& c)                   = 0;

    virtual Status setImageConfig      (const image::Config& c)             = 0;

    virtual Status getImageCalibration (image::Calibration& c)              = 0;

    virtual Status setImageCalibration (const image::Calibration& c)        = 0;

    virtual Status getSensorCalibration (image::SensorCalibration& c)              = 0;

        virtual Status setSensorCalibration (const image::SensorCalibration& c)        = 0;

    virtual Status getTransmitDelay (image::TransmitDelay& c)              = 0;

        virtual Status setTransmitDelay (const image::TransmitDelay& c)        = 0;

    virtual Status getLidarCalibration (lidar::Calibration& c)              = 0;

    virtual Status setLidarCalibration (const lidar::Calibration& c)        = 0;

    virtual Status getImageHistogram   (int64_t frameId,  // from last 20 images, left only
                                        image::Histogram& histogram)        = 0;


    virtual Status getDeviceModes      (std::vector<system::DeviceMode>& m) = 0;

    virtual Status getMtu              (int32_t& mtu)                       = 0;

    virtual Status setMtu              (int32_t mtu)                        = 0;

    virtual Status getNetworkConfig    (system::NetworkConfig& c)           = 0;

    virtual Status setNetworkConfig    (const system::NetworkConfig& c)     = 0;

    virtual Status getDeviceInfo       (system::DeviceInfo& info)           = 0;

    virtual Status setDeviceInfo       (const std::string& key,
                                        const system::DeviceInfo& i)        = 0;

    virtual Status getDeviceStatus     (system::StatusMessage& status) = 0;

    virtual Status getExternalCalibration (system::ExternalCalibration& calibration) = 0;

    virtual Status setExternalCalibration (const system::ExternalCalibration& calibration) = 0;

    virtual Status flashBitstream      (const std::string& file)            = 0;

    virtual Status flashFirmware       (const std::string& file)            = 0;

    virtual Status verifyBitstream     (const std::string& file)            = 0;

    virtual Status verifyFirmware      (const std::string& file)            = 0;

    //
    // IMU configuration.
    //
    // Detailed info may be queried, and configuration may be queried or set.
    //
    // See imu::Details and imu::Config classes for more information.
    //
    // 'samplesPerMessage' is the number of samples (aggregate from all IMU types)
    // that the sensor will queue internally before putting on the wire.
    // Note that low settings combined with high IMU sensor rates may interfere
    // with the acquisition and transmission of image and lidar data.
    //
    // For setImuConfig():
    //
    //    Set 'storeSettingsInFlash' to true to have the configuration saved in
    //    non-volatile flash on the sensor head.
    //
    //    Set 'samplesPerMessage' to zero for the sensor to keep its current
    //    samplesPerMessage setting.
    //
    //    IMU streams must be restarted for any configuration changes to be
    //    reflected.

    virtual Status getImuInfo          (uint32_t& maxSamplesPerMesage,
                                        std::vector<imu::Info>& info)       = 0;

    virtual Status getImuConfig        (uint32_t& samplesPerMessage,
                                        std::vector<imu::Config>& c)        = 0;

    virtual Status setImuConfig        (bool storeSettingsInFlash,
                                        uint32_t samplesPerMessage,
                                        const std::vector<imu::Config>& c)  = 0;

    virtual Status getLargeBufferDetails(uint32_t& bufferCount,
                                         uint32_t& bufferSize) = 0;
    virtual Status setLargeBuffers      (const std::vector<uint8_t*>& buffers,
                                         uint32_t                     bufferSize) = 0;

    virtual Status getLocalUdpPort(uint16_t& port) = 0;
};


}; // namespace multisense
}; // namespace crl

#endif // LibMultiSense_MultiSenseChannel_hh