sensors.h

Go to the documentation of this file.

#ifndef _VNSENSORS_H_
#define _VNSENSORS_H_

#include <stddef.h>

#include "vn/int.h"
#include "vn/error.h"
#include "vn/enum.h"
#include "vn/bool.h"
#include "vn/protocol/upack.h"
#include "vn/protocol/upackf.h"
#include "vn/xplat/serialport.h"
#include "vn/xplat/event.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4820)
#endif

typedef struct
{
    AsyncMode asyncMode;            
    uint16_t rateDivisor;           
    CommonGroup commonField;        
    TimeGroup timeField;            
    ImuGroup imuField;              
    GpsGroup gpsField;              
    AttitudeGroup attitudeField;    
    InsGroup insField;              
} BinaryOutputRegister;

void BinaryOutputRegister_initialize(
    BinaryOutputRegister *reg,
    AsyncMode asyncMode,
    uint32_t rateDivisor,
    CommonGroup commonField,
    TimeGroup timeField,
    ImuGroup imuField,
    GpsGroup gpsField,
    AttitudeGroup attitudeField,
    InsGroup insField);

typedef struct
{
    vec4f quat;

    vec3f mag;

    vec3f accel;

    vec3f gyro;

} QuaternionMagneticAccelerationAndAngularRatesRegister;

typedef struct
{
    vec3f mag;

    vec3f accel;

    vec3f gyro;

} MagneticAccelerationAndAngularRatesRegister;

typedef struct
{
    vec3f magRef;

    vec3f accRef;

} MagneticAndGravityReferenceVectorsRegister;

typedef struct
{
    float angularWalkVariance;

    vec3f angularRateVariance;

    vec3f magneticVariance;

    vec3f accelerationVariance;

} FilterMeasurementsVarianceParametersRegister;

typedef struct
{
    mat3f c;

    vec3f b;

} MagnetometerCompensationRegister;

typedef struct
{
    float magneticDisturbanceGain;

    float accelerationDisturbanceGain;

    float magneticDisturbanceMemory;

    float accelerationDisturbanceMemory;

} FilterActiveTuningParametersRegister;

typedef struct
{
    mat3f c;

    vec3f b;

} AccelerationCompensationRegister;

typedef struct
{
    vec3f yawPitchRoll;

    vec3f mag;

    vec3f accel;

    vec3f gyro;

} YawPitchRollMagneticAccelerationAndAngularRatesRegister;

typedef struct
{
    uint8_t serialCount;

    uint8_t serialStatus;

    uint8_t spiCount;

    uint8_t spiStatus;

    uint8_t serialChecksum;

    uint8_t spiChecksum;

    uint8_t errorMode;

} CommunicationProtocolControlRegister;

typedef struct
{
    uint8_t syncInMode;

    uint8_t syncInEdge;

    uint16_t syncInSkipFactor;

    uint8_t syncOutMode;

    uint8_t syncOutPolarity;

    uint16_t syncOutSkipFactor;

    uint32_t syncOutPulseWidth;

} SynchronizationControlRegister;

typedef struct
{
    uint32_t syncInCount;

    uint32_t syncInTime;

    uint32_t syncOutCount;

} SynchronizationStatusRegister;

typedef struct
{
    uint8_t magMode;

    uint8_t extMagMode;

    uint8_t extAccMode;

    uint8_t extGyroMode;

    vec3f gyroLimit;

} FilterBasicControlRegister;

typedef struct
{
    uint8_t enable;

    uint8_t headingMode;

    uint8_t filteringMode;

    uint8_t tuningMode;

} VpeBasicControlRegister;

typedef struct
{
    vec3f baseTuning;

    vec3f adaptiveTuning;

    vec3f adaptiveFiltering;

} VpeMagnetometerBasicTuningRegister;

typedef struct
{
    vec3f minFiltering;

    vec3f maxFiltering;

    float maxAdaptRate;

    float disturbanceWindow;

    float maxTuning;

} VpeMagnetometerAdvancedTuningRegister;

typedef struct
{
    vec3f baseTuning;

    vec3f adaptiveTuning;

    vec3f adaptiveFiltering;

} VpeAccelerometerBasicTuningRegister;

typedef struct
{
    vec3f minFiltering;

    vec3f maxFiltering;

    float maxAdaptRate;

    float disturbanceWindow;

    float maxTuning;

} VpeAccelerometerAdvancedTuningRegister;

typedef struct
{
    vec3f angularWalkVariance;

    vec3f baseTuning;

    vec3f adaptiveTuning;

} VpeGyroBasicTuningRegister;

typedef struct
{
    uint8_t hsiMode;

    uint8_t hsiOutput;

    uint8_t convergeRate;

} MagnetometerCalibrationControlRegister;

typedef struct
{
    mat3f c;

    vec3f b;

} CalculatedMagnetometerCalibrationRegister;

typedef struct
{
    uint8_t mode;

    float velocityTuning;

    float rateTuning;

} VelocityCompensationControlRegister;

typedef struct
{
    float x;

    float xDot;

    vec3f accelOffset;

    vec3f omega;

} VelocityCompensationStatusRegister;

typedef struct
{
    vec3f mag;

    vec3f accel;

    vec3f gyro;

    float temp;

    float pressure;

} ImuMeasurementsRegister;

typedef struct
{
    uint8_t mode;

    uint8_t ppsSource;

} GpsConfigurationRegister;

typedef struct
{
    double time;

    uint16_t week;

    uint8_t gpsFix;

    uint8_t numSats;

    vec3d lla;

    vec3f nedVel;

    vec3f nedAcc;

    float speedAcc;

    float timeAcc;

} GpsSolutionLlaRegister;

typedef struct
{
    double tow;

    uint16_t week;

    uint8_t gpsFix;

    uint8_t numSats;

    vec3d position;

    vec3f velocity;

    vec3f posAcc;

    float speedAcc;

    float timeAcc;

} GpsSolutionEcefRegister;

typedef struct
{
    double time;

    uint16_t week;

    uint16_t status;

    vec3f yawPitchRoll;

    vec3d position;

    vec3f nedVel;

    float attUncertainty;

    float posUncertainty;

    float velUncertainty;

} InsSolutionLlaRegister;

typedef struct
{
    double time;

    uint16_t week;

    uint16_t status;

    vec3f yawPitchRoll;

    vec3d position;

    vec3f velocity;

    float attUncertainty;

    float posUncertainty;

    float velUncertainty;

} InsSolutionEcefRegister;

typedef struct
{
    uint8_t scenario;

    uint8_t ahrsAiding;

} InsBasicConfigurationRegisterVn200;

typedef struct
{
    uint8_t scenario;

    uint8_t ahrsAiding;

    uint8_t estBaseline;

} InsBasicConfigurationRegisterVn300;

typedef struct
{
    uint8_t useMag;

    uint8_t usePres;

    uint8_t posAtt;

    uint8_t velAtt;

    uint8_t velBias;

    uint8_t useFoam;

    uint8_t gpsCovType;

    uint8_t velCount;

    float velInit;

    float moveOrigin;

    float gpsTimeout;

    float deltaLimitPos;

    float deltaLimitVel;

    float minPosUncertainty;

    float minVelUncertainty;

} InsAdvancedConfigurationRegister;

typedef struct
{
    vec3f yawPitchRoll;

    vec3d position;

    vec3f velocity;

    vec3f accel;

    vec3f angularRate;

} InsStateLlaRegister;

typedef struct
{
    vec3f yawPitchRoll;

    vec3d position;

    vec3f velocity;

    vec3f accel;

    vec3f angularRate;

} InsStateEcefRegister;

typedef struct
{
    vec3f gyroBias;

    vec3f accelBias;

    float pressureBias;

} StartupFilterBiasEstimateRegister;

typedef struct
{
    float deltaTime;

    vec3f deltaTheta;

    vec3f deltaVelocity;

} DeltaThetaAndDeltaVelocityRegister;

typedef struct
{
    uint8_t integrationFrame;

    uint8_t gyroCompensation;

    uint8_t accelCompensation;

} DeltaThetaAndDeltaVelocityConfigurationRegister;

typedef struct
{
    uint8_t useMagModel;

    uint8_t useGravityModel;

    uint32_t recalcThreshold;

    float year;

    vec3d position;

} ReferenceVectorConfigurationRegister;

typedef struct
{
    mat3f c;

    vec3f b;

} GyroCompensationRegister;

typedef struct
{
    uint16_t magWindowSize;

    uint16_t accelWindowSize;

    uint16_t gyroWindowSize;

    uint16_t tempWindowSize;

    uint16_t presWindowSize;

    uint8_t magFilterMode;

    uint8_t accelFilterMode;

    uint8_t gyroFilterMode;

    uint8_t tempFilterMode;

    uint8_t presFilterMode;

} ImuFilteringConfigurationRegister;

typedef struct
{
    vec3f position;

    vec3f uncertainty;

} GpsCompassBaselineRegister;

typedef struct
{
    uint8_t estBaselineUsed;

    uint16_t numMeas;

    vec3f position;

    vec3f uncertainty;

} GpsCompassEstimatedBaselineRegister;

typedef struct
{
    uint16_t imuRate;

    uint16_t navDivisor;

    float filterTargetRate;

    float filterMinRate;

} ImuRateConfigurationRegister;

typedef struct
{
    vec3f yawPitchRoll;

    vec3f bodyAccel;

    vec3f gyro;

} YawPitchRollTrueBodyAccelerationAndAngularRatesRegister;

typedef struct
{
    vec3f yawPitchRoll;

    vec3f inertialAccel;

    vec3f gyro;

} YawPitchRollTrueInertialAccelerationAndAngularRatesRegister;

/* \} */

typedef void (*VnSensor_PacketFoundHandler)(void *userData, VnUartPacket *packet, size_t runningIndex);

typedef struct
{
    VnSerialPort serialPort;

    /* Error detection mode to use for outgoing packets. */
    VnErrorDetectionMode sendErrorDetectionMode;

    /* Timeout duration for waiting for a response from the sensor. */
    uint16_t responseTimeoutMs;

    /* Delay between retransmitting commands. */
    uint16_t retransmitDelayMs;

    VnCriticalSection transactionCS;

    VnEvent newResponsesEvent;

    /* Indicates if the transaction function is waiting for a response. */
    bool waitingForResponse;

    /* Indicates if a response is waiting for processing by the transaction functions. */
    bool responseWaitingForProcessing;

    size_t runningDataIndex;

    VnUartPacketFinder packetFinder;

    VnSensor_PacketFoundHandler asyncPacketFoundHandler;
    void *asyncPacketFoundHandlerUserData;

    VnSensor_PacketFoundHandler errorMessageReceivedHandler;
    void *errorMessageReceivedHandlerUserData;

    size_t responseLength;

    /* Holds any received response from the sensor for processing in our transaction functions. */
    char response[0x100];

} VnSensor;

VnError VnSensor_initialize(VnSensor* sensor);

VnError VnSensor_connect(VnSensor* sensor, const char* portName, uint32_t baudrate);

VnError VnSensor_disconnect(VnSensor* sensor);

VnError VnSensor_changeBaudrate(VnSensor* sensor, uint32_t baudrate);

VnError VnSensor_transaction(VnSensor* sensor, char* toSend, size_t toSendLength, char* response, size_t* responseLength);

bool VnSensor_isConnected(VnSensor* sensor);

VnError VnSensor_writeSettings(VnSensor* sensor, bool waitForReply);

VnError VnSensor_restoreFactorySettings(VnSensor* sensor, bool waitForReply);

VnError VnSensor_reset(VnSensor* sensor, bool waitForReply);

VnError VnSensor_tare(VnSensor* sensor, bool waitForReply);

VnError VnSensor_setGyroBias(VnSensor* sensor, bool waitForReply);

VnError VnSensor_magneticDisturbancePresent(VnSensor* sensor, bool disturbancePresent, bool waitForReply);

VnError VnSensor_accelerationDisturbancePresent(VnSensor* sensor, bool disturbancePresent, bool waitForReply);

bool VnSensor_verifySensorConnectivity(VnSensor* sensor);

uint16_t VnSensor_getResponseTimeoutMs(VnSensor* sensor);

VnError VnSensor_setResponseTimeoutMs(VnSensor* sensor, uint16_t reponseTimeoutMs);

uint16_t VnSensor_getRetransmitDelayMs(VnSensor* sensor);

VnError VnSensor_setRetransmitDelayMs(VnSensor* sensor, uint16_t retransmitDelayMs);

VnError VnSensor_registerAsyncPacketReceivedHandler(VnSensor *sensor, VnSensor_PacketFoundHandler handler, void *userData);

VnError VnSensor_unregisterAsyncPacketReceivedHandler(VnSensor *sensor);

VnError VnSensor_registerErrorPacketReceivedHandler(VnSensor *sensor, VnSensor_PacketFoundHandler handler, void *userData);

VnError VnSensor_unregisterErrorPacketReceivedHandler(VnSensor *sensor);

VnError VnSensor_readBinaryOutput1(VnSensor *sensor, BinaryOutputRegister *fields);

VnError VnSensor_writeBinaryOutput1(VnSensor *sensor, BinaryOutputRegister *fields, bool waitForReply);

VnError VnSensor_readBinaryOutput2(VnSensor *sensor, BinaryOutputRegister *fields);

VnError VnSensor_writeBinaryOutput2(VnSensor *sensor, BinaryOutputRegister *fields, bool waitForReply);

VnError VnSensor_readBinaryOutput3(VnSensor *sensor, BinaryOutputRegister *fields);

VnError VnSensor_writeBinaryOutput3(VnSensor *sensor, BinaryOutputRegister *fields, bool waitForReply);

#ifdef EXTRA

VnError VnSensor_readBinaryOutput4(VnSensor *sensor, BinaryOutputRegister *fields);

VnError VnSensor_writeBinaryOutput4(VnSensor *sensor, BinaryOutputRegister *fields, bool waitForReply);

VnError VnSensor_readBinaryOutput5(VnSensor *sensor, BinaryOutputRegister *fields);

VnError VnSensor_writeBinaryOutput5(VnSensor *sensor, BinaryOutputRegister *fields, bool waitForReply);

#endif

VnError VnSensor_readUserTag(VnSensor *sensor, char *tagBuffer, size_t tagBufferLength);

VnError VnSensor_writeUserTag(VnSensor *sensor, char* tag, bool waitForReply);

VnError VnSensor_readModelNumber(VnSensor *sensor, char *productNameBuffer, size_t productNameBufferLength);

VnError VnSensor_readHardwareRevision(VnSensor *sensor, uint32_t *revision);

VnError VnSensor_readSerialNumber(VnSensor *sensor, uint32_t *serialNum);

VnError VnSensor_readFirmwareVersion(VnSensor *sensor, char *firmwareVersionBuffer, size_t firmwareVersionBufferLength);

VnError VnSensor_readSerialBaudRate(VnSensor *sensor, uint32_t *baudrate);

VnError VnSensor_writeSerialBaudRate(VnSensor *sensor, uint32_t baudrate, bool waitForReply);

VnError VnSensor_readAsyncDataOutputType(VnSensor *sensor, VnAsciiAsync *ador);

VnError VnSensor_writeAsyncDataOutputType(VnSensor *sensor, VnAsciiAsync ador, bool waitForReply);

VnError VnSensor_readAsyncDataOutputFrequency(VnSensor *sensor, uint32_t *adof);

VnError VnSensor_writeAsyncDataOutputFrequency(VnSensor *sensor, uint32_t adof, bool waitForReply);

VnError VnSensor_readYawPitchRoll(VnSensor *sensor, vec3f *yawPitchRoll);

VnError VnSensor_readAttitudeQuaternion(VnSensor *sensor, vec4f *quat);

VnError VnSensor_readQuaternionMagneticAccelerationAndAngularRates(VnSensor *sensor, QuaternionMagneticAccelerationAndAngularRatesRegister *fields);

VnError VnSensor_readMagneticMeasurements(VnSensor *sensor, vec3f *mag);

VnError VnSensor_readAccelerationMeasurements(VnSensor *sensor, vec3f *accel);

VnError VnSensor_readAngularRateMeasurements(VnSensor *sensor, vec3f *gyro);

VnError VnSensor_readMagneticAccelerationAndAngularRates(VnSensor *sensor, MagneticAccelerationAndAngularRatesRegister *fields);

VnError VnSensor_readMagneticAndGravityReferenceVectors(VnSensor *sensor, MagneticAndGravityReferenceVectorsRegister *fields);

VnError VnSensor_writeMagneticAndGravityReferenceVectors(VnSensor *sensor, MagneticAndGravityReferenceVectorsRegister fields, bool waitForReply);

VnError VnSensor_readMagnetometerCompensation(VnSensor *sensor, MagnetometerCompensationRegister *fields);

VnError VnSensor_writeMagnetometerCompensation(VnSensor *sensor, MagnetometerCompensationRegister fields, bool waitForReply);

VnError VnSensor_readAccelerationCompensation(VnSensor *sensor, AccelerationCompensationRegister *fields);

VnError VnSensor_writeAccelerationCompensation(VnSensor *sensor, AccelerationCompensationRegister fields, bool waitForReply);

VnError VnSensor_readReferenceFrameRotation(VnSensor *sensor, mat3f *c);

VnError VnSensor_writeReferenceFrameRotation(VnSensor *sensor, mat3f c, bool waitForReply);

VnError VnSensor_readYawPitchRollMagneticAccelerationAndAngularRates(VnSensor *sensor, YawPitchRollMagneticAccelerationAndAngularRatesRegister *fields);

VnError VnSensor_readCommunicationProtocolControl(VnSensor *sensor, CommunicationProtocolControlRegister *fields);

VnError VnSensor_writeCommunicationProtocolControl(VnSensor *sensor, CommunicationProtocolControlRegister fields, bool waitForReply);

VnError VnSensor_readSynchronizationControl(VnSensor *sensor, SynchronizationControlRegister *fields);

VnError VnSensor_writeSynchronizationControl(VnSensor *sensor, SynchronizationControlRegister fields, bool waitForReply);

VnError VnSensor_readSynchronizationStatus(VnSensor *sensor, SynchronizationStatusRegister *fields);

VnError VnSensor_writeSynchronizationStatus(VnSensor *sensor, SynchronizationStatusRegister fields, bool waitForReply);

VnError VnSensor_readVpeBasicControl(VnSensor *sensor, VpeBasicControlRegister *fields);

VnError VnSensor_writeVpeBasicControl(VnSensor *sensor, VpeBasicControlRegister fields, bool waitForReply);

VnError VnSensor_readVpeMagnetometerBasicTuning(VnSensor *sensor, VpeMagnetometerBasicTuningRegister *fields);

VnError VnSensor_writeVpeMagnetometerBasicTuning(VnSensor *sensor, VpeMagnetometerBasicTuningRegister fields, bool waitForReply);

VnError VnSensor_readVpeAccelerometerBasicTuning(VnSensor *sensor, VpeAccelerometerBasicTuningRegister *fields);

VnError VnSensor_writeVpeAccelerometerBasicTuning(VnSensor *sensor, VpeAccelerometerBasicTuningRegister fields, bool waitForReply);

VnError VnSensor_readMagnetometerCalibrationControl(VnSensor *sensor, MagnetometerCalibrationControlRegister *fields);

VnError VnSensor_writeMagnetometerCalibrationControl(VnSensor *sensor, MagnetometerCalibrationControlRegister fields, bool waitForReply);

VnError VnSensor_readCalculatedMagnetometerCalibration(VnSensor *sensor, CalculatedMagnetometerCalibrationRegister *fields);

VnError VnSensor_readVelocityCompensationMeasurement(VnSensor *sensor, vec3f *velocity);

VnError VnSensor_writeVelocityCompensationMeasurement(VnSensor *sensor, vec3f velocity, bool waitForReply);

VnError VnSensor_readVelocityCompensationControl(VnSensor *sensor, VelocityCompensationControlRegister *fields);

VnError VnSensor_writeVelocityCompensationControl(VnSensor *sensor, VelocityCompensationControlRegister fields, bool waitForReply);

VnError VnSensor_readImuMeasurements(VnSensor *sensor, ImuMeasurementsRegister *fields);

VnError VnSensor_readGpsConfiguration(VnSensor *sensor, GpsConfigurationRegister *fields);

VnError VnSensor_writeGpsConfiguration(VnSensor *sensor, GpsConfigurationRegister fields, bool waitForReply);

VnError VnSensor_readGpsAntennaOffset(VnSensor *sensor, vec3f *position);

VnError VnSensor_writeGpsAntennaOffset(VnSensor *sensor, vec3f position, bool waitForReply);

VnError VnSensor_readGpsSolutionLla(VnSensor *sensor, GpsSolutionLlaRegister *fields);

VnError VnSensor_readGpsSolutionEcef(VnSensor *sensor, GpsSolutionEcefRegister *fields);

VnError VnSensor_readInsSolutionLla(VnSensor *sensor, InsSolutionLlaRegister *fields);

VnError VnSensor_readInsSolutionEcef(VnSensor *sensor, InsSolutionEcefRegister *fields);

VnError VnSensor_readInsBasicConfigurationVn200(VnSensor *sensor, InsBasicConfigurationRegisterVn200 *fields);

VnError VnSensor_writeInsBasicConfigurationVn200(VnSensor *sensor, InsBasicConfigurationRegisterVn200 fields, bool waitForReply);

VnError VnSensor_readInsBasicConfigurationVn300(VnSensor *sensor, InsBasicConfigurationRegisterVn300 *fields);

VnError VnSensor_writeInsBasicConfigurationVn300(VnSensor *sensor, InsBasicConfigurationRegisterVn300 fields, bool waitForReply);

VnError VnSensor_readInsStateLla(VnSensor *sensor, InsStateLlaRegister *fields);

VnError VnSensor_readInsStateEcef(VnSensor *sensor, InsStateEcefRegister *fields);

VnError VnSensor_readStartupFilterBiasEstimate(VnSensor *sensor, StartupFilterBiasEstimateRegister *fields);

VnError VnSensor_writeStartupFilterBiasEstimate(VnSensor *sensor, StartupFilterBiasEstimateRegister fields, bool waitForReply);

VnError VnSensor_readDeltaThetaAndDeltaVelocity(VnSensor *sensor, DeltaThetaAndDeltaVelocityRegister *fields);

VnError VnSensor_readDeltaThetaAndDeltaVelocityConfiguration(VnSensor *sensor, DeltaThetaAndDeltaVelocityConfigurationRegister *fields);

VnError VnSensor_writeDeltaThetaAndDeltaVelocityConfiguration(VnSensor *sensor, DeltaThetaAndDeltaVelocityConfigurationRegister fields, bool waitForReply);

VnError VnSensor_readReferenceVectorConfiguration(VnSensor *sensor, ReferenceVectorConfigurationRegister *fields);

VnError VnSensor_writeReferenceVectorConfiguration(VnSensor *sensor, ReferenceVectorConfigurationRegister fields, bool waitForReply);

VnError VnSensor_readGyroCompensation(VnSensor *sensor, GyroCompensationRegister *fields);

VnError VnSensor_writeGyroCompensation(VnSensor *sensor, GyroCompensationRegister fields, bool waitForReply);

VnError VnSensor_readImuFilteringConfiguration(VnSensor *sensor, ImuFilteringConfigurationRegister *fields);

VnError VnSensor_writeImuFilteringConfiguration(VnSensor *sensor, ImuFilteringConfigurationRegister fields, bool waitForReply);

VnError VnSensor_readGpsCompassBaseline(VnSensor *sensor, GpsCompassBaselineRegister *fields);

VnError VnSensor_writeGpsCompassBaseline(VnSensor *sensor, GpsCompassBaselineRegister fields, bool waitForReply);

VnError VnSensor_readGpsCompassEstimatedBaseline(VnSensor *sensor, GpsCompassEstimatedBaselineRegister *fields);

VnError VnSensor_readYawPitchRollTrueBodyAccelerationAndAngularRates(VnSensor *sensor, YawPitchRollTrueBodyAccelerationAndAngularRatesRegister *fields);

VnError VnSensor_readYawPitchRollTrueInertialAccelerationAndAngularRates(VnSensor *sensor, YawPitchRollTrueInertialAccelerationAndAngularRatesRegister *fields);

void strFromSensorError(char *out, SensorError val);

void strFromSyncInMode(char *out, VnSyncInMode val);

void strFromSyncInEdge(char *out, VnSyncInEdge val);

void strFromSyncOutMode(char *out, VnSyncOutMode val);

void strFromSyncOutPolarity(char *out, VnSyncOutPolarity val);

void strFromCountMode(char *out, VnCountMode val);

void strFromStatusMode(char *out, VnStatusMode val);

void strFromChecksumMode(char *out, VnChecksumMode val);

void strFromErrorMode(char *out, VnErrorMode val);

void strFromFilterMode(char *out, VnFilterMode val);

void strFromIntegrationFrame(char *out, VnIntegrationFrame val);

void strFromCompensationMode(char *out, VnCompensationMode val);

void strFromGpsFix(char *out, VnGpsFix val);

void strFromGpsMode(char *out, VnGpsMode val);

void strFromPpsSource(char *out, VnPpsSource val);

void strFromVpeEnable(char *out, VnVpeEnable val);

void strFromHeadingMode(char *out, VnHeadingMode val);

void strFromVpeMode(char *out, VnVpeMode val);

void strFromScenario(char *out, VnScenario val);

void strFromHsiMode(char *out, VnHsiMode val);

void strFromHsiOutput(char *out, VnHsiOutput val);

void strFromVelocityCompensationMode(char *out, VnVelocityCompensationMode val);

void strFromMagneticMode(char *out, VnMagneticMode val);

void strFromExternalSensorMode(char *out, VnExternalSensorMode val);

void strFromFoamInit(char *out, VnFoamInit val);

#ifdef __cplusplus
}
#endif

#ifdef _WIN32
#pragma warning(pop)
#endif

#endif