upack.h

#ifndef VNUPACK_H_INCLUDED
#define VNUPACK_H_INCLUDED

#include <stdarg.h>

#include "vn/int.h"
#include "vn/bool.h"
#include "vn/enum.h"
#include "vn/error.h"
#include "vn/error_detection.h"
#include "vn/math/matrix.h"
#include "vn/math/vector.h"
#include "vn/protocol/common.h"

#ifndef VNUART_PROTOCOL_BUFFER_SIZE

    #define VNUART_PROTOCOL_BUFFER_SIZE 256
#endif

#define VN_BINARY_START_CHAR        0xFA
#define VN_ASCII_START_CHAR         '$'

#ifdef __cplusplus
extern "C" {
#endif

typedef void(*vnuart_sensor_error_received)(VnError error);

typedef struct
{
    size_t curExtractLoc;

    size_t length;

    uint8_t* data;

} VnUartPacket;

void VnUartPacket_initialize(VnUartPacket* packet, uint8_t* data, size_t len);

void VnUartPacket_initializeFromStr(VnUartPacket* packet, char* data);

bool VnUartPacket_isValid(VnUartPacket *packet);

bool VnUartPacket_isAsciiAsync(VnUartPacket *packet);

bool VnUartPacket_isResponse(VnUartPacket *packet);

bool VnUartPacket_isError(VnUartPacket *packet);

bool VnUartPacket_isErrorRaw(uint8_t *packet);

PacketType VnUartPacket_type(VnUartPacket *packet);

VnError VnUartPacket_finalizeCommand(VnErrorDetectionMode errorDetectionMode, uint8_t *packet, size_t *length);

uint8_t VnUartPacket_groups(VnUartPacket* packet);

uint16_t VnUartPacket_groupField(VnUartPacket* packet, size_t groupIndex);

size_t VnUartPacket_computeBinaryPacketLength(uint8_t const *startOfPossibleBinaryPacket);

size_t VnUartPacket_computeNumOfBytesForBinaryGroupPayload(BinaryGroupType groupType, uint16_t groupField);

bool VnUartPacket_isCompatible(
    VnUartPacket *packet,
    CommonGroup commonGroup,
    TimeGroup timeGroup,
    ImuGroup imuGroup,
    GpsGroup gpsGroup,
    AttitudeGroup attitudeGroup,
    InsGroup insGroup);

uint8_t VnUartPacket_extractUint8(VnUartPacket *packet);

int8_t VnUartPacket_extractInt8(VnUartPacket *packet);

uint16_t VnUartPacket_extractUint16(VnUartPacket *packet);

uint32_t VnUartPacket_extractUint32(VnUartPacket *packet);

uint64_t VnUartPacket_extractUint64(VnUartPacket *packet);

float VnUartPacket_extractFloat(VnUartPacket* packet);

vec3f VnUartPacket_extractVec3f(VnUartPacket *packet);

vec3d VnUartPacket_extractVec3d(VnUartPacket *packet);

vec4f VnUartPacket_extractVec4f(VnUartPacket *packet);

mat3f VnUartPacket_extractMat3f(VnUartPacket *packet);

VnAsciiAsync VnUartPacket_determineAsciiAsyncType(VnUartPacket* packet);

void VnUartPacket_parseVNYPR(VnUartPacket* packet, vec3f *yawPitchRoll);

void VnUartPacket_parseVNQTN(VnUartPacket* packet, vec4f *quaternion);

#ifdef EXTRA

void VnUartPacket_parseVNQTM(VnUartPacket* packet, vec4f *quaternion, vec3f *magnetic);

void VnUartPacket_parseVNQTA(VnUartPacket* packet, vec4f *quaternion, vec3f *acceleration);

void VnUartPacket_parseVNQTR(VnUartPacket* packet, vec4f *quaternion, vec3f *angularRate);

void VnUartPacket_parseVNQMA(VnUartPacket* packet, vec4f *quaternion, vec3f *magnetic, vec3f *acceleration);

void VnUartPacket_parseVNQAR(VnUartPacket* packet, vec4f *quaternion, vec3f *acceleration, vec3f *angularRate);

#endif

void VnUartPacket_parseVNQMR(VnUartPacket* packet, vec4f *quaternion, vec3f *magnetic, vec3f *acceleration, vec3f *angularRate);

#ifdef EXTRA

void VnUartPacket_parseVNDCM(VnUartPacket* packet, mat3f *dcm);

#endif

void VnUartPacket_parseVNMAG(VnUartPacket* packet, vec3f *magnetic);

void VnUartPacket_parseVNACC(VnUartPacket* packet, vec3f *acceleration);

void VnUartPacket_parseVNGYR(VnUartPacket* packet, vec3f *angularRate);

void VnUartPacket_parseVNMAR(VnUartPacket* packet, vec3f *magnetic, vec3f *acceleration, vec3f *angularRate);

VnError VnUartPacket_parseVNYMR(
    VnUartPacket* packet,
    vec3f *yawPitchRoll,
    vec3f *magnetic,
    vec3f *acceleration,
    vec3f *angularRate);

/*VnError VnUartPacket_parseVNYMR(
    uint8_t* packetBuf,
    size_t packetLen,
    vec3f *yawPitchRoll,
    vec3f *magnetic,
    vec3f *acceleration,
    vec3f *angularRate);*/


#ifdef EXTRA

void VnUartPacket_parseVNYCM(VnUartPacket* packet, vec3f *yawPitchRoll, vec3f *magnetic, vec3f *acceleration, vec3f *angularRate, float *temperature);

#endif

void VnUartPacket_parseVNYBA(VnUartPacket* packet, vec3f *yawPitchRoll, vec3f *accelerationBody, vec3f *angularRate);

void VnUartPacket_parseVNYIA(VnUartPacket* packet, vec3f *yawPitchRoll, vec3f *accelerationInertial, vec3f *angularRate);

#ifdef EXTRA

void VnUartPacket_parseVNICM(VnUartPacket* packet, vec3f *yawPitchRoll, vec3f *magnetic, vec3f *accelerationInertial, vec3f *angularRate);

#endif

void VnUartPacket_parseVNIMU(VnUartPacket* packet, vec3f *magneticUncompensated, vec3f *accelerationUncompensated, vec3f *angularRateUncompensated, float *temperature, float *pressure);

void VnUartPacket_parseVNGPS(VnUartPacket* packet, double *time, uint16_t *week, uint8_t *gpsFix, uint8_t *numSats, vec3d *lla, vec3f *nedVel, vec3f *nedAcc, float *speedAcc, float *timeAcc);

void VnUartPacket_parseVNINS(VnUartPacket* packet, double *time, uint16_t *week, uint16_t *status, vec3f *yawPitchRoll, vec3d *lla, vec3f *nedVel, float *attUncertainty, float *posUncertainty, float *velUncertainty);

void VnUartPacket_parseVNINE(VnUartPacket* packet, double *time, uint16_t *week, uint16_t *status, vec3f *yawPitchRoll, vec3d *position, vec3f *velocity, float *attUncertainty, float *posUncertainty, float *velUncertainty);

void VnUartPacket_parseVNISL(VnUartPacket* packet, vec3f* ypr, vec3d* lla, vec3f* velocity, vec3f* acceleration, vec3f* angularRate);

void VnUartPacket_parseVNISE(VnUartPacket* packet, vec3f* ypr, vec3d* position, vec3f* velocity, vec3f* acceleration, vec3f* angularRate);

#ifdef EXTRA

void VnUartPacket_parseVNRAW(VnUartPacket* packet, vec3f *magneticVoltage, vec3f *accelerationVoltage, vec3f *angularRateVoltage, float *temperatureVoltage);

void VnUartPacket_parseVNCMV(VnUartPacket* packet, vec3f *magneticUncompensated, vec3f *accelerationUncompensated, vec3f *angularRateUncompensated, float *temperature);

void VnUartPacket_parseVNSTV(VnUartPacket* packet, vec4f *quaternion, vec3f *angularRateBias);

void VnUartPacket_parseVNCOV(VnUartPacket* packet, vec3f *attitudeVariance, vec3f *angularRateBiasVariance);

#endif

void VnUartPacket_parseVNGPE(VnUartPacket* packet, double *tow, uint16_t *week, uint8_t *gpsFix, uint8_t *numSats, vec3d *position, vec3f *velocity, vec3f *posAcc, float *speedAcc, float *timeAcc);

void VnUartPacket_parseVNDTV(VnUartPacket* packet, float *deltaTime, vec3f *deltaTheta, vec3f *deltaVelocity);

VnError vnuart_genread(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    uint16_t registerId,
    size_t *cmdSize);

VnError VnUartPacket_genReadBinaryOutput1(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadBinaryOutput2(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadBinaryOutput3(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

#ifdef EXTRA

VnError VnUartPacket_genReadBinaryOutput4(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadBinaryOutput5(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

#endif

VnError VnUartPacket_genCmdWriteSettings(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genCmdRestoreFactorySettings(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genCmdReset(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genCmdTare(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genCmdSetGyroBias(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genCmdKnownMagneticDisturbance(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    bool disturbancePresent,
    size_t *cmdSize);

VnError VnUartPacket_genCmdKnownAccelerationDisturbance(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    bool disturbancePresent,
    size_t *cmdSize);

VnError VnUartPacket_genReadUserTag(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadModelNumber(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadHardwareRevision(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadSerialNumber(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadFirmwareVersion(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadSerialBaudRate(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAsyncDataOutputType(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAsyncDataOutputFrequency(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadYawPitchRoll(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAttitudeQuaternion(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadQuaternionMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadMagneticMeasurements(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAccelerationMeasurements(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAngularRateMeasurements(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadMagneticAndGravityReferenceVectors(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadMagnetometerCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadAccelerationCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadReferenceFrameRotation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadYawPitchRollMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadCommunicationProtocolControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadSynchronizationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadSynchronizationStatus(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadVpeBasicControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadVpeMagnetometerBasicTuning(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadVpeAccelerometerBasicTuning(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadMagnetometerCalibrationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadCalculatedMagnetometerCalibration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadVelocityCompensationMeasurement(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadVelocityCompensationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadImuMeasurements(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsAntennaOffset(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsSolutionLla(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsSolutionEcef(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsSolutionLla(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsSolutionEcef(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsBasicConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsBasicConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsStateLla(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadInsStateEcef(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadStartupFilterBiasEstimate(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadDeltaThetaAndDeltaVelocity(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadDeltaThetaAndDeltaVelocityConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadReferenceVectorConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGyroCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadImuFilteringConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsCompassBaseline(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadGpsCompassEstimatedBaseline(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize);

VnError VnUartPacket_genWrite(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    uint16_t registerId,
    size_t *cmdSize,
    char const *format,
    ...);

VnError VnUartPacket_genWriteBinaryOutput1(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint16_t asyncMode,
    uint16_t rateDivisor,
    uint16_t commonField,
    uint16_t timeField,
    uint16_t imuField,
    uint16_t gpsField,
    uint16_t attitudeField,
    uint16_t insField);

VnError VnUartPacket_genWriteBinaryOutput2(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint16_t asyncMode,
    uint16_t rateDivisor,
    uint16_t commonField,
    uint16_t timeField,
    uint16_t imuField,
    uint16_t gpsField,
    uint16_t attitudeField,
    uint16_t insField);

VnError VnUartPacket_genWriteBinaryOutput3(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint16_t asyncMode,
    uint16_t rateDivisor,
    uint16_t commonField,
    uint16_t timeField,
    uint16_t imuField,
    uint16_t gpsField,
    uint16_t attitudeField,
    uint16_t insField);

#ifdef EXTRA

VnError VnUartPacket_genWriteBinaryOutput4(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint16_t asyncMode,
    uint16_t rateDivisor,
    uint16_t commonField,
    uint16_t timeField,
    uint16_t imuField,
    uint16_t gpsField,
    uint16_t attitudeField,
    uint16_t insField);

VnError VnUartPacket_genWriteBinaryOutput5(
    uint8_t *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint16_t asyncMode,
    uint16_t rateDivisor,
    uint16_t commonField,
    uint16_t timeField,
    uint16_t imuField,
    uint16_t gpsField,
    uint16_t attitudeField,
    uint16_t insField);

#endif

VnError VnUartPacket_genWriteUserTag(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    char* tag);

VnError VnUartPacket_genWriteSerialBaudRate(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t baudrate);

VnError VnUartPacket_genWriteSerialBaudRateWithOptions(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t baudrate);

VnError VnUartPacket_genWriteAsyncDataOutputType(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t ador);

VnError VnUartPacket_genWriteAsyncDataOutputTypeWithOptions(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t ador);

VnError VnUartPacket_genWriteAsyncDataOutputFrequency(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t adof);

VnError VnUartPacket_genWriteAsyncDataOutputFrequencyWithOptions(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t adof);

VnError VnUartPacket_genWriteMagneticAndGravityReferenceVectors(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f magRef,
    vec3f accRef);

VnError VnUartPacket_genWriteMagnetometerCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    mat3f c,
    vec3f b);

VnError VnUartPacket_genWriteAccelerationCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    mat3f c,
    vec3f b);

VnError VnUartPacket_genWriteReferenceFrameRotation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    mat3f c);

VnError VnUartPacket_genWriteCommunicationProtocolControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t serialCount,
    uint8_t serialStatus,
    uint8_t spiCount,
    uint8_t spiStatus,
    uint8_t serialChecksum,
    uint8_t spiChecksum,
    uint8_t errorMode);

VnError VnUartPacket_genWriteSynchronizationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t syncInMode,
    uint8_t syncInEdge,
    uint16_t syncInSkipFactor,
    uint32_t reserved1,
    uint8_t syncOutMode,
    uint8_t syncOutPolarity,
    uint16_t syncOutSkipFactor,
    uint32_t syncOutPulseWidth,
    uint32_t reserved2);

VnError VnUartPacket_genWriteSynchronizationStatus(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint32_t syncInCount,
    uint32_t syncInTime,
    uint32_t syncOutCount);

VnError VnUartPacket_genWriteVpeBasicControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t enable,
    uint8_t headingMode,
    uint8_t filteringMode,
    uint8_t tuningMode);

VnError VnUartPacket_genWriteVpeMagnetometerBasicTuning(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f baseTuning,
    vec3f adaptiveTuning,
    vec3f adaptiveFiltering);

VnError VnUartPacket_genWriteVpeAccelerometerBasicTuning(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f baseTuning,
    vec3f adaptiveTuning,
    vec3f adaptiveFiltering);

VnError VnUartPacket_genWriteMagnetometerCalibrationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t hsiMode,
    uint8_t hsiOutput,
    uint8_t convergeRate);

VnError VnUartPacket_genWriteVelocityCompensationMeasurement(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f velocity);

VnError VnUartPacket_genWriteVelocityCompensationControl(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t mode,
    float velocityTuning,
    float rateTuning);

VnError VnUartPacket_genWriteGpsConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t mode,
    uint8_t ppsSource,
    uint8_t reserved1,
    uint8_t reserved2,
    uint8_t reserved3);

VnError VnUartPacket_genWriteGpsAntennaOffset(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f position);

VnError VnUartPacket_genWriteInsBasicConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t scenario,
    uint8_t ahrsAiding,
    uint8_t estBaseline,
    uint8_t resv2);

VnError VnUartPacket_genWriteStartupFilterBiasEstimate(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f gyroBias,
    vec3f accelBias,
    float pressureBias);

VnError VnUartPacket_genWriteDeltaThetaAndDeltaVelocityConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t integrationFrame,
    uint8_t gyroCompensation,
    uint8_t accelCompensation,
    uint8_t reserved1,
    uint16_t reserved2);

VnError VnUartPacket_genWriteReferenceVectorConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    uint8_t useMagModel,
    uint8_t useGravityModel,
    uint8_t resv1,
    uint8_t resv2,
    uint32_t recalcThreshold,
    float year,
    vec3d position);

VnError VnUartPacket_genWriteGyroCompensation(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    mat3f c,
    vec3f b);

VnError VnUartPacket_genWriteImuFilteringConfiguration(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    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);

VnError VnUartPacket_genWriteGpsCompassBaseline(
    char *buffer,
    size_t bufferSize,
    VnErrorDetectionMode errorDetectionMode,
    size_t *cmdSize,
    vec3f position,
    vec3f uncertainty);

void VnUartPacket_parseError(VnUartPacket *packet, uint8_t *error);

void VnUartPacket_parseErrorRaw(uint8_t *packet, uint8_t *error);

void VnUartPacket_parseBinaryOutput(
    VnUartPacket *packet,
    uint16_t* asyncMode,
    uint16_t* rateDivisor,
    uint16_t* outputGroup,
    uint16_t* commonField,
    uint16_t* timeField,
    uint16_t* imuField,
    uint16_t* gpsField,
    uint16_t* attitudeField,
    uint16_t* insField);

void VnUartPacket_parseBinaryOutputRaw(
    uint8_t *packet,
    uint16_t* asyncMode,
    uint16_t* rateDivisor,
    uint16_t* outputGroup,
    uint16_t* commonField,
    uint16_t* timeField,
    uint16_t* imuField,
    uint16_t* gpsField,
    uint16_t* attitudeField,
    uint16_t* insField);

void VnUartPacket_parseUserTag(VnUartPacket *packet, char* tag);

void VnUartPacket_parseUserTagRaw(char *packet, char* tag);

void VnUartPacket_parseModelNumber(VnUartPacket *packet, char* productName);

void VnUartPacket_parseModelNumberRaw(char *packet, char* productName);

void VnUartPacket_parseHardwareRevision(VnUartPacket *packet, uint32_t* revision);

void VnUartPacket_parseHardwareRevisionRaw(char *packet, uint32_t* revision);

void VnUartPacket_parseSerialNumber(VnUartPacket *packet, uint32_t* serialNum);

void VnUartPacket_parseSerialNumberRaw(char *packet, uint32_t* serialNum);

void VnUartPacket_parseFirmwareVersion(VnUartPacket *packet, char* firmwareVersion);

void VnUartPacket_parseFirmwareVersionRaw(char *packet, char* firmwareVersion);

void VnUartPacket_parseSerialBaudRate(VnUartPacket *packet, uint32_t* baudrate);

void VnUartPacket_parseSerialBaudRateRaw(char *packet, uint32_t* baudrate);

void VnUartPacket_parseAsyncDataOutputType(VnUartPacket *packet, uint32_t* ador);

void VnUartPacket_parseAsyncDataOutputTypeRaw(char *packet, uint32_t* ador);

void VnUartPacket_parseAsyncDataOutputFrequency(VnUartPacket *packet, uint32_t* adof);

void VnUartPacket_parseAsyncDataOutputFrequencyRaw(char *packet, uint32_t* adof);

void VnUartPacket_parseYawPitchRoll(VnUartPacket *packet, vec3f* yawPitchRoll);

void VnUartPacket_parseYawPitchRollRaw(char *packet, vec3f* yawPitchRoll);

void VnUartPacket_parseAttitudeQuaternion(VnUartPacket *packet, vec4f* quat);

void VnUartPacket_parseAttitudeQuaternionRaw(char *packet, vec4f* quat);

void VnUartPacket_parseQuaternionMagneticAccelerationAndAngularRates(VnUartPacket *packet, vec4f* quat, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseQuaternionMagneticAccelerationAndAngularRatesRaw(char *packet, vec4f* quat, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseMagneticMeasurements(VnUartPacket *packet, vec3f* mag);

void VnUartPacket_parseMagneticMeasurementsRaw(char *packet, vec3f* mag);

void VnUartPacket_parseAccelerationMeasurements(VnUartPacket *packet, vec3f* accel);

void VnUartPacket_parseAccelerationMeasurementsRaw(char *packet, vec3f* accel);

void VnUartPacket_parseAngularRateMeasurements(VnUartPacket *packet, vec3f* gyro);

void VnUartPacket_parseAngularRateMeasurementsRaw(char *packet, vec3f* gyro);

void VnUartPacket_parseMagneticAccelerationAndAngularRates(VnUartPacket *packet, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseMagneticAccelerationAndAngularRatesRaw(char *packet, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseMagneticAndGravityReferenceVectors(VnUartPacket *packet, vec3f* magRef, vec3f* accRef);

void VnUartPacket_parseMagneticAndGravityReferenceVectorsRaw(char *packet, vec3f* magRef, vec3f* accRef);

void VnUartPacket_parseFilterMeasurementsVarianceParameters(VnUartPacket *packet, float* angularWalkVariance, vec3f* angularRateVariance, vec3f* magneticVariance, vec3f* accelerationVariance);

void VnUartPacket_parseFilterMeasurementsVarianceParametersRaw(char *packet, float* angularWalkVariance, vec3f* angularRateVariance, vec3f* magneticVariance, vec3f* accelerationVariance);

void VnUartPacket_parseMagnetometerCompensation(VnUartPacket *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseMagnetometerCompensationRaw(char *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseFilterActiveTuningParameters(VnUartPacket *packet, float* magneticDisturbanceGain, float* accelerationDisturbanceGain, float* magneticDisturbanceMemory, float* accelerationDisturbanceMemory);

void VnUartPacket_parseFilterActiveTuningParametersRaw(char *packet, float* magneticDisturbanceGain, float* accelerationDisturbanceGain, float* magneticDisturbanceMemory, float* accelerationDisturbanceMemory);

void VnUartPacket_parseAccelerationCompensation(VnUartPacket *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseAccelerationCompensationRaw(char *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseReferenceFrameRotation(VnUartPacket *packet, mat3f* c);

void VnUartPacket_parseReferenceFrameRotationRaw(char *packet, mat3f* c);

void VnUartPacket_parseYawPitchRollMagneticAccelerationAndAngularRates(VnUartPacket *packet, vec3f* yawPitchRoll, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseYawPitchRollMagneticAccelerationAndAngularRatesRaw(char *packet, vec3f* yawPitchRoll, vec3f* mag, vec3f* accel, vec3f* gyro);

void VnUartPacket_parseCommunicationProtocolControl(VnUartPacket *packet, uint8_t* serialCount, uint8_t* serialStatus, uint8_t* spiCount, uint8_t* spiStatus, uint8_t* serialChecksum, uint8_t* spiChecksum, uint8_t* errorMode);

void VnUartPacket_parseCommunicationProtocolControlRaw(char *packet, uint8_t* serialCount, uint8_t* serialStatus, uint8_t* spiCount, uint8_t* spiStatus, uint8_t* serialChecksum, uint8_t* spiChecksum, uint8_t* errorMode);

void VnUartPacket_parseSynchronizationControl(VnUartPacket *packet, uint8_t* syncInMode, uint8_t* syncInEdge, uint16_t* syncInSkipFactor, uint32_t* reserved1, uint8_t* syncOutMode, uint8_t* syncOutPolarity, uint16_t* syncOutSkipFactor, uint32_t* syncOutPulseWidth, uint32_t* reserved2);

void VnUartPacket_parseSynchronizationControlRaw(char *packet, uint8_t* syncInMode, uint8_t* syncInEdge, uint16_t* syncInSkipFactor, uint32_t* reserved1, uint8_t* syncOutMode, uint8_t* syncOutPolarity, uint16_t* syncOutSkipFactor, uint32_t* syncOutPulseWidth, uint32_t* reserved2);

void VnUartPacket_parseSynchronizationStatus(VnUartPacket *packet, uint32_t* syncInCount, uint32_t* syncInTime, uint32_t* syncOutCount);

void VnUartPacket_parseSynchronizationStatusRaw(char *packet, uint32_t* syncInCount, uint32_t* syncInTime, uint32_t* syncOutCount);

void VnUartPacket_parseFilterBasicControl(VnUartPacket *packet, uint8_t* magMode, uint8_t* extMagMode, uint8_t* extAccMode, uint8_t* extGyroMode, vec3f* gyroLimit);

void VnUartPacket_parseFilterBasicControlRaw(char *packet, uint8_t* magMode, uint8_t* extMagMode, uint8_t* extAccMode, uint8_t* extGyroMode, vec3f* gyroLimit);

void VnUartPacket_parseVpeBasicControl(VnUartPacket *packet, uint8_t* enable, uint8_t* headingMode, uint8_t* filteringMode, uint8_t* tuningMode);

void VnUartPacket_parseVpeBasicControlRaw(char *packet, uint8_t* enable, uint8_t* headingMode, uint8_t* filteringMode, uint8_t* tuningMode);

void VnUartPacket_parseVpeMagnetometerBasicTuning(VnUartPacket *packet, vec3f* baseTuning, vec3f* adaptiveTuning, vec3f* adaptiveFiltering);

void VnUartPacket_parseVpeMagnetometerBasicTuningRaw(char *packet, vec3f* baseTuning, vec3f* adaptiveTuning, vec3f* adaptiveFiltering);

void VnUartPacket_parseVpeMagnetometerAdvancedTuning(VnUartPacket *packet, vec3f* minFiltering, vec3f* maxFiltering, float* maxAdaptRate, float* disturbanceWindow, float* maxTuning);

void VnUartPacket_parseVpeMagnetometerAdvancedTuningRaw(char *packet, vec3f* minFiltering, vec3f* maxFiltering, float* maxAdaptRate, float* disturbanceWindow, float* maxTuning);

void VnUartPacket_parseVpeAccelerometerBasicTuning(VnUartPacket *packet, vec3f* baseTuning, vec3f* adaptiveTuning, vec3f* adaptiveFiltering);

void VnUartPacket_parseVpeAccelerometerBasicTuningRaw(char *packet, vec3f* baseTuning, vec3f* adaptiveTuning, vec3f* adaptiveFiltering);

void VnUartPacket_parseVpeAccelerometerAdvancedTuning(VnUartPacket *packet, vec3f* minFiltering, vec3f* maxFiltering, float* maxAdaptRate, float* disturbanceWindow, float* maxTuning);

void VnUartPacket_parseVpeAccelerometerAdvancedTuningRaw(char *packet, vec3f* minFiltering, vec3f* maxFiltering, float* maxAdaptRate, float* disturbanceWindow, float* maxTuning);

void VnUartPacket_parseVpeGyroBasicTuning(VnUartPacket *packet, vec3f* angularWalkVariance, vec3f* baseTuning, vec3f* adaptiveTuning);

void VnUartPacket_parseVpeGyroBasicTuningRaw(char *packet, vec3f* angularWalkVariance, vec3f* baseTuning, vec3f* adaptiveTuning);

void VnUartPacket_parseFilterStartupGyroBias(VnUartPacket *packet, vec3f* bias);

void VnUartPacket_parseFilterStartupGyroBiasRaw(char *packet, vec3f* bias);

void VnUartPacket_parseMagnetometerCalibrationControl(VnUartPacket *packet, uint8_t* hsiMode, uint8_t* hsiOutput, uint8_t* convergeRate);

void VnUartPacket_parseMagnetometerCalibrationControlRaw(char *packet, uint8_t* hsiMode, uint8_t* hsiOutput, uint8_t* convergeRate);

void VnUartPacket_parseCalculatedMagnetometerCalibration(VnUartPacket *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseCalculatedMagnetometerCalibrationRaw(char *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseIndoorHeadingModeControl(VnUartPacket *packet, float* maxRateError, uint8_t* reserved1);

void VnUartPacket_parseIndoorHeadingModeControlRaw(char *packet, float* maxRateError, uint8_t* reserved1);

void VnUartPacket_parseVelocityCompensationMeasurement(VnUartPacket *packet, vec3f* velocity);

void VnUartPacket_parseVelocityCompensationMeasurementRaw(char *packet, vec3f* velocity);

void VnUartPacket_parseVelocityCompensationControl(VnUartPacket *packet, uint8_t* mode, float* velocityTuning, float* rateTuning);

void VnUartPacket_parseVelocityCompensationControlRaw(char *packet, uint8_t* mode, float* velocityTuning, float* rateTuning);

void VnUartPacket_parseVelocityCompensationStatus(VnUartPacket *packet, float* x, float* xDot, vec3f* accelOffset, vec3f* omega);

void VnUartPacket_parseVelocityCompensationStatusRaw(char *packet, float* x, float* xDot, vec3f* accelOffset, vec3f* omega);

void VnUartPacket_parseImuMeasurements(VnUartPacket *packet, vec3f* mag, vec3f* accel, vec3f* gyro, float* temp, float* pressure);

void VnUartPacket_parseImuMeasurementsRaw(char *packet, vec3f* mag, vec3f* accel, vec3f* gyro, float* temp, float* pressure);

void VnUartPacket_parseGpsConfiguration(VnUartPacket *packet, uint8_t* mode, uint8_t* ppsSource, uint8_t* reserved1, uint8_t* reserved2, uint8_t* reserved3);

void VnUartPacket_parseGpsConfigurationRaw(char *packet, uint8_t* mode, uint8_t* ppsSource, uint8_t* reserved1, uint8_t* reserved2, uint8_t* reserved3);

void VnUartPacket_parseGpsAntennaOffset(VnUartPacket *packet, vec3f* position);

void VnUartPacket_parseGpsAntennaOffsetRaw(char *packet, vec3f* position);

void VnUartPacket_parseGpsSolutionLla(VnUartPacket *packet, double* time, uint16_t* week, uint8_t* gpsFix, uint8_t* numSats, vec3d* lla, vec3f* nedVel, vec3f* nedAcc, float* speedAcc, float* timeAcc);

void VnUartPacket_parseGpsSolutionLlaRaw(char *packet, double* time, uint16_t* week, uint8_t* gpsFix, uint8_t* numSats, vec3d* lla, vec3f* nedVel, vec3f* nedAcc, float* speedAcc, float* timeAcc);

void VnUartPacket_parseGpsSolutionEcef(VnUartPacket *packet, double* tow, uint16_t* week, uint8_t* gpsFix, uint8_t* numSats, vec3d* position, vec3f* velocity, vec3f* posAcc, float* speedAcc, float* timeAcc);

void VnUartPacket_parseGpsSolutionEcefRaw(char *packet, double* tow, uint16_t* week, uint8_t* gpsFix, uint8_t* numSats, vec3d* position, vec3f* velocity, vec3f* posAcc, float* speedAcc, float* timeAcc);

void VnUartPacket_parseInsSolutionLla(VnUartPacket *packet, double* time, uint16_t* week, uint16_t* status, vec3f* yawPitchRoll, vec3d* position, vec3f* nedVel, float* attUncertainty, float* posUncertainty, float* velUncertainty);

void VnUartPacket_parseInsSolutionLlaRaw(char *packet, double* time, uint16_t* week, uint16_t* status, vec3f* yawPitchRoll, vec3d* position, vec3f* nedVel, float* attUncertainty, float* posUncertainty, float* velUncertainty);

void VnUartPacket_parseInsSolutionEcef(VnUartPacket *packet, double* time, uint16_t* week, uint16_t* status, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, float* attUncertainty, float* posUncertainty, float* velUncertainty);

void VnUartPacket_parseInsSolutionEcefRaw(char *packet, double* time, uint16_t* week, uint16_t* status, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, float* attUncertainty, float* posUncertainty, float* velUncertainty);

void VnUartPacket_parseInsBasicConfiguration(VnUartPacket *packet, uint8_t* scenario, uint8_t* ahrsAiding, uint8_t* estBaseline, uint8_t* resv2);

void VnUartPacket_parseInsBasicConfigurationRaw(char *packet, uint8_t* scenario, uint8_t* ahrsAiding, uint8_t* estBaseline, uint8_t* resv2);

void VnUartPacket_parseInsAdvancedConfiguration(VnUartPacket *packet, 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);

void VnUartPacket_parseInsAdvancedConfigurationRaw(char *packet, 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);

void VnUartPacket_parseInsStateLla(VnUartPacket *packet, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, vec3f* accel, vec3f* angularRate);

void VnUartPacket_parseInsStateLlaRaw(char *packet, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, vec3f* accel, vec3f* angularRate);

void VnUartPacket_parseInsStateEcef(VnUartPacket *packet, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, vec3f* accel, vec3f* angularRate);

void VnUartPacket_parseInsStateEcefRaw(char *packet, vec3f* yawPitchRoll, vec3d* position, vec3f* velocity, vec3f* accel, vec3f* angularRate);

void VnUartPacket_parseStartupFilterBiasEstimate(VnUartPacket *packet, vec3f* gyroBias, vec3f* accelBias, float* pressureBias);

void VnUartPacket_parseStartupFilterBiasEstimateRaw(char *packet, vec3f* gyroBias, vec3f* accelBias, float* pressureBias);

void VnUartPacket_parseDeltaThetaAndDeltaVelocity(VnUartPacket *packet, float* deltaTime, vec3f* deltaTheta, vec3f* deltaVelocity);

void VnUartPacket_parseDeltaThetaAndDeltaVelocityRaw(char *packet, float* deltaTime, vec3f* deltaTheta, vec3f* deltaVelocity);

void VnUartPacket_parseDeltaThetaAndDeltaVelocityConfiguration(VnUartPacket *packet, uint8_t* integrationFrame, uint8_t* gyroCompensation, uint8_t* accelCompensation, uint8_t* reserved1, uint16_t* reserved2);

void VnUartPacket_parseDeltaThetaAndDeltaVelocityConfigurationRaw(char *packet, uint8_t* integrationFrame, uint8_t* gyroCompensation, uint8_t* accelCompensation, uint8_t* reserved1, uint16_t* reserved2);

void VnUartPacket_parseReferenceVectorConfiguration(VnUartPacket *packet, uint8_t* useMagModel, uint8_t* useGravityModel, uint8_t* resv1, uint8_t* resv2, uint32_t* recalcThreshold, float* year, vec3d* position);

void VnUartPacket_parseReferenceVectorConfigurationRaw(char *packet, uint8_t* useMagModel, uint8_t* useGravityModel, uint8_t* resv1, uint8_t* resv2, uint32_t* recalcThreshold, float* year, vec3d* position);

void VnUartPacket_parseGyroCompensation(VnUartPacket *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseGyroCompensationRaw(char *packet, mat3f* c, vec3f* b);

void VnUartPacket_parseImuFilteringConfiguration(VnUartPacket *packet, 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);

void VnUartPacket_parseImuFilteringConfigurationRaw(char *packet, 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);

void VnUartPacket_parseGpsCompassBaseline(VnUartPacket *packet, vec3f* position, vec3f* uncertainty);

void VnUartPacket_parseGpsCompassBaselineRaw(char *packet, vec3f* position, vec3f* uncertainty);

void VnUartPacket_parseGpsCompassEstimatedBaseline(VnUartPacket *packet, uint8_t* estBaselineUsed, uint8_t* resv, uint16_t* numMeas, vec3f* position, vec3f* uncertainty);

void VnUartPacket_parseGpsCompassEstimatedBaselineRaw(char *packet, uint8_t* estBaselineUsed, uint8_t* resv, uint16_t* numMeas, vec3f* position, vec3f* uncertainty);

void VnUartPacket_parseImuRateConfiguration(VnUartPacket *packet, uint16_t* imuRate, uint16_t* navDivisor, float* filterTargetRate, float* filterMinRate);

void VnUartPacket_parseImuRateConfigurationRaw(char *packet, uint16_t* imuRate, uint16_t* navDivisor, float* filterTargetRate, float* filterMinRate);

void VnUartPacket_parseYawPitchRollTrueBodyAccelerationAndAngularRates(VnUartPacket *packet, vec3f* yawPitchRoll, vec3f* bodyAccel, vec3f* gyro);

void VnUartPacket_parseYawPitchRollTrueBodyAccelerationAndAngularRatesRaw(char *packet, vec3f* yawPitchRoll, vec3f* bodyAccel, vec3f* gyro);

void VnUartPacket_parseYawPitchRollTrueInertialAccelerationAndAngularRates(VnUartPacket *packet, vec3f* yawPitchRoll, vec3f* inertialAccel, vec3f* gyro);

void VnUartPacket_parseYawPitchRollTrueInertialAccelerationAndAngularRatesRaw(char *packet, vec3f* yawPitchRoll, vec3f* inertialAccel, vec3f* gyro);

void strFromVnAsciiAsync(char *out, VnAsciiAsync val);

#ifdef __cplusplus
}
#endif

#endif