RawIMUData.hpp

Go to the documentation of this file.

#pragma once
 
#include "depthai-shared/common/Point3f.hpp"
#include "depthai-shared/common/Timestamp.hpp"
#include "depthai-shared/datatype/RawBuffer.hpp"
#include "depthai-shared/utility/Serialization.hpp"
 
namespace dai {
 
struct IMUReport {
    enum class Accuracy : std::uint8_t {
        UNRELIABLE = 0,
        LOW = 1,
        MEDIUM = 2,
        HIGH = 3,
    };
    int32_t sequence = 0;
 
    Accuracy accuracy = Accuracy::UNRELIABLE;
 
    Timestamp timestamp = {};
 
    Timestamp tsDevice = {};
 
    std::chrono::time_point<std::chrono::steady_clock, std::chrono::steady_clock::duration> getTimestamp() const {
        return timestamp.get();
    }
 
    std::chrono::time_point<std::chrono::steady_clock, std::chrono::steady_clock::duration> getTimestampDevice() const {
        return tsDevice.get();
    }
 
    int32_t getSequenceNum() const {
        return sequence;
    }
};
DEPTHAI_SERIALIZE_EXT(IMUReport, sequence, accuracy, timestamp, tsDevice);
 
struct IMUReportAccelerometer : public IMUReport {
    float x = 0;
    float y = 0;
    float z = 0;
};
DEPTHAI_SERIALIZE_EXT(IMUReportAccelerometer, x, y, z, sequence, accuracy, timestamp, tsDevice);
 
struct IMUReportGyroscope : public IMUReport {
    float x = 0;
    float y = 0;
    float z = 0;
};
DEPTHAI_SERIALIZE_EXT(IMUReportGyroscope, x, y, z, sequence, accuracy, timestamp, tsDevice);
 
struct IMUReportMagneticField : public IMUReport {
    float x = 0;
    float y = 0;
    float z = 0;
};
DEPTHAI_SERIALIZE_EXT(IMUReportMagneticField, x, y, z, sequence, accuracy, timestamp, tsDevice);
 
struct IMUReportRotationVectorWAcc : public IMUReport {
    float i = 0;                      
    float j = 0;                      
    float k = 0;                      
    float real = 0;                   
    float rotationVectorAccuracy = 0; 
};
DEPTHAI_SERIALIZE_EXT(IMUReportRotationVectorWAcc, i, j, k, real, rotationVectorAccuracy, sequence, accuracy, timestamp, tsDevice);
 
#if 0
 
struct IMUReportGyroscopeUncalibrated : public IMUReport {
    /* Units are rad/s */
    float x = 0;     
    float y = 0;     
    float z = 0;     
    float biasX = 0; 
    float biasY = 0; 
    float biasZ = 0; 
};
DEPTHAI_SERIALIZE_EXT(IMUReportGyroscopeUncalibrated, x, y, z, biasX, biasY, biasZ, sequence, accuracy, timestamp, tsDevice);
 
 
 
struct IMUReportMagneticFieldUncalibrated : public IMUReport {
    /* Units are uTesla */
    float x = 0;     
    float y = 0;     
    float z = 0;     
    float biasX = 0; 
    float biasY = 0; 
    float biasZ = 0; 
};
DEPTHAI_SERIALIZE_EXT(IMUReportMagneticFieldUncalibrated, x, y, z, biasX, biasY, biasZ, sequence, accuracy, timestamp, tsDevice);
 
 
 
struct IMUReportRotationVector : public IMUReport {
    float i = 0;    
    float j = 0;    
    float k = 0;    
    float real = 0; 
};
DEPTHAI_SERIALIZE_EXT(IMUReportRotationVector, i, j, k, real, sequence, accuracy, timestamp, tsDevice);
 
 
struct IMUReportGyroIntegratedRV : public IMUReport {
    float i = 0;       
    float j = 0;       
    float k = 0;       
    float real = 0;    
    float angVelX = 0; 
    float angVelY = 0; 
    float angVelZ = 0; 
};
DEPTHAI_SERIALIZE_EXT(IMUReportGyroIntegratedRV, i, j, k, real, angVelX, angVelY, angVelZ, sequence, accuracy, timestamp, tsDevice);
 
#endif
 
struct IMUPacket {
    IMUReportAccelerometer acceleroMeter;
    IMUReportGyroscope gyroscope;
    IMUReportMagneticField magneticField;
    IMUReportRotationVectorWAcc rotationVector;
 
#if 0
    IMUReportAccelerometer rawAcceleroMeter;
 
    IMUReportAccelerometer linearAcceleroMeter;
    IMUReportAccelerometer gravity;
 
    IMUReportGyroscope rawGyroscope;
    IMUReportGyroscopeUncalibrated gyroscopeUncalibrated;
 
    IMUReportMagneticField rawMagneticField;
    IMUReportMagneticFieldUncalibrated magneticFieldUncalibrated;
 
    IMUReportRotationVector gameRotationVector;
    IMUReportRotationVectorWAcc geoMagRotationVector;
 
    IMUReportRotationVectorWAcc arvrStabilizedRotationVector;
    IMUReportRotationVector arvrStabilizedGameRotationVector;
    IMUReportGyroIntegratedRV gyroIntegratedRotationVector;
#endif
};
 
DEPTHAI_SERIALIZE_EXT(IMUPacket, acceleroMeter, gyroscope, magneticField, rotationVector);
 
struct RawIMUData : public RawBuffer {
    std::vector<IMUPacket> packets;
 
    void serialize(std::vector<std::uint8_t>& metadata, DatatypeEnum& datatype) const override {
        metadata = utility::serialize(*this);
        datatype = DatatypeEnum::IMUData;
    };
 
    DatatypeEnum getType() const override {
        return DatatypeEnum::IMUData;
    }
 
    DEPTHAI_SERIALIZE(RawIMUData, packets, RawBuffer::sequenceNum, RawBuffer::ts, RawBuffer::tsDevice);
};
 
}  // namespace dai