1553 lines
58 KiB
C++
1553 lines
58 KiB
C++
#ifndef _VNSENSORS_REGISTERS_H_
|
|
#define _VNSENSORS_REGISTERS_H_
|
|
|
|
#include "int.h"
|
|
#include "vector.h"
|
|
#include "matrix.h"
|
|
#include "types.h"
|
|
|
|
namespace vn {
|
|
namespace sensors {
|
|
|
|
/// \defgroup registerStructures Register Structures
|
|
/// \brief These structures represent the various registers on a VecotorNav
|
|
/// sensor.
|
|
///
|
|
/// \{
|
|
|
|
/// \brief Structure representing a Binary Output register.
|
|
///
|
|
/// The field outputGroup available on the sensor's register is not necessary
|
|
/// in this structure since all read/writes operations will automatically
|
|
/// determine this from the settings for the individual groups within this
|
|
/// structure.
|
|
struct BinaryOutputRegister
|
|
{
|
|
protocol::uart::AsyncMode asyncMode; ///< The asyncMode field.
|
|
uint16_t rateDivisor; ///< The rateDivisor field.
|
|
protocol::uart::CommonGroup commonField; ///< Group 1 (Common)
|
|
protocol::uart::TimeGroup timeField; ///< Group 2 (Time)
|
|
protocol::uart::ImuGroup imuField; ///< Group 3 (IMU)
|
|
protocol::uart::GpsGroup gpsField; ///< Group 4 (GPS)
|
|
protocol::uart::AttitudeGroup attitudeField; ///< Group 5 (Attitude)
|
|
protocol::uart::InsGroup insField; ///< Group 6 (INS)
|
|
protocol::uart::GpsGroup gps2Field; ///< Group 7 (GPS2)
|
|
|
|
BinaryOutputRegister() :
|
|
asyncMode(protocol::uart::ASYNCMODE_NONE),
|
|
rateDivisor(0),
|
|
commonField(protocol::uart::COMMONGROUP_NONE),
|
|
timeField(protocol::uart::TIMEGROUP_NONE),
|
|
imuField(protocol::uart::IMUGROUP_NONE),
|
|
gpsField(protocol::uart::GPSGROUP_NONE),
|
|
attitudeField(protocol::uart::ATTITUDEGROUP_NONE),
|
|
insField(protocol::uart::INSGROUP_NONE),
|
|
gps2Field(protocol::uart::GPSGROUP_NONE)
|
|
{ }
|
|
|
|
/// \brief Creates an initializes a new BinaryOutputRegister structure.
|
|
///
|
|
/// \param[in] asyncModeIn Value to initialize the asyncMode field with.
|
|
/// \param[in] rateDivisorIn Value to initialize the rateDivisor field with.
|
|
/// \param[in] commonFieldIn Value to initialize field 1 (Common) with.
|
|
/// \param[in] timeFieldIn Value to initialize field 2 (Time) with.
|
|
/// \param[in] imuFieldIn Value to initialize field 3 (IMU) with.
|
|
/// \param[in] gpsFieldIn Value to initialize field 4 (GPS) with.
|
|
/// \param[in] attitudeFieldIn Value to initialize field 5 (Attitude) with.
|
|
/// \param[in] insFieldIn Value to initialize field 6 (INS) with.
|
|
/// \param[in] gps2FieldIn Value to initialize field 7 (GPS2) with.
|
|
BinaryOutputRegister(
|
|
protocol::uart::AsyncMode asyncModeIn,
|
|
uint16_t rateDivisorIn,
|
|
protocol::uart::CommonGroup commonFieldIn,
|
|
protocol::uart::TimeGroup timeFieldIn,
|
|
protocol::uart::ImuGroup imuFieldIn,
|
|
protocol::uart::GpsGroup gpsFieldIn,
|
|
protocol::uart::AttitudeGroup attitudeFieldIn,
|
|
protocol::uart::InsGroup insFieldIn,
|
|
protocol::uart::GpsGroup gps2FieldIn) :
|
|
asyncMode(asyncModeIn),
|
|
rateDivisor(rateDivisorIn),
|
|
commonField(commonFieldIn),
|
|
timeField(timeFieldIn),
|
|
imuField(imuFieldIn),
|
|
gpsField(gpsFieldIn),
|
|
attitudeField(attitudeFieldIn),
|
|
insField(insFieldIn),
|
|
gps2Field(gps2FieldIn)
|
|
{ }
|
|
|
|
BinaryOutputRegister(
|
|
uint16_t asyncModeIn,
|
|
uint16_t rateDivisorIn,
|
|
uint16_t commonFieldIn,
|
|
uint16_t timeFieldIn,
|
|
uint16_t imuFieldIn,
|
|
uint16_t gpsFieldIn,
|
|
uint16_t attitudeFieldIn,
|
|
uint16_t insFieldIn,
|
|
uint16_t gps2FieldIn) :
|
|
asyncMode(static_cast<protocol::uart::AsyncMode>(asyncModeIn)),
|
|
rateDivisor(rateDivisorIn),
|
|
commonField(static_cast<protocol::uart::CommonGroup>(commonFieldIn)),
|
|
timeField(static_cast<protocol::uart::TimeGroup>(timeFieldIn)),
|
|
imuField(static_cast<protocol::uart::ImuGroup>(imuFieldIn)),
|
|
gpsField(static_cast<protocol::uart::GpsGroup>(gpsFieldIn)),
|
|
attitudeField(static_cast<protocol::uart::AttitudeGroup>(attitudeFieldIn)),
|
|
insField(static_cast<protocol::uart::InsGroup>(insFieldIn)),
|
|
gps2Field(static_cast<protocol::uart::GpsGroup>(gps2FieldIn))
|
|
{ }
|
|
};
|
|
|
|
/// \brief Structure representing the Quaternion, Magnetic, Acceleration and Angular Rates register.
|
|
struct QuaternionMagneticAccelerationAndAngularRatesRegister
|
|
{
|
|
vn::math::vec4f quat; ///< The quat field.
|
|
vn::math::vec3f mag; ///< The mag field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
|
|
QuaternionMagneticAccelerationAndAngularRatesRegister() { }
|
|
|
|
/// \brief Creates an initializes a new QuaternionMagneticAccelerationAndAngularRatesRegister structure.
|
|
///
|
|
/// \param[in] quatIn Value to initialize the quat field with.
|
|
/// \param[in] magIn Value to initialize the mag field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
QuaternionMagneticAccelerationAndAngularRatesRegister(
|
|
vn::math::vec4f quatIn,
|
|
vn::math::vec3f magIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f gyroIn) :
|
|
quat(quatIn),
|
|
mag(magIn),
|
|
accel(accelIn),
|
|
gyro(gyroIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Magnetic, Acceleration and Angular Rates register.
|
|
struct MagneticAccelerationAndAngularRatesRegister
|
|
{
|
|
vn::math::vec3f mag; ///< The mag field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
|
|
MagneticAccelerationAndAngularRatesRegister() { }
|
|
|
|
/// \brief Creates an initializes a new MagneticAccelerationAndAngularRatesRegister structure.
|
|
///
|
|
/// \param[in] magIn Value to initialize the mag field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
MagneticAccelerationAndAngularRatesRegister(
|
|
vn::math::vec3f magIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f gyroIn) :
|
|
mag(magIn),
|
|
accel(accelIn),
|
|
gyro(gyroIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Magnetic and Gravity Reference Vectors register.
|
|
struct MagneticAndGravityReferenceVectorsRegister
|
|
{
|
|
vn::math::vec3f magRef; ///< The magRef field.
|
|
vn::math::vec3f accRef; ///< The accRef field.
|
|
|
|
MagneticAndGravityReferenceVectorsRegister() { }
|
|
|
|
/// \brief Creates an initializes a new MagneticAndGravityReferenceVectorsRegister structure.
|
|
///
|
|
/// \param[in] magRefIn Value to initialize the magRef field with.
|
|
/// \param[in] accRefIn Value to initialize the accRef field with.
|
|
MagneticAndGravityReferenceVectorsRegister(
|
|
vn::math::vec3f magRefIn,
|
|
vn::math::vec3f accRefIn) :
|
|
magRef(magRefIn),
|
|
accRef(accRefIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Filter Measurements Variance Parameters register.
|
|
struct FilterMeasurementsVarianceParametersRegister
|
|
{
|
|
float angularWalkVariance; ///< The angularWalkVariance field.
|
|
vn::math::vec3f angularRateVariance; ///< The angularRateVariance field.
|
|
vn::math::vec3f magneticVariance; ///< The magneticVariance field.
|
|
vn::math::vec3f accelerationVariance; ///< The accelerationVariance field.
|
|
|
|
FilterMeasurementsVarianceParametersRegister() { }
|
|
|
|
/// \brief Creates an initializes a new FilterMeasurementsVarianceParametersRegister structure.
|
|
///
|
|
/// \param[in] angularWalkVarianceIn Value to initialize the angularWalkVariance field with.
|
|
/// \param[in] angularRateVarianceIn Value to initialize the angularRateVariance field with.
|
|
/// \param[in] magneticVarianceIn Value to initialize the magneticVariance field with.
|
|
/// \param[in] accelerationVarianceIn Value to initialize the accelerationVariance field with.
|
|
FilterMeasurementsVarianceParametersRegister(
|
|
float angularWalkVarianceIn,
|
|
vn::math::vec3f angularRateVarianceIn,
|
|
vn::math::vec3f magneticVarianceIn,
|
|
vn::math::vec3f accelerationVarianceIn) :
|
|
angularWalkVariance(angularWalkVarianceIn),
|
|
angularRateVariance(angularRateVarianceIn),
|
|
magneticVariance(magneticVarianceIn),
|
|
accelerationVariance(accelerationVarianceIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Magnetometer Compensation register.
|
|
struct MagnetometerCompensationRegister
|
|
{
|
|
vn::math::mat3f c; ///< The c field.
|
|
vn::math::vec3f b; ///< The b field.
|
|
|
|
MagnetometerCompensationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new MagnetometerCompensationRegister structure.
|
|
///
|
|
/// \param[in] cIn Value to initialize the c field with.
|
|
/// \param[in] bIn Value to initialize the b field with.
|
|
MagnetometerCompensationRegister(
|
|
vn::math::mat3f cIn,
|
|
vn::math::vec3f bIn) :
|
|
c(cIn),
|
|
b(bIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Filter Active Tuning Parameters register.
|
|
struct FilterActiveTuningParametersRegister
|
|
{
|
|
float magneticDisturbanceGain; ///< The magneticDisturbanceGain field.
|
|
float accelerationDisturbanceGain; ///< The accelerationDisturbanceGain field.
|
|
float magneticDisturbanceMemory; ///< The magneticDisturbanceMemory field.
|
|
float accelerationDisturbanceMemory; ///< The accelerationDisturbanceMemory field.
|
|
|
|
FilterActiveTuningParametersRegister() { }
|
|
|
|
/// \brief Creates an initializes a new FilterActiveTuningParametersRegister structure.
|
|
///
|
|
/// \param[in] magneticDisturbanceGainIn Value to initialize the magneticDisturbanceGain field with.
|
|
/// \param[in] accelerationDisturbanceGainIn Value to initialize the accelerationDisturbanceGain field with.
|
|
/// \param[in] magneticDisturbanceMemoryIn Value to initialize the magneticDisturbanceMemory field with.
|
|
/// \param[in] accelerationDisturbanceMemoryIn Value to initialize the accelerationDisturbanceMemory field with.
|
|
FilterActiveTuningParametersRegister(
|
|
float magneticDisturbanceGainIn,
|
|
float accelerationDisturbanceGainIn,
|
|
float magneticDisturbanceMemoryIn,
|
|
float accelerationDisturbanceMemoryIn) :
|
|
magneticDisturbanceGain(magneticDisturbanceGainIn),
|
|
accelerationDisturbanceGain(accelerationDisturbanceGainIn),
|
|
magneticDisturbanceMemory(magneticDisturbanceMemoryIn),
|
|
accelerationDisturbanceMemory(accelerationDisturbanceMemoryIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Acceleration Compensation register.
|
|
struct AccelerationCompensationRegister
|
|
{
|
|
vn::math::mat3f c; ///< The c field.
|
|
vn::math::vec3f b; ///< The b field.
|
|
|
|
AccelerationCompensationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new AccelerationCompensationRegister structure.
|
|
///
|
|
/// \param[in] cIn Value to initialize the c field with.
|
|
/// \param[in] bIn Value to initialize the b field with.
|
|
AccelerationCompensationRegister(
|
|
vn::math::mat3f cIn,
|
|
vn::math::vec3f bIn) :
|
|
c(cIn),
|
|
b(bIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Yaw, Pitch, Roll, Magnetic, Acceleration and Angular Rates register.
|
|
struct YawPitchRollMagneticAccelerationAndAngularRatesRegister
|
|
{
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3f mag; ///< The mag field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
|
|
YawPitchRollMagneticAccelerationAndAngularRatesRegister() { }
|
|
|
|
/// \brief Creates an initializes a new YawPitchRollMagneticAccelerationAndAngularRatesRegister structure.
|
|
///
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] magIn Value to initialize the mag field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
YawPitchRollMagneticAccelerationAndAngularRatesRegister(
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3f magIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f gyroIn) :
|
|
yawPitchRoll(yawPitchRollIn),
|
|
mag(magIn),
|
|
accel(accelIn),
|
|
gyro(gyroIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Communication Protocol Control register.
|
|
struct CommunicationProtocolControlRegister
|
|
{
|
|
protocol::uart::CountMode serialCount; ///< The serialCount field.
|
|
protocol::uart::StatusMode serialStatus; ///< The serialStatus field.
|
|
protocol::uart::CountMode spiCount; ///< The spiCount field.
|
|
protocol::uart::StatusMode spiStatus; ///< The spiStatus field.
|
|
protocol::uart::ChecksumMode serialChecksum; ///< The serialChecksum field.
|
|
protocol::uart::ChecksumMode spiChecksum; ///< The spiChecksum field.
|
|
protocol::uart::ErrorMode errorMode; ///< The errorMode field.
|
|
|
|
CommunicationProtocolControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new CommunicationProtocolControlRegister structure.
|
|
///
|
|
/// \param[in] serialCountIn Value to initialize the serialCount field with.
|
|
/// \param[in] serialStatusIn Value to initialize the serialStatus field with.
|
|
/// \param[in] spiCountIn Value to initialize the spiCount field with.
|
|
/// \param[in] spiStatusIn Value to initialize the spiStatus field with.
|
|
/// \param[in] serialChecksumIn Value to initialize the serialChecksum field with.
|
|
/// \param[in] spiChecksumIn Value to initialize the spiChecksum field with.
|
|
/// \param[in] errorModeIn Value to initialize the errorMode field with.
|
|
CommunicationProtocolControlRegister(
|
|
protocol::uart::CountMode serialCountIn,
|
|
protocol::uart::StatusMode serialStatusIn,
|
|
protocol::uart::CountMode spiCountIn,
|
|
protocol::uart::StatusMode spiStatusIn,
|
|
protocol::uart::ChecksumMode serialChecksumIn,
|
|
protocol::uart::ChecksumMode spiChecksumIn,
|
|
protocol::uart::ErrorMode errorModeIn) :
|
|
serialCount(serialCountIn),
|
|
serialStatus(serialStatusIn),
|
|
spiCount(spiCountIn),
|
|
spiStatus(spiStatusIn),
|
|
serialChecksum(serialChecksumIn),
|
|
spiChecksum(spiChecksumIn),
|
|
errorMode(errorModeIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Synchronization Control register.
|
|
struct SynchronizationControlRegister
|
|
{
|
|
protocol::uart::SyncInMode syncInMode; ///< The syncInMode field.
|
|
protocol::uart::SyncInEdge syncInEdge; ///< The syncInEdge field.
|
|
uint16_t syncInSkipFactor; ///< The syncInSkipFactor field.
|
|
protocol::uart::SyncOutMode syncOutMode; ///< The syncOutMode field.
|
|
protocol::uart::SyncOutPolarity syncOutPolarity; ///< The syncOutPolarity field.
|
|
uint16_t syncOutSkipFactor; ///< The syncOutSkipFactor field.
|
|
uint32_t syncOutPulseWidth; ///< The syncOutPulseWidth field.
|
|
|
|
SynchronizationControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new SynchronizationControlRegister structure.
|
|
///
|
|
/// \param[in] syncInModeIn Value to initialize the syncInMode field with.
|
|
/// \param[in] syncInEdgeIn Value to initialize the syncInEdge field with.
|
|
/// \param[in] syncInSkipFactorIn Value to initialize the syncInSkipFactor field with.
|
|
/// \param[in] syncOutModeIn Value to initialize the syncOutMode field with.
|
|
/// \param[in] syncOutPolarityIn Value to initialize the syncOutPolarity field with.
|
|
/// \param[in] syncOutSkipFactorIn Value to initialize the syncOutSkipFactor field with.
|
|
/// \param[in] syncOutPulseWidthIn Value to initialize the syncOutPulseWidth field with.
|
|
SynchronizationControlRegister(
|
|
protocol::uart::SyncInMode syncInModeIn,
|
|
protocol::uart::SyncInEdge syncInEdgeIn,
|
|
uint16_t syncInSkipFactorIn,
|
|
protocol::uart::SyncOutMode syncOutModeIn,
|
|
protocol::uart::SyncOutPolarity syncOutPolarityIn,
|
|
uint16_t syncOutSkipFactorIn,
|
|
uint32_t syncOutPulseWidthIn) :
|
|
syncInMode(syncInModeIn),
|
|
syncInEdge(syncInEdgeIn),
|
|
syncInSkipFactor(syncInSkipFactorIn),
|
|
syncOutMode(syncOutModeIn),
|
|
syncOutPolarity(syncOutPolarityIn),
|
|
syncOutSkipFactor(syncOutSkipFactorIn),
|
|
syncOutPulseWidth(syncOutPulseWidthIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Synchronization Status register.
|
|
struct SynchronizationStatusRegister
|
|
{
|
|
uint32_t syncInCount; ///< The syncInCount field.
|
|
uint32_t syncInTime; ///< The syncInTime field.
|
|
uint32_t syncOutCount; ///< The syncOutCount field.
|
|
|
|
SynchronizationStatusRegister() { }
|
|
|
|
/// \brief Creates an initializes a new SynchronizationStatusRegister structure.
|
|
///
|
|
/// \param[in] syncInCountIn Value to initialize the syncInCount field with.
|
|
/// \param[in] syncInTimeIn Value to initialize the syncInTime field with.
|
|
/// \param[in] syncOutCountIn Value to initialize the syncOutCount field with.
|
|
SynchronizationStatusRegister(
|
|
uint32_t syncInCountIn,
|
|
uint32_t syncInTimeIn,
|
|
uint32_t syncOutCountIn) :
|
|
syncInCount(syncInCountIn),
|
|
syncInTime(syncInTimeIn),
|
|
syncOutCount(syncOutCountIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Filter Basic Control register.
|
|
struct FilterBasicControlRegister
|
|
{
|
|
protocol::uart::MagneticMode magMode; ///< The magMode field.
|
|
protocol::uart::ExternalSensorMode extMagMode; ///< The extMagMode field.
|
|
protocol::uart::ExternalSensorMode extAccMode; ///< The extAccMode field.
|
|
protocol::uart::ExternalSensorMode extGyroMode; ///< The extGyroMode field.
|
|
vn::math::vec3f gyroLimit; ///< The gyroLimit field.
|
|
|
|
FilterBasicControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new FilterBasicControlRegister structure.
|
|
///
|
|
/// \param[in] magModeIn Value to initialize the magMode field with.
|
|
/// \param[in] extMagModeIn Value to initialize the extMagMode field with.
|
|
/// \param[in] extAccModeIn Value to initialize the extAccMode field with.
|
|
/// \param[in] extGyroModeIn Value to initialize the extGyroMode field with.
|
|
/// \param[in] gyroLimitIn Value to initialize the gyroLimit field with.
|
|
FilterBasicControlRegister(
|
|
protocol::uart::MagneticMode magModeIn,
|
|
protocol::uart::ExternalSensorMode extMagModeIn,
|
|
protocol::uart::ExternalSensorMode extAccModeIn,
|
|
protocol::uart::ExternalSensorMode extGyroModeIn,
|
|
vn::math::vec3f gyroLimitIn) :
|
|
magMode(magModeIn),
|
|
extMagMode(extMagModeIn),
|
|
extAccMode(extAccModeIn),
|
|
extGyroMode(extGyroModeIn),
|
|
gyroLimit(gyroLimitIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Basic Control register.
|
|
struct VpeBasicControlRegister
|
|
{
|
|
protocol::uart::VpeEnable enable; ///< The enable field.
|
|
protocol::uart::HeadingMode headingMode; ///< The headingMode field.
|
|
protocol::uart::VpeMode filteringMode; ///< The filteringMode field.
|
|
protocol::uart::VpeMode tuningMode; ///< The tuningMode field.
|
|
|
|
VpeBasicControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeBasicControlRegister structure.
|
|
///
|
|
/// \param[in] enableIn Value to initialize the enable field with.
|
|
/// \param[in] headingModeIn Value to initialize the headingMode field with.
|
|
/// \param[in] filteringModeIn Value to initialize the filteringMode field with.
|
|
/// \param[in] tuningModeIn Value to initialize the tuningMode field with.
|
|
VpeBasicControlRegister(
|
|
protocol::uart::VpeEnable enableIn,
|
|
protocol::uart::HeadingMode headingModeIn,
|
|
protocol::uart::VpeMode filteringModeIn,
|
|
protocol::uart::VpeMode tuningModeIn) :
|
|
enable(enableIn),
|
|
headingMode(headingModeIn),
|
|
filteringMode(filteringModeIn),
|
|
tuningMode(tuningModeIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Heave Configuration Register
|
|
struct HeaveConfigurationRegister
|
|
{
|
|
float initialWavePeriod;
|
|
float initialWaveAmplitude;
|
|
float maxWavePeriod;
|
|
float minWaveAmplitude;
|
|
float delayedHeaveCutoffFreq;
|
|
float heaveCutoffFreq;
|
|
float heaveRateCutoffFreq;
|
|
|
|
HeaveConfigurationRegister() { }
|
|
|
|
/// \brief Creates and initializes a new HeaveConfigurationRegister structure.
|
|
///
|
|
/// \param[in] initialWavePeriodIn Value to initialize the initialWavePeriod field with.
|
|
/// \param[in] initialWaveAmplitudeIn Value to initialize the initialWaveAmplitude field with.
|
|
/// \param[in] maxWavePeriodIn Value to initialize the maxWavePeriod field with.
|
|
/// \param[in] minWaveAmplitudeIn Value to initialize the minWaveAmplitude field with.
|
|
/// \param[in] delayedHeaveCutoffFreqIn Value to initialize the delayedHeaveCutoffFreq field with.
|
|
/// \param[in] heaveCutoffFreqIn Value to initialize the heaveCutoffFreq field with.
|
|
/// \param[in] heaveRateCutoffFreqIn Value to initialize the heaveRateCutoffFreq field with.
|
|
HeaveConfigurationRegister(
|
|
float initialWavePeriodIn,
|
|
float initialWaveAmplitudeIn,
|
|
float maxWavePeriodIn,
|
|
float minWaveAmplitudeIn,
|
|
float delayedHeaveCutoffFreqIn,
|
|
float heaveCutoffFreqIn,
|
|
float heaveRateCutoffFreqIn
|
|
) :
|
|
initialWavePeriod(initialWavePeriodIn),
|
|
initialWaveAmplitude(initialWaveAmplitudeIn),
|
|
maxWavePeriod(maxWavePeriodIn),
|
|
minWaveAmplitude(minWaveAmplitudeIn),
|
|
delayedHeaveCutoffFreq(delayedHeaveCutoffFreqIn),
|
|
heaveCutoffFreq(heaveCutoffFreqIn),
|
|
heaveRateCutoffFreq(heaveRateCutoffFreqIn)
|
|
{ }
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Magnetometer Basic Tuning register.
|
|
struct VpeMagnetometerBasicTuningRegister
|
|
{
|
|
vn::math::vec3f baseTuning; ///< The baseTuning field.
|
|
vn::math::vec3f adaptiveTuning; ///< The adaptiveTuning field.
|
|
vn::math::vec3f adaptiveFiltering; ///< The adaptiveFiltering field.
|
|
|
|
VpeMagnetometerBasicTuningRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeMagnetometerBasicTuningRegister structure.
|
|
///
|
|
/// \param[in] baseTuningIn Value to initialize the baseTuning field with.
|
|
/// \param[in] adaptiveTuningIn Value to initialize the adaptiveTuning field with.
|
|
/// \param[in] adaptiveFilteringIn Value to initialize the adaptiveFiltering field with.
|
|
VpeMagnetometerBasicTuningRegister(
|
|
vn::math::vec3f baseTuningIn,
|
|
vn::math::vec3f adaptiveTuningIn,
|
|
vn::math::vec3f adaptiveFilteringIn) :
|
|
baseTuning(baseTuningIn),
|
|
adaptiveTuning(adaptiveTuningIn),
|
|
adaptiveFiltering(adaptiveFilteringIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Magnetometer Advanced Tuning register.
|
|
struct VpeMagnetometerAdvancedTuningRegister
|
|
{
|
|
vn::math::vec3f minFiltering; ///< The minFiltering field.
|
|
vn::math::vec3f maxFiltering; ///< The maxFiltering field.
|
|
float maxAdaptRate; ///< The maxAdaptRate field.
|
|
float disturbanceWindow; ///< The disturbanceWindow field.
|
|
float maxTuning; ///< The maxTuning field.
|
|
|
|
VpeMagnetometerAdvancedTuningRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeMagnetometerAdvancedTuningRegister structure.
|
|
///
|
|
/// \param[in] minFilteringIn Value to initialize the minFiltering field with.
|
|
/// \param[in] maxFilteringIn Value to initialize the maxFiltering field with.
|
|
/// \param[in] maxAdaptRateIn Value to initialize the maxAdaptRate field with.
|
|
/// \param[in] disturbanceWindowIn Value to initialize the disturbanceWindow field with.
|
|
/// \param[in] maxTuningIn Value to initialize the maxTuning field with.
|
|
VpeMagnetometerAdvancedTuningRegister(
|
|
vn::math::vec3f minFilteringIn,
|
|
vn::math::vec3f maxFilteringIn,
|
|
float maxAdaptRateIn,
|
|
float disturbanceWindowIn,
|
|
float maxTuningIn) :
|
|
minFiltering(minFilteringIn),
|
|
maxFiltering(maxFilteringIn),
|
|
maxAdaptRate(maxAdaptRateIn),
|
|
disturbanceWindow(disturbanceWindowIn),
|
|
maxTuning(maxTuningIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Accelerometer Basic Tuning register.
|
|
struct VpeAccelerometerBasicTuningRegister
|
|
{
|
|
vn::math::vec3f baseTuning; ///< The baseTuning field.
|
|
vn::math::vec3f adaptiveTuning; ///< The adaptiveTuning field.
|
|
vn::math::vec3f adaptiveFiltering; ///< The adaptiveFiltering field.
|
|
|
|
VpeAccelerometerBasicTuningRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeAccelerometerBasicTuningRegister structure.
|
|
///
|
|
/// \param[in] baseTuningIn Value to initialize the baseTuning field with.
|
|
/// \param[in] adaptiveTuningIn Value to initialize the adaptiveTuning field with.
|
|
/// \param[in] adaptiveFilteringIn Value to initialize the adaptiveFiltering field with.
|
|
VpeAccelerometerBasicTuningRegister(
|
|
vn::math::vec3f baseTuningIn,
|
|
vn::math::vec3f adaptiveTuningIn,
|
|
vn::math::vec3f adaptiveFilteringIn) :
|
|
baseTuning(baseTuningIn),
|
|
adaptiveTuning(adaptiveTuningIn),
|
|
adaptiveFiltering(adaptiveFilteringIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Accelerometer Advanced Tuning register.
|
|
struct VpeAccelerometerAdvancedTuningRegister
|
|
{
|
|
vn::math::vec3f minFiltering; ///< The minFiltering field.
|
|
vn::math::vec3f maxFiltering; ///< The maxFiltering field.
|
|
float maxAdaptRate; ///< The maxAdaptRate field.
|
|
float disturbanceWindow; ///< The disturbanceWindow field.
|
|
float maxTuning; ///< The maxTuning field.
|
|
|
|
VpeAccelerometerAdvancedTuningRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeAccelerometerAdvancedTuningRegister structure.
|
|
///
|
|
/// \param[in] minFilteringIn Value to initialize the minFiltering field with.
|
|
/// \param[in] maxFilteringIn Value to initialize the maxFiltering field with.
|
|
/// \param[in] maxAdaptRateIn Value to initialize the maxAdaptRate field with.
|
|
/// \param[in] disturbanceWindowIn Value to initialize the disturbanceWindow field with.
|
|
/// \param[in] maxTuningIn Value to initialize the maxTuning field with.
|
|
VpeAccelerometerAdvancedTuningRegister(
|
|
vn::math::vec3f minFilteringIn,
|
|
vn::math::vec3f maxFilteringIn,
|
|
float maxAdaptRateIn,
|
|
float disturbanceWindowIn,
|
|
float maxTuningIn) :
|
|
minFiltering(minFilteringIn),
|
|
maxFiltering(maxFilteringIn),
|
|
maxAdaptRate(maxAdaptRateIn),
|
|
disturbanceWindow(disturbanceWindowIn),
|
|
maxTuning(maxTuningIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the VPE Gyro Basic Tuning register.
|
|
struct VpeGyroBasicTuningRegister
|
|
{
|
|
vn::math::vec3f angularWalkVariance; ///< The angularWalkVariance field.
|
|
vn::math::vec3f baseTuning; ///< The baseTuning field.
|
|
vn::math::vec3f adaptiveTuning; ///< The adaptiveTuning field.
|
|
|
|
VpeGyroBasicTuningRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VpeGyroBasicTuningRegister structure.
|
|
///
|
|
/// \param[in] angularWalkVarianceIn Value to initialize the angularWalkVariance field with.
|
|
/// \param[in] baseTuningIn Value to initialize the baseTuning field with.
|
|
/// \param[in] adaptiveTuningIn Value to initialize the adaptiveTuning field with.
|
|
VpeGyroBasicTuningRegister(
|
|
vn::math::vec3f angularWalkVarianceIn,
|
|
vn::math::vec3f baseTuningIn,
|
|
vn::math::vec3f adaptiveTuningIn) :
|
|
angularWalkVariance(angularWalkVarianceIn),
|
|
baseTuning(baseTuningIn),
|
|
adaptiveTuning(adaptiveTuningIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Magnetometer Calibration Control register.
|
|
struct MagnetometerCalibrationControlRegister
|
|
{
|
|
protocol::uart::HsiMode hsiMode; ///< The hsiMode field.
|
|
protocol::uart::HsiOutput hsiOutput; ///< The hsiOutput field.
|
|
uint8_t convergeRate; ///< The convergeRate field.
|
|
|
|
MagnetometerCalibrationControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new MagnetometerCalibrationControlRegister structure.
|
|
///
|
|
/// \param[in] hsiModeIn Value to initialize the hsiMode field with.
|
|
/// \param[in] hsiOutputIn Value to initialize the hsiOutput field with.
|
|
/// \param[in] convergeRateIn Value to initialize the convergeRate field with.
|
|
MagnetometerCalibrationControlRegister(
|
|
protocol::uart::HsiMode hsiModeIn,
|
|
protocol::uart::HsiOutput hsiOutputIn,
|
|
uint8_t convergeRateIn) :
|
|
hsiMode(hsiModeIn),
|
|
hsiOutput(hsiOutputIn),
|
|
convergeRate(convergeRateIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Calculated Magnetometer Calibration register.
|
|
struct CalculatedMagnetometerCalibrationRegister
|
|
{
|
|
vn::math::mat3f c; ///< The c field.
|
|
vn::math::vec3f b; ///< The b field.
|
|
|
|
CalculatedMagnetometerCalibrationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new CalculatedMagnetometerCalibrationRegister structure.
|
|
///
|
|
/// \param[in] cIn Value to initialize the c field with.
|
|
/// \param[in] bIn Value to initialize the b field with.
|
|
CalculatedMagnetometerCalibrationRegister(
|
|
vn::math::mat3f cIn,
|
|
vn::math::vec3f bIn) :
|
|
c(cIn),
|
|
b(bIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Velocity Compensation Control register.
|
|
struct VelocityCompensationControlRegister
|
|
{
|
|
protocol::uart::VelocityCompensationMode mode; ///< The mode field.
|
|
float velocityTuning; ///< The velocityTuning field.
|
|
float rateTuning; ///< The rateTuning field.
|
|
|
|
VelocityCompensationControlRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VelocityCompensationControlRegister structure.
|
|
///
|
|
/// \param[in] modeIn Value to initialize the mode field with.
|
|
/// \param[in] velocityTuningIn Value to initialize the velocityTuning field with.
|
|
/// \param[in] rateTuningIn Value to initialize the rateTuning field with.
|
|
VelocityCompensationControlRegister(
|
|
protocol::uart::VelocityCompensationMode modeIn,
|
|
float velocityTuningIn,
|
|
float rateTuningIn) :
|
|
mode(modeIn),
|
|
velocityTuning(velocityTuningIn),
|
|
rateTuning(rateTuningIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Velocity Compensation Status register.
|
|
struct VelocityCompensationStatusRegister
|
|
{
|
|
float x; ///< The x field.
|
|
float xDot; ///< The xDot field.
|
|
vn::math::vec3f accelOffset; ///< The accelOffset field.
|
|
vn::math::vec3f omega; ///< The omega field.
|
|
|
|
VelocityCompensationStatusRegister() { }
|
|
|
|
/// \brief Creates an initializes a new VelocityCompensationStatusRegister structure.
|
|
///
|
|
/// \param[in] xIn Value to initialize the x field with.
|
|
/// \param[in] xDotIn Value to initialize the xDot field with.
|
|
/// \param[in] accelOffsetIn Value to initialize the accelOffset field with.
|
|
/// \param[in] omegaIn Value to initialize the omega field with.
|
|
VelocityCompensationStatusRegister(
|
|
float xIn,
|
|
float xDotIn,
|
|
vn::math::vec3f accelOffsetIn,
|
|
vn::math::vec3f omegaIn) :
|
|
x(xIn),
|
|
xDot(xDotIn),
|
|
accelOffset(accelOffsetIn),
|
|
omega(omegaIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the IMU Measurements register.
|
|
struct ImuMeasurementsRegister
|
|
{
|
|
vn::math::vec3f mag; ///< The mag field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
float temp; ///< The temp field.
|
|
float pressure; ///< The pressure field.
|
|
|
|
ImuMeasurementsRegister() { }
|
|
|
|
/// \brief Creates an initializes a new ImuMeasurementsRegister structure.
|
|
///
|
|
/// \param[in] magIn Value to initialize the mag field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
/// \param[in] tempIn Value to initialize the temp field with.
|
|
/// \param[in] pressureIn Value to initialize the pressure field with.
|
|
ImuMeasurementsRegister(
|
|
vn::math::vec3f magIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f gyroIn,
|
|
float tempIn,
|
|
float pressureIn) :
|
|
mag(magIn),
|
|
accel(accelIn),
|
|
gyro(gyroIn),
|
|
temp(tempIn),
|
|
pressure(pressureIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the GPS Configuration register.
|
|
struct GpsConfigurationRegister
|
|
{
|
|
protocol::uart::GpsMode mode; ///< The mode field.
|
|
protocol::uart::PpsSource ppsSource; ///< The ppsSource field.
|
|
protocol::uart::GpsRate rate; ///< The rate field.
|
|
protocol::uart::AntPower antPow; ///< The antPow field.
|
|
|
|
GpsConfigurationRegister() :
|
|
rate(protocol::uart::GPSRATE_5HZ),
|
|
antPow(protocol::uart::ANTPOWER_OFFRESV)
|
|
{ }
|
|
|
|
/// \brief Creates an initializes a new GpsConfigurationRegister structure (deprecated).
|
|
///
|
|
/// \param[in] modeIn Value to initialize the mode field with.
|
|
/// \param[in] ppsSourceIn Value to initialize the ppsSource field with.
|
|
GpsConfigurationRegister(
|
|
protocol::uart::GpsMode modeIn,
|
|
protocol::uart::PpsSource ppsSourceIn) :
|
|
mode(modeIn),
|
|
ppsSource(ppsSourceIn),
|
|
rate(protocol::uart::GPSRATE_5HZ),
|
|
antPow(protocol::uart::ANTPOWER_OFFRESV)
|
|
{ }
|
|
|
|
/// \brief Creates an initializes a new GpsConfigurationRegister structure.
|
|
///
|
|
/// \param[in] modeIn Value to initialize the mode field with.
|
|
/// \param[in] ppsSourceIn Value to initialize the ppsSource field with.
|
|
/// \param[in] rateIn Value to initialize the rate field with.
|
|
/// \param[in] antPowIn Value to initialize the antPow field with.
|
|
GpsConfigurationRegister(
|
|
protocol::uart::GpsMode modeIn,
|
|
protocol::uart::PpsSource ppsSourceIn,
|
|
protocol::uart::GpsRate rateIn,
|
|
protocol::uart::AntPower antPowIn) :
|
|
mode(modeIn),
|
|
ppsSource(ppsSourceIn),
|
|
rate(rateIn),
|
|
antPow(antPowIn)
|
|
{ }
|
|
};
|
|
|
|
/// \brief Structure representing the GPS Solution - LLA register.
|
|
struct GpsSolutionLlaRegister
|
|
{
|
|
double time; ///< The time field.
|
|
uint16_t week; ///< The week field.
|
|
protocol::uart::GpsFix gpsFix; ///< The gpsFix field.
|
|
uint8_t numSats; ///< The numSats field.
|
|
vn::math::vec3d lla; ///< The lla field.
|
|
vn::math::vec3f nedVel; ///< The nedVel field.
|
|
vn::math::vec3f nedAcc; ///< The nedAcc field.
|
|
float speedAcc; ///< The speedAcc field.
|
|
float timeAcc; ///< The timeAcc field.
|
|
|
|
GpsSolutionLlaRegister() { }
|
|
|
|
/// \brief Creates an initializes a new GpsSolutionLlaRegister structure.
|
|
///
|
|
/// \param[in] timeIn Value to initialize the time field with.
|
|
/// \param[in] weekIn Value to initialize the week field with.
|
|
/// \param[in] gpsFixIn Value to initialize the gpsFix field with.
|
|
/// \param[in] numSatsIn Value to initialize the numSats field with.
|
|
/// \param[in] llaIn Value to initialize the lla field with.
|
|
/// \param[in] nedVelIn Value to initialize the nedVel field with.
|
|
/// \param[in] nedAccIn Value to initialize the nedAcc field with.
|
|
/// \param[in] speedAccIn Value to initialize the speedAcc field with.
|
|
/// \param[in] timeAccIn Value to initialize the timeAcc field with.
|
|
GpsSolutionLlaRegister(
|
|
double timeIn,
|
|
uint16_t weekIn,
|
|
protocol::uart::GpsFix gpsFixIn,
|
|
uint8_t numSatsIn,
|
|
vn::math::vec3d llaIn,
|
|
vn::math::vec3f nedVelIn,
|
|
vn::math::vec3f nedAccIn,
|
|
float speedAccIn,
|
|
float timeAccIn) :
|
|
time(timeIn),
|
|
week(weekIn),
|
|
gpsFix(gpsFixIn),
|
|
numSats(numSatsIn),
|
|
lla(llaIn),
|
|
nedVel(nedVelIn),
|
|
nedAcc(nedAccIn),
|
|
speedAcc(speedAccIn),
|
|
timeAcc(timeAccIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the GPS Solution - ECEF register.
|
|
struct GpsSolutionEcefRegister
|
|
{
|
|
double tow; ///< The tow field.
|
|
uint16_t week; ///< The week field.
|
|
protocol::uart::GpsFix gpsFix; ///< The gpsFix field.
|
|
uint8_t numSats; ///< The numSats field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
vn::math::vec3f velocity; ///< The velocity field.
|
|
vn::math::vec3f posAcc; ///< The posAcc field.
|
|
float speedAcc; ///< The speedAcc field.
|
|
float timeAcc; ///< The timeAcc field.
|
|
|
|
GpsSolutionEcefRegister() { }
|
|
|
|
/// \brief Creates an initializes a new GpsSolutionEcefRegister structure.
|
|
///
|
|
/// \param[in] towIn Value to initialize the tow field with.
|
|
/// \param[in] weekIn Value to initialize the week field with.
|
|
/// \param[in] gpsFixIn Value to initialize the gpsFix field with.
|
|
/// \param[in] numSatsIn Value to initialize the numSats field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] velocityIn Value to initialize the velocity field with.
|
|
/// \param[in] posAccIn Value to initialize the posAcc field with.
|
|
/// \param[in] speedAccIn Value to initialize the speedAcc field with.
|
|
/// \param[in] timeAccIn Value to initialize the timeAcc field with.
|
|
GpsSolutionEcefRegister(
|
|
double towIn,
|
|
uint16_t weekIn,
|
|
protocol::uart::GpsFix gpsFixIn,
|
|
uint8_t numSatsIn,
|
|
vn::math::vec3d positionIn,
|
|
vn::math::vec3f velocityIn,
|
|
vn::math::vec3f posAccIn,
|
|
float speedAccIn,
|
|
float timeAccIn) :
|
|
tow(towIn),
|
|
week(weekIn),
|
|
gpsFix(gpsFixIn),
|
|
numSats(numSatsIn),
|
|
position(positionIn),
|
|
velocity(velocityIn),
|
|
posAcc(posAccIn),
|
|
speedAcc(speedAccIn),
|
|
timeAcc(timeAccIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS Solution - LLA register.
|
|
struct InsSolutionLlaRegister
|
|
{
|
|
double time; ///< The time field.
|
|
uint16_t week; ///< The week field.
|
|
uint16_t status; ///< The status field.
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
vn::math::vec3f nedVel; ///< The nedVel field.
|
|
float attUncertainty; ///< The attUncertainty field.
|
|
float posUncertainty; ///< The posUncertainty field.
|
|
float velUncertainty; ///< The velUncertainty field.
|
|
|
|
InsSolutionLlaRegister() { }
|
|
|
|
/// \brief Creates an initializes a new InsSolutionLlaRegister structure.
|
|
///
|
|
/// \param[in] timeIn Value to initialize the time field with.
|
|
/// \param[in] weekIn Value to initialize the week field with.
|
|
/// \param[in] statusIn Value to initialize the status field with.
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] nedVelIn Value to initialize the nedVel field with.
|
|
/// \param[in] attUncertaintyIn Value to initialize the attUncertainty field with.
|
|
/// \param[in] posUncertaintyIn Value to initialize the posUncertainty field with.
|
|
/// \param[in] velUncertaintyIn Value to initialize the velUncertainty field with.
|
|
InsSolutionLlaRegister(
|
|
double timeIn,
|
|
uint16_t weekIn,
|
|
uint16_t statusIn,
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3d positionIn,
|
|
vn::math::vec3f nedVelIn,
|
|
float attUncertaintyIn,
|
|
float posUncertaintyIn,
|
|
float velUncertaintyIn) :
|
|
time(timeIn),
|
|
week(weekIn),
|
|
status(statusIn),
|
|
yawPitchRoll(yawPitchRollIn),
|
|
position(positionIn),
|
|
nedVel(nedVelIn),
|
|
attUncertainty(attUncertaintyIn),
|
|
posUncertainty(posUncertaintyIn),
|
|
velUncertainty(velUncertaintyIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS Solution - ECEF register.
|
|
struct InsSolutionEcefRegister
|
|
{
|
|
double time; ///< The time field.
|
|
uint16_t week; ///< The week field.
|
|
uint16_t status; ///< The status field.
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
vn::math::vec3f velocity; ///< The velocity field.
|
|
float attUncertainty; ///< The attUncertainty field.
|
|
float posUncertainty; ///< The posUncertainty field.
|
|
float velUncertainty; ///< The velUncertainty field.
|
|
|
|
InsSolutionEcefRegister() { }
|
|
|
|
/// \brief Creates an initializes a new InsSolutionEcefRegister structure.
|
|
///
|
|
/// \param[in] timeIn Value to initialize the time field with.
|
|
/// \param[in] weekIn Value to initialize the week field with.
|
|
/// \param[in] statusIn Value to initialize the status field with.
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] velocityIn Value to initialize the velocity field with.
|
|
/// \param[in] attUncertaintyIn Value to initialize the attUncertainty field with.
|
|
/// \param[in] posUncertaintyIn Value to initialize the posUncertainty field with.
|
|
/// \param[in] velUncertaintyIn Value to initialize the velUncertainty field with.
|
|
InsSolutionEcefRegister(
|
|
double timeIn,
|
|
uint16_t weekIn,
|
|
uint16_t statusIn,
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3d positionIn,
|
|
vn::math::vec3f velocityIn,
|
|
float attUncertaintyIn,
|
|
float posUncertaintyIn,
|
|
float velUncertaintyIn) :
|
|
time(timeIn),
|
|
week(weekIn),
|
|
status(statusIn),
|
|
yawPitchRoll(yawPitchRollIn),
|
|
position(positionIn),
|
|
velocity(velocityIn),
|
|
attUncertainty(attUncertaintyIn),
|
|
posUncertainty(posUncertaintyIn),
|
|
velUncertainty(velUncertaintyIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS Basic Configuration register for a VN-200 sensor.
|
|
struct InsBasicConfigurationRegisterVn200
|
|
{
|
|
protocol::uart::Scenario scenario; ///< The scenario field.
|
|
bool ahrsAiding; ///< The ahrsAiding field.
|
|
|
|
InsBasicConfigurationRegisterVn200() { }
|
|
|
|
/// \brief Creates an initializes a new InsBasicConfigurationRegisterVn200 structure.
|
|
///
|
|
/// \param[in] scenarioIn Value to initialize the scenario field with.
|
|
/// \param[in] ahrsAidingIn Value to initialize the ahrsAiding field with.
|
|
InsBasicConfigurationRegisterVn200(
|
|
protocol::uart::Scenario scenarioIn,
|
|
bool ahrsAidingIn) :
|
|
scenario(scenarioIn),
|
|
ahrsAiding(ahrsAidingIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS Basic Configuration register for a VN-300 sensor.
|
|
struct InsBasicConfigurationRegisterVn300
|
|
{
|
|
protocol::uart::Scenario scenario; ///< The scenario field.
|
|
bool ahrsAiding; ///< The ahrsAiding field.
|
|
bool estBaseline; ///< The estBaseline field.
|
|
|
|
InsBasicConfigurationRegisterVn300() { }
|
|
|
|
/// \brief Creates an initializes a new InsBasicConfigurationRegisterVn300 structure.
|
|
///
|
|
/// \param[in] scenarioIn Value to initialize the scenario field with.
|
|
/// \param[in] ahrsAidingIn Value to initialize the ahrsAiding field with.
|
|
/// \param[in] estBaselineIn Value to initialize the estBaseline field with.
|
|
InsBasicConfigurationRegisterVn300(
|
|
protocol::uart::Scenario scenarioIn,
|
|
bool ahrsAidingIn,
|
|
bool estBaselineIn) :
|
|
scenario(scenarioIn),
|
|
ahrsAiding(ahrsAidingIn),
|
|
estBaseline(estBaselineIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS Advanced Configuration register.
|
|
struct InsAdvancedConfigurationRegister
|
|
{
|
|
bool useMag; ///< The useMag field.
|
|
bool usePres; ///< The usePres field.
|
|
bool posAtt; ///< The posAtt field.
|
|
bool velAtt; ///< The velAtt field.
|
|
bool velBias; ///< The velBias field.
|
|
protocol::uart::FoamInit useFoam; ///< The useFoam field.
|
|
uint8_t gpsCovType; ///< The gpsCovType field.
|
|
uint8_t velCount; ///< The velCount field.
|
|
float velInit; ///< The velInit field.
|
|
float moveOrigin; ///< The moveOrigin field.
|
|
float gpsTimeout; ///< The gpsTimeout field.
|
|
float deltaLimitPos; ///< The deltaLimitPos field.
|
|
float deltaLimitVel; ///< The deltaLimitVel field.
|
|
float minPosUncertainty; ///< The minPosUncertainty field.
|
|
float minVelUncertainty; ///< The minVelUncertainty field.
|
|
|
|
InsAdvancedConfigurationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new InsAdvancedConfigurationRegister structure.
|
|
///
|
|
/// \param[in] useMagIn Value to initialize the useMag field with.
|
|
/// \param[in] usePresIn Value to initialize the usePres field with.
|
|
/// \param[in] posAttIn Value to initialize the posAtt field with.
|
|
/// \param[in] velAttIn Value to initialize the velAtt field with.
|
|
/// \param[in] velBiasIn Value to initialize the velBias field with.
|
|
/// \param[in] useFoamIn Value to initialize the useFoam field with.
|
|
/// \param[in] gpsCovTypeIn Value to initialize the gpsCovType field with.
|
|
/// \param[in] velCountIn Value to initialize the velCount field with.
|
|
/// \param[in] velInitIn Value to initialize the velInit field with.
|
|
/// \param[in] moveOriginIn Value to initialize the moveOrigin field with.
|
|
/// \param[in] gpsTimeoutIn Value to initialize the gpsTimeout field with.
|
|
/// \param[in] deltaLimitPosIn Value to initialize the deltaLimitPos field with.
|
|
/// \param[in] deltaLimitVelIn Value to initialize the deltaLimitVel field with.
|
|
/// \param[in] minPosUncertaintyIn Value to initialize the minPosUncertainty field with.
|
|
/// \param[in] minVelUncertaintyIn Value to initialize the minVelUncertainty field with.
|
|
InsAdvancedConfigurationRegister(
|
|
bool useMagIn,
|
|
bool usePresIn,
|
|
bool posAttIn,
|
|
bool velAttIn,
|
|
bool velBiasIn,
|
|
protocol::uart::FoamInit useFoamIn,
|
|
uint8_t gpsCovTypeIn,
|
|
uint8_t velCountIn,
|
|
float velInitIn,
|
|
float moveOriginIn,
|
|
float gpsTimeoutIn,
|
|
float deltaLimitPosIn,
|
|
float deltaLimitVelIn,
|
|
float minPosUncertaintyIn,
|
|
float minVelUncertaintyIn) :
|
|
useMag(useMagIn),
|
|
usePres(usePresIn),
|
|
posAtt(posAttIn),
|
|
velAtt(velAttIn),
|
|
velBias(velBiasIn),
|
|
useFoam(useFoamIn),
|
|
gpsCovType(gpsCovTypeIn),
|
|
velCount(velCountIn),
|
|
velInit(velInitIn),
|
|
moveOrigin(moveOriginIn),
|
|
gpsTimeout(gpsTimeoutIn),
|
|
deltaLimitPos(deltaLimitPosIn),
|
|
deltaLimitVel(deltaLimitVelIn),
|
|
minPosUncertainty(minPosUncertaintyIn),
|
|
minVelUncertainty(minVelUncertaintyIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS State - LLA register.
|
|
struct InsStateLlaRegister
|
|
{
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
vn::math::vec3f velocity; ///< The velocity field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f angularRate; ///< The angularRate field.
|
|
|
|
InsStateLlaRegister() { }
|
|
|
|
/// \brief Creates an initializes a new InsStateLlaRegister structure.
|
|
///
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] velocityIn Value to initialize the velocity field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] angularRateIn Value to initialize the angularRate field with.
|
|
InsStateLlaRegister(
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3d positionIn,
|
|
vn::math::vec3f velocityIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f angularRateIn) :
|
|
yawPitchRoll(yawPitchRollIn),
|
|
position(positionIn),
|
|
velocity(velocityIn),
|
|
accel(accelIn),
|
|
angularRate(angularRateIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the INS State - ECEF register.
|
|
struct InsStateEcefRegister
|
|
{
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
vn::math::vec3f velocity; ///< The velocity field.
|
|
vn::math::vec3f accel; ///< The accel field.
|
|
vn::math::vec3f angularRate; ///< The angularRate field.
|
|
|
|
InsStateEcefRegister() { }
|
|
|
|
/// \brief Creates an initializes a new InsStateEcefRegister structure.
|
|
///
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] velocityIn Value to initialize the velocity field with.
|
|
/// \param[in] accelIn Value to initialize the accel field with.
|
|
/// \param[in] angularRateIn Value to initialize the angularRate field with.
|
|
InsStateEcefRegister(
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3d positionIn,
|
|
vn::math::vec3f velocityIn,
|
|
vn::math::vec3f accelIn,
|
|
vn::math::vec3f angularRateIn) :
|
|
yawPitchRoll(yawPitchRollIn),
|
|
position(positionIn),
|
|
velocity(velocityIn),
|
|
accel(accelIn),
|
|
angularRate(angularRateIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Startup Filter Bias Estimate register.
|
|
struct StartupFilterBiasEstimateRegister
|
|
{
|
|
vn::math::vec3f gyroBias; ///< The gyroBias field.
|
|
vn::math::vec3f accelBias; ///< The accelBias field.
|
|
float pressureBias; ///< The pressureBias field.
|
|
|
|
StartupFilterBiasEstimateRegister() { }
|
|
|
|
/// \brief Creates an initializes a new StartupFilterBiasEstimateRegister structure.
|
|
///
|
|
/// \param[in] gyroBiasIn Value to initialize the gyroBias field with.
|
|
/// \param[in] accelBiasIn Value to initialize the accelBias field with.
|
|
/// \param[in] pressureBiasIn Value to initialize the pressureBias field with.
|
|
StartupFilterBiasEstimateRegister(
|
|
vn::math::vec3f gyroBiasIn,
|
|
vn::math::vec3f accelBiasIn,
|
|
float pressureBiasIn) :
|
|
gyroBias(gyroBiasIn),
|
|
accelBias(accelBiasIn),
|
|
pressureBias(pressureBiasIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Delta Theta and Delta Velocity register.
|
|
struct DeltaThetaAndDeltaVelocityRegister
|
|
{
|
|
float deltaTime; ///< The deltaTime field.
|
|
vn::math::vec3f deltaTheta; ///< The deltaTheta field.
|
|
vn::math::vec3f deltaVelocity; ///< The deltaVelocity field.
|
|
|
|
DeltaThetaAndDeltaVelocityRegister() { }
|
|
|
|
/// \brief Creates an initializes a new DeltaThetaAndDeltaVelocityRegister structure.
|
|
///
|
|
/// \param[in] deltaTimeIn Value to initialize the deltaTime field with.
|
|
/// \param[in] deltaThetaIn Value to initialize the deltaTheta field with.
|
|
/// \param[in] deltaVelocityIn Value to initialize the deltaVelocity field with.
|
|
DeltaThetaAndDeltaVelocityRegister(
|
|
float deltaTimeIn,
|
|
vn::math::vec3f deltaThetaIn,
|
|
vn::math::vec3f deltaVelocityIn) :
|
|
deltaTime(deltaTimeIn),
|
|
deltaTheta(deltaThetaIn),
|
|
deltaVelocity(deltaVelocityIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Delta Theta and Delta Velocity Configuration register.
|
|
struct DeltaThetaAndDeltaVelocityConfigurationRegister
|
|
{
|
|
protocol::uart::IntegrationFrame integrationFrame; ///< The integrationFrame field.
|
|
protocol::uart::CompensationMode gyroCompensation; ///< The gyroCompensation field.
|
|
protocol::uart::AccCompensationMode accelCompensation; ///< The accelCompensation field.
|
|
protocol::uart::EarthRateCorrection earthRateCorrection; ///< The earthRateCorrection field.
|
|
|
|
DeltaThetaAndDeltaVelocityConfigurationRegister() :
|
|
earthRateCorrection(protocol::uart::EARTHRATECORR_NONE)
|
|
{ }
|
|
|
|
/// \brief Creates an initializes a new DeltaThetaAndDeltaVelocityConfigurationRegister structure (deprecated).
|
|
///
|
|
/// \param[in] integrationFrameIn Value to initialize the integrationFrame field with.
|
|
/// \param[in] gyroCompensationIn Value to initialize the gyroCompensation field with.
|
|
/// \param[in] accelCompensationIn Value to initialize the accelCompensation field with.
|
|
DeltaThetaAndDeltaVelocityConfigurationRegister(
|
|
protocol::uart::IntegrationFrame integrationFrameIn,
|
|
protocol::uart::CompensationMode gyroCompensationIn,
|
|
protocol::uart::AccCompensationMode accelCompensationIn) :
|
|
integrationFrame(integrationFrameIn),
|
|
gyroCompensation(gyroCompensationIn),
|
|
accelCompensation(accelCompensationIn),
|
|
earthRateCorrection(protocol::uart::EARTHRATECORR_NONE)
|
|
{ }
|
|
|
|
/// \brief Creates an initializes a new DeltaThetaAndDeltaVelocityConfigurationRegister structure.
|
|
///
|
|
/// \param[in] integrationFrameIn Value to initialize the integrationFrame field with.
|
|
/// \param[in] gyroCompensationIn Value to initialize the gyroCompensation field with.
|
|
/// \param[in] accelCompensationIn Value to initialize the accelCompensation field with.
|
|
/// \param[in] earthRateCorrection Value to initialize the earthRateCorrection field with.
|
|
DeltaThetaAndDeltaVelocityConfigurationRegister(
|
|
protocol::uart::IntegrationFrame integrationFrameIn,
|
|
protocol::uart::CompensationMode gyroCompensationIn,
|
|
protocol::uart::AccCompensationMode accelCompensationIn,
|
|
protocol::uart::EarthRateCorrection earthRateCorrectionIn) :
|
|
integrationFrame(integrationFrameIn),
|
|
gyroCompensation(gyroCompensationIn),
|
|
accelCompensation(accelCompensationIn),
|
|
earthRateCorrection(earthRateCorrectionIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Reference Vector Configuration register.
|
|
struct ReferenceVectorConfigurationRegister
|
|
{
|
|
bool useMagModel; ///< The useMagModel field.
|
|
bool useGravityModel; ///< The useGravityModel field.
|
|
uint32_t recalcThreshold; ///< The recalcThreshold field.
|
|
float year; ///< The year field.
|
|
vn::math::vec3d position; ///< The position field.
|
|
|
|
ReferenceVectorConfigurationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new ReferenceVectorConfigurationRegister structure.
|
|
///
|
|
/// \param[in] useMagModelIn Value to initialize the useMagModel field with.
|
|
/// \param[in] useGravityModelIn Value to initialize the useGravityModel field with.
|
|
/// \param[in] recalcThresholdIn Value to initialize the recalcThreshold field with.
|
|
/// \param[in] yearIn Value to initialize the year field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
ReferenceVectorConfigurationRegister(
|
|
bool useMagModelIn,
|
|
bool useGravityModelIn,
|
|
uint32_t recalcThresholdIn,
|
|
float yearIn,
|
|
vn::math::vec3d positionIn) :
|
|
useMagModel(useMagModelIn),
|
|
useGravityModel(useGravityModelIn),
|
|
recalcThreshold(recalcThresholdIn),
|
|
year(yearIn),
|
|
position(positionIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Gyro Compensation register.
|
|
struct GyroCompensationRegister
|
|
{
|
|
vn::math::mat3f c; ///< The c field.
|
|
vn::math::vec3f b; ///< The b field.
|
|
|
|
GyroCompensationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new GyroCompensationRegister structure.
|
|
///
|
|
/// \param[in] cIn Value to initialize the c field with.
|
|
/// \param[in] bIn Value to initialize the b field with.
|
|
GyroCompensationRegister(
|
|
vn::math::mat3f cIn,
|
|
vn::math::vec3f bIn) :
|
|
c(cIn),
|
|
b(bIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the IMU Filtering Configuration register.
|
|
struct ImuFilteringConfigurationRegister
|
|
{
|
|
uint16_t magWindowSize; ///< The magWindowSize field.
|
|
uint16_t accelWindowSize; ///< The accelWindowSize field.
|
|
uint16_t gyroWindowSize; ///< The gyroWindowSize field.
|
|
uint16_t tempWindowSize; ///< The tempWindowSize field.
|
|
uint16_t presWindowSize; ///< The presWindowSize field.
|
|
protocol::uart::FilterMode magFilterMode; ///< The magFilterMode field.
|
|
protocol::uart::FilterMode accelFilterMode; ///< The accelFilterMode field.
|
|
protocol::uart::FilterMode gyroFilterMode; ///< The gyroFilterMode field.
|
|
protocol::uart::FilterMode tempFilterMode; ///< The tempFilterMode field.
|
|
protocol::uart::FilterMode presFilterMode; ///< The presFilterMode field.
|
|
|
|
ImuFilteringConfigurationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new ImuFilteringConfigurationRegister structure.
|
|
///
|
|
/// \param[in] magWindowSizeIn Value to initialize the magWindowSize field with.
|
|
/// \param[in] accelWindowSizeIn Value to initialize the accelWindowSize field with.
|
|
/// \param[in] gyroWindowSizeIn Value to initialize the gyroWindowSize field with.
|
|
/// \param[in] tempWindowSizeIn Value to initialize the tempWindowSize field with.
|
|
/// \param[in] presWindowSizeIn Value to initialize the presWindowSize field with.
|
|
/// \param[in] magFilterModeIn Value to initialize the magFilterMode field with.
|
|
/// \param[in] accelFilterModeIn Value to initialize the accelFilterMode field with.
|
|
/// \param[in] gyroFilterModeIn Value to initialize the gyroFilterMode field with.
|
|
/// \param[in] tempFilterModeIn Value to initialize the tempFilterMode field with.
|
|
/// \param[in] presFilterModeIn Value to initialize the presFilterMode field with.
|
|
ImuFilteringConfigurationRegister(
|
|
uint16_t magWindowSizeIn,
|
|
uint16_t accelWindowSizeIn,
|
|
uint16_t gyroWindowSizeIn,
|
|
uint16_t tempWindowSizeIn,
|
|
uint16_t presWindowSizeIn,
|
|
protocol::uart::FilterMode magFilterModeIn,
|
|
protocol::uart::FilterMode accelFilterModeIn,
|
|
protocol::uart::FilterMode gyroFilterModeIn,
|
|
protocol::uart::FilterMode tempFilterModeIn,
|
|
protocol::uart::FilterMode presFilterModeIn) :
|
|
magWindowSize(magWindowSizeIn),
|
|
accelWindowSize(accelWindowSizeIn),
|
|
gyroWindowSize(gyroWindowSizeIn),
|
|
tempWindowSize(tempWindowSizeIn),
|
|
presWindowSize(presWindowSizeIn),
|
|
magFilterMode(magFilterModeIn),
|
|
accelFilterMode(accelFilterModeIn),
|
|
gyroFilterMode(gyroFilterModeIn),
|
|
tempFilterMode(tempFilterModeIn),
|
|
presFilterMode(presFilterModeIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the GPS Compass Baseline register.
|
|
struct GpsCompassBaselineRegister
|
|
{
|
|
vn::math::vec3f position; ///< The position field.
|
|
vn::math::vec3f uncertainty; ///< The uncertainty field.
|
|
|
|
GpsCompassBaselineRegister() { }
|
|
|
|
/// \brief Creates an initializes a new GpsCompassBaselineRegister structure.
|
|
///
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] uncertaintyIn Value to initialize the uncertainty field with.
|
|
GpsCompassBaselineRegister(
|
|
vn::math::vec3f positionIn,
|
|
vn::math::vec3f uncertaintyIn) :
|
|
position(positionIn),
|
|
uncertainty(uncertaintyIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the GPS Compass Estimated Baseline register.
|
|
struct GpsCompassEstimatedBaselineRegister
|
|
{
|
|
bool estBaselineUsed; ///< The estBaselineUsed field.
|
|
uint16_t numMeas; ///< The numMeas field.
|
|
vn::math::vec3f position; ///< The position field.
|
|
vn::math::vec3f uncertainty; ///< The uncertainty field.
|
|
|
|
GpsCompassEstimatedBaselineRegister() { }
|
|
|
|
/// \brief Creates an initializes a new GpsCompassEstimatedBaselineRegister structure.
|
|
///
|
|
/// \param[in] estBaselineUsedIn Value to initialize the estBaselineUsed field with.
|
|
/// \param[in] numMeasIn Value to initialize the numMeas field with.
|
|
/// \param[in] positionIn Value to initialize the position field with.
|
|
/// \param[in] uncertaintyIn Value to initialize the uncertainty field with.
|
|
GpsCompassEstimatedBaselineRegister(
|
|
bool estBaselineUsedIn,
|
|
uint16_t numMeasIn,
|
|
vn::math::vec3f positionIn,
|
|
vn::math::vec3f uncertaintyIn) :
|
|
estBaselineUsed(estBaselineUsedIn),
|
|
numMeas(numMeasIn),
|
|
position(positionIn),
|
|
uncertainty(uncertaintyIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the IMU Rate Configuration register.
|
|
struct ImuRateConfigurationRegister
|
|
{
|
|
uint16_t imuRate; ///< The imuRate field.
|
|
uint16_t navDivisor; ///< The navDivisor field.
|
|
float filterTargetRate; ///< The filterTargetRate field.
|
|
float filterMinRate; ///< The filterMinRate field.
|
|
|
|
ImuRateConfigurationRegister() { }
|
|
|
|
/// \brief Creates an initializes a new ImuRateConfigurationRegister structure.
|
|
///
|
|
/// \param[in] imuRateIn Value to initialize the imuRate field with.
|
|
/// \param[in] navDivisorIn Value to initialize the navDivisor field with.
|
|
/// \param[in] filterTargetRateIn Value to initialize the filterTargetRate field with.
|
|
/// \param[in] filterMinRateIn Value to initialize the filterMinRate field with.
|
|
ImuRateConfigurationRegister(
|
|
uint16_t imuRateIn,
|
|
uint16_t navDivisorIn,
|
|
float filterTargetRateIn,
|
|
float filterMinRateIn) :
|
|
imuRate(imuRateIn),
|
|
navDivisor(navDivisorIn),
|
|
filterTargetRate(filterTargetRateIn),
|
|
filterMinRate(filterMinRateIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Yaw, Pitch, Roll, True Body Acceleration and Angular Rates register.
|
|
struct YawPitchRollTrueBodyAccelerationAndAngularRatesRegister
|
|
{
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3f bodyAccel; ///< The bodyAccel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
|
|
YawPitchRollTrueBodyAccelerationAndAngularRatesRegister() { }
|
|
|
|
/// \brief Creates an initializes a new YawPitchRollTrueBodyAccelerationAndAngularRatesRegister structure.
|
|
///
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] bodyAccelIn Value to initialize the bodyAccel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
YawPitchRollTrueBodyAccelerationAndAngularRatesRegister(
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3f bodyAccelIn,
|
|
vn::math::vec3f gyroIn) :
|
|
yawPitchRoll(yawPitchRollIn),
|
|
bodyAccel(bodyAccelIn),
|
|
gyro(gyroIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \brief Structure representing the Yaw, Pitch, Roll, True Inertial Acceleration and Angular Rates register.
|
|
struct YawPitchRollTrueInertialAccelerationAndAngularRatesRegister
|
|
{
|
|
vn::math::vec3f yawPitchRoll; ///< The yawPitchRoll field.
|
|
vn::math::vec3f inertialAccel; ///< The inertialAccel field.
|
|
vn::math::vec3f gyro; ///< The gyro field.
|
|
|
|
YawPitchRollTrueInertialAccelerationAndAngularRatesRegister() { }
|
|
|
|
/// \brief Creates an initializes a new YawPitchRollTrueInertialAccelerationAndAngularRatesRegister structure.
|
|
///
|
|
/// \param[in] yawPitchRollIn Value to initialize the yawPitchRoll field with.
|
|
/// \param[in] inertialAccelIn Value to initialize the inertialAccel field with.
|
|
/// \param[in] gyroIn Value to initialize the gyro field with.
|
|
YawPitchRollTrueInertialAccelerationAndAngularRatesRegister(
|
|
vn::math::vec3f yawPitchRollIn,
|
|
vn::math::vec3f inertialAccelIn,
|
|
vn::math::vec3f gyroIn) :
|
|
yawPitchRoll(yawPitchRollIn),
|
|
inertialAccel(inertialAccelIn),
|
|
gyro(gyroIn)
|
|
{ }
|
|
|
|
};
|
|
|
|
/// \}
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|