/* VectorNav HSI Calibration Library v1.0.0.2
 *
 * Copyright (c) 2018 VectorNav Technologies, LLC
 *
 * This source code is proprietary to and copyrighted by VectorNav Technologies, LLC and is
 * available solely under license from VectorNav. All rights reserved. If you do not have a
 * license to use this source code from VectorNav, any use hereof is strictly prohibited by
 * U.S. law and other applicable law. This source code is restricted for use solely with the
 * products of VectorNav and as otherwise set forth in any agreement with VectorNav. Any
 * disclosure of this source code to the public or to any third party is also prohibited.
 */
#ifndef _VNSPI_H_
#define _VNSPI_H_

#include <stddef.h>
#include "vnint.h"
#include "vnenum.h"
#include "vnvector.h"
#include "vnmatrix.h"

#ifdef __cplusplus
extern "C" {
#endif

/**\brief Generates a command to write settings.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain
 *     on output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength.This is useful back - to - back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteSettings(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/**\brief Generates a command to restore factory settings.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain
 *     on output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength.This is useful back - to - back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genRestorFactorySettings(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/**\brief Generates a command to tare the sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain
 *     on output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength.This is useful back - to - back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genTare(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/**\brief Generates a command to reset the sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain
 *     on output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength.This is useful back - to - back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReset(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/**\brief Generic function for making register read commands.
 * \param[out] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain
 *     on output the number of bytes in the command to send.
 * \param[in] regId The register ID to generate the read command for.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_genRead(
    char *buffer,
    size_t *size,
    uint8_t regId,
    size_t desiredLength);

/**\brief Parses a response from reading the User Tag register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] tag The register's Tag field.
 * \param[in] tagLength The number of bytes available in the buffer tag.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseUserTag(
    const char *response,
    char* tag,
    size_t tagLength);

/**\brief Parses a response from reading the Model Number register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] productName The register's Product Name field.
 * \param[in] productNameLength The number of bytes available in the buffer productName.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseModelNumber(
    const char *response,
    char* productName,
    size_t productNameLength);

/**\brief Parses a response from reading the Hardware Revision register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] revision The register's Revision field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseHardwareRevision(
    const char *response,
    uint32_t *revision);

/**\brief Parses a response from reading the Serial Number register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] serialNum The register's SerialNum field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseSerialNumber(
    const char *response,
    uint32_t *serialNum);

/**\brief Parses a response from reading the Firmware Version register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] firmwareVersion The register's Firmware Version field.
 * \param[in] firmwareVersionLength The number of bytes available in the buffer firmwareVersion.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseFirmwareVersion(
    const char *response,
    char* firmwareVersion,
    size_t firmwareVersionLength);

/**\brief Parses a response from reading the Serial Baud Rate register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] baudrate The register's Baud Rate field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseSerialBaudRate(
    const char *response,
    uint32_t *baudrate);

/**\brief Parses a response from reading the Async Data Output Type register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] ador The register's ADOR field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAsyncDataOutputType(
    const char *response,
    uint32_t *ador);

/**\brief Parses a response from reading the Async Data Output Frequency register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] adof The register's ADOF field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAsyncDataOutputFrequency(
    const char *response,
    uint32_t *adof);

/**\brief Parses a response from reading the Yaw Pitch Roll register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseYawPitchRoll(
    const char *response,
    union vn_vec3f *yawPitchRoll);

/**\brief Parses a response from reading the Attitude Quaternion register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] quat The register's Quat field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAttitudeQuaternion(
    const char *response,
    union vn_vec4f *quat);

/**\brief Parses a response from reading the Quaternion, Magnetic, Acceleration and Angular Rates register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] quat The register's Quat field.
 * \param[out] mag The register's Mag field.
 * \param[out] accel The register's Accel field.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseQuaternionMagneticAccelerationAndAngularRates(
    const char *response,
    union vn_vec4f *quat, 
    union vn_vec3f *mag, 
    union vn_vec3f *accel, 
    union vn_vec3f *gyro);

/**\brief Parses a response from reading the Magnetic Measurements register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] mag The register's Mag field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseMagneticMeasurements(
    const char *response,
    union vn_vec3f *mag);

/**\brief Parses a response from reading the Acceleration Measurements register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] accel The register's Accel field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAccelerationMeasurements(
    const char *response,
    union vn_vec3f *accel);

/**\brief Parses a response from reading the Angular Rate Measurements register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAngularRateMeasurements(
    const char *response,
    union vn_vec3f *gyro);

/**\brief Parses a response from reading the Magnetic, Acceleration and Angular Rates register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] mag The register's Mag field.
 * \param[out] accel The register's Accel field.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseMagneticAccelerationAndAngularRates(
    const char *response,
    union vn_vec3f *mag, 
    union vn_vec3f *accel, 
    union vn_vec3f *gyro);

/**\brief Parses a response from reading the Magnetic and Gravity Reference Vectors register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] magRef The register's MagRef field.
 * \param[out] accRef The register's AccRef field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseMagneticAndGravityReferenceVectors(
    const char *response,
    union vn_vec3f *magRef, 
    union vn_vec3f *accRef);

/**\brief Parses a response from reading the Filter Measurements Variance Parameters register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] angularWalkVariance The register's Angular Walk Variance field.
 * \param[out] angularRateVariance The register's Angular Rate Variance field.
 * \param[out] magneticVariance The register's Magnetic Variance field.
 * \param[out] accelerationVariance The register's Acceleration Variance field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseFilterMeasurementsVarianceParameters(
    const char *response,
    float *angularWalkVariance, 
    union vn_vec3f *angularRateVariance, 
    union vn_vec3f *magneticVariance, 
    union vn_vec3f *accelerationVariance);

/**\brief Parses a response from reading the Magnetometer Compensation register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] c The register's C field.
 * \param[out] b The register's B field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseMagnetometerCompensation(
    const char *response,
    union vn_mat3f *c, 
    union vn_vec3f *b);

/**\brief Parses a response from reading the Filter Active Tuning Parameters register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] magneticDisturbanceGain The register's Magnetic Disturbance Gain field.
 * \param[out] accelerationDisturbanceGain The register's Acceleration Disturbance Gain field.
 * \param[out] magneticDisturbanceMemory The register's Magnetic Disturbance Memory field.
 * \param[out] accelerationDisturbanceMemory The register's Acceleration Disturbance Memory field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseFilterActiveTuningParameters(
    const char *response,
    float *magneticDisturbanceGain, 
    float *accelerationDisturbanceGain, 
    float *magneticDisturbanceMemory, 
    float *accelerationDisturbanceMemory);

/**\brief Parses a response from reading the Acceleration Compensation register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] c The register's C field.
 * \param[out] b The register's B field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseAccelerationCompensation(
    const char *response,
    union vn_mat3f *c, 
    union vn_vec3f *b);

/**\brief Parses a response from reading the Reference Frame Rotation register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] c The register's C field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseReferenceFrameRotation(
    const char *response,
    union vn_mat3f *c);

/**\brief Parses a response from reading the Yaw, Pitch, Roll, Magnetic, Acceleration and Angular Rates register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] mag The register's Mag field.
 * \param[out] accel The register's Accel field.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseYawPitchRollMagneticAccelerationAndAngularRates(
    const char *response,
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3f *mag, 
    union vn_vec3f *accel, 
    union vn_vec3f *gyro);

/**\brief Parses a response from reading the Communication Protocol Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] serialCount The register's SerialCount field.
 * \param[out] serialStatus The register's SerialStatus field.
 * \param[out] spiCount The register's SPICount field.
 * \param[out] spiStatus The register's SPIStatus field.
 * \param[out] serialChecksum The register's SerialChecksum field.
 * \param[out] spiChecksum The register's SPIChecksum field.
 * \param[out] errorMode The register's ErrorMode field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseCommunicationProtocolControl(
    const char *response,
    uint8_t *serialCount, 
    uint8_t *serialStatus, 
    uint8_t *spiCount, 
    uint8_t *spiStatus, 
    uint8_t *serialChecksum, 
    uint8_t *spiChecksum, 
    uint8_t *errorMode);

/**\brief Parses a response from reading the Synchronization Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] syncInMode The register's SyncInMode field.
 * \param[out] syncInEdge The register's SyncInEdge field.
 * \param[out] syncInSkipFactor The register's SyncInSkipFactor field.
 * \param[out] reserved1 The register's RESERVED1 field.
 * \param[out] syncOutMode The register's SyncOutMode field.
 * \param[out] syncOutPolarity The register's SyncOutPolarity field.
 * \param[out] syncOutSkipFactor The register's SyncOutSkipFactor field.
 * \param[out] syncOutPulseWidth The register's SyncOutPulseWidth field.
 * \param[out] reserved2 The register's RESERVED2 field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseSynchronizationControl(
    const char *response,
    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);

/**\brief Parses a response from reading the Synchronization Status register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] syncInCount The register's SyncInCount field.
 * \param[out] syncInTime The register's SyncInTime field.
 * \param[out] syncOutCount The register's SyncOutCount field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseSynchronizationStatus(
    const char *response,
    uint32_t *syncInCount, 
    uint32_t *syncInTime, 
    uint32_t *syncOutCount);

/**\brief Parses a response from reading the Filter Basic Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] magMode The register's MagMode field.
 * \param[out] extMagMode The register's ExtMagMode field.
 * \param[out] extAccMode The register's ExtAccMode field.
 * \param[out] extGyroMode The register's ExtGyroMode field.
 * \param[out] gyroLimit The register's GyroLimit field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseFilterBasicControl(
    const char *response,
    uint8_t *magMode, 
    uint8_t *extMagMode, 
    uint8_t *extAccMode, 
    uint8_t *extGyroMode, 
    union vn_vec3f *gyroLimit);

/**\brief Parses a response from reading the VPE Basic Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] enable The register's Enable field.
 * \param[out] headingMode The register's HeadingMode field.
 * \param[out] filteringMode The register's FilteringMode field.
 * \param[out] tuningMode The register's TuningMode field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeBasicControl(
    const char *response,
    uint8_t *enable, 
    uint8_t *headingMode, 
    uint8_t *filteringMode, 
    uint8_t *tuningMode);

/**\brief Parses a response from reading the VPE Magnetometer Basic Tuning register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] baseTuning The register's BaseTuning field.
 * \param[out] adaptiveTuning The register's AdaptiveTuning field.
 * \param[out] adaptiveFiltering The register's AdaptiveFiltering field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeMagnetometerBasicTuning(
    const char *response,
    union vn_vec3f *baseTuning, 
    union vn_vec3f *adaptiveTuning, 
    union vn_vec3f *adaptiveFiltering);

/**\brief Parses a response from reading the VPE Magnetometer Advanced Tuning register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] minFiltering The register's MinFiltering field.
 * \param[out] maxFiltering The register's MaxFiltering field.
 * \param[out] maxAdaptRate The register's MaxAdaptRate field.
 * \param[out] disturbanceWindow The register's DisturbanceWindow field.
 * \param[out] maxTuning The register's MaxTuning field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeMagnetometerAdvancedTuning(
    const char *response,
    union vn_vec3f *minFiltering, 
    union vn_vec3f *maxFiltering, 
    float *maxAdaptRate, 
    float *disturbanceWindow, 
    float *maxTuning);

/**\brief Parses a response from reading the VPE Accelerometer Basic Tuning register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] baseTuning The register's BaseTuning field.
 * \param[out] adaptiveTuning The register's AdaptiveTuning field.
 * \param[out] adaptiveFiltering The register's AdaptiveFiltering field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeAccelerometerBasicTuning(
    const char *response,
    union vn_vec3f *baseTuning, 
    union vn_vec3f *adaptiveTuning, 
    union vn_vec3f *adaptiveFiltering);

/**\brief Parses a response from reading the VPE Accelerometer Advanced Tuning register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] minFiltering The register's MinFiltering field.
 * \param[out] maxFiltering The register's MaxFiltering field.
 * \param[out] maxAdaptRate The register's MaxAdaptRate field.
 * \param[out] disturbanceWindow The register's DisturbanceWindow field.
 * \param[out] maxTuning The register's MaxTuning field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeAccelerometerAdvancedTuning(
    const char *response,
    union vn_vec3f *minFiltering, 
    union vn_vec3f *maxFiltering, 
    float *maxAdaptRate, 
    float *disturbanceWindow, 
    float *maxTuning);

/**\brief Parses a response from reading the VPE Gyro Basic Tuning register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] angularWalkVariance The register's AngularWalkVariance field.
 * \param[out] baseTuning The register's BaseTuning field.
 * \param[out] adaptiveTuning The register's AdaptiveTuning field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVpeGyroBasicTuning(
    const char *response,
    union vn_vec3f *angularWalkVariance, 
    union vn_vec3f *baseTuning, 
    union vn_vec3f *adaptiveTuning);

/**\brief Parses a response from reading the Filter Startup Gyro Bias register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] bias The register's Bias field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseFilterStartupGyroBias(
    const char *response,
    union vn_vec3f *bias);

/**\brief Parses a response from reading the Magnetometer Calibration Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] hsiMode The register's HSIMode field.
 * \param[out] hsiOutput The register's HSIOutput field.
 * \param[out] convergeRate The register's ConvergeRate field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseMagnetometerCalibrationControl(
    const char *response,
    uint8_t *hsiMode, 
    uint8_t *hsiOutput, 
    uint8_t *convergeRate);

/**\brief Parses a response from reading the Calculated Magnetometer Calibration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] c The register's C field.
 * \param[out] b The register's B field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseCalculatedMagnetometerCalibration(
    const char *response,
    union vn_mat3f *c, 
    union vn_vec3f *b);

/**\brief Parses a response from reading the Indoor Heading Mode Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] maxRateError The register's Max Rate Error field.
 * \param[out] reserved1 The register's Reserved1 field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseIndoorHeadingModeControl(
    const char *response,
    float *maxRateError, 
    uint8_t *reserved1);

/**\brief Parses a response from reading the Velocity Compensation Measurement register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] velocity The register's Velocity field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVelocityCompensationMeasurement(
    const char *response,
    union vn_vec3f *velocity);

/**\brief Parses a response from reading the Velocity Compensation Control register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] mode The register's Mode field.
 * \param[out] velocityTuning The register's VelocityTuning field.
 * \param[out] rateTuning The register's RateTuning field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVelocityCompensationControl(
    const char *response,
    uint8_t *mode, 
    float *velocityTuning, 
    float *rateTuning);

/**\brief Parses a response from reading the Velocity Compensation Status register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] x The register's x field.
 * \param[out] xDot The register's xDot field.
 * \param[out] accelOffset The register's accelOffset field.
 * \param[out] omega The register's omega field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseVelocityCompensationStatus(
    const char *response,
    float *x, 
    float *xDot, 
    union vn_vec3f *accelOffset, 
    union vn_vec3f *omega);

/**\brief Parses a response from reading the IMU Measurements register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] mag The register's Mag field.
 * \param[out] accel The register's Accel field.
 * \param[out] gyro The register's Gyro field.
 * \param[out] temp The register's Temp field.
 * \param[out] pressure The register's Pressure field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseImuMeasurements(
    const char *response,
    union vn_vec3f *mag, 
    union vn_vec3f *accel, 
    union vn_vec3f *gyro, 
    float *temp, 
    float *pressure);

/**\brief Parses a response from reading the GPS Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] mode The register's Mode field.
 * \param[out] ppsSource The register's PpsSource field.
 * \param[out] reserved1 The register's Reserved1 field.
 * \param[out] reserved2 The register's Reserved2 field.
 * \param[out] reserved3 The register's Reserved3 field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsConfiguration(
    const char *response,
    uint8_t *mode, 
    uint8_t *ppsSource, 
    uint8_t *reserved1, 
    uint8_t *reserved2, 
    uint8_t *reserved3);

/**\brief Parses a response from reading the GPS Antenna Offset register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] position The register's Position field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsAntennaOffset(
    const char *response,
    union vn_vec3f *position);

/**\brief Parses a response from reading the GPS Solution - LLA register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] time The register's Time field.
 * \param[out] week The register's Week field.
 * \param[out] gpsFix The register's GpsFix field.
 * \param[out] numSats The register's NumSats field.
 * \param[out] lla The register's Lla field.
 * \param[out] nedVel The register's NedVel field.
 * \param[out] nedAcc The register's NedAcc field.
 * \param[out] speedAcc The register's SpeedAcc field.
 * \param[out] timeAcc The register's TimeAcc field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsSolutionLla(
    const char *response,
    double *time, 
    uint16_t *week, 
    uint8_t *gpsFix, 
    uint8_t *numSats, 
    union vn_vec3d *lla, 
    union vn_vec3f *nedVel, 
    union vn_vec3f *nedAcc, 
    float *speedAcc, 
    float *timeAcc);

/**\brief Parses a response from reading the GPS Solution - ECEF register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] tow The register's Tow field.
 * \param[out] week The register's Week field.
 * \param[out] gpsFix The register's GpsFix field.
 * \param[out] numSats The register's NumSats field.
 * \param[out] position The register's Position field.
 * \param[out] velocity The register's Velocity field.
 * \param[out] posAcc The register's PosAcc field.
 * \param[out] speedAcc The register's SpeedAcc field.
 * \param[out] timeAcc The register's TimeAcc field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsSolutionEcef(
    const char *response,
    double *tow, 
    uint16_t *week, 
    uint8_t *gpsFix, 
    uint8_t *numSats, 
    union vn_vec3d *position, 
    union vn_vec3f *velocity, 
    union vn_vec3f *posAcc, 
    float *speedAcc, 
    float *timeAcc);

/**\brief Parses a response from reading the INS Solution - LLA register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] time The register's Time field.
 * \param[out] week The register's Week field.
 * \param[out] status The register's Status field.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] position The register's Position field.
 * \param[out] nedVel The register's NedVel field.
 * \param[out] attUncertainty The register's AttUncertainty field.
 * \param[out] posUncertainty The register's PosUncertainty field.
 * \param[out] velUncertainty The register's VelUncertainty field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsSolutionLla(
    const char *response,
    double *time, 
    uint16_t *week, 
    uint16_t *status, 
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3d *position, 
    union vn_vec3f *nedVel, 
    float *attUncertainty, 
    float *posUncertainty, 
    float *velUncertainty);

/**\brief Parses a response from reading the INS Solution - ECEF register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] time The register's Time field.
 * \param[out] week The register's Week field.
 * \param[out] status The register's Status field.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] position The register's Position field.
 * \param[out] velocity The register's Velocity field.
 * \param[out] attUncertainty The register's AttUncertainty field.
 * \param[out] posUncertainty The register's PosUncertainty field.
 * \param[out] velUncertainty The register's VelUncertainty field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsSolutionEcef(
    const char *response,
    double *time, 
    uint16_t *week, 
    uint16_t *status, 
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3d *position, 
    union vn_vec3f *velocity, 
    float *attUncertainty, 
    float *posUncertainty, 
    float *velUncertainty);

/**\brief Parses a response from reading the INS Basic Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] scenario The register's Scenario field.
 * \param[out] ahrsAiding The register's AhrsAiding field.
 * \param[out] estBaseline The register's EstBaseline field.
 * \param[out] resv2 The register's Resv2 field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsBasicConfiguration(
    const char *response,
    uint8_t *scenario, 
    uint8_t *ahrsAiding, 
    uint8_t *estBaseline, 
    uint8_t *resv2);

/**\brief Parses a response from reading the INS Advanced Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] useMag The register's UseMag field.
 * \param[out] usePres The register's UsePres field.
 * \param[out] posAtt The register's PosAtt field.
 * \param[out] velAtt The register's VelAtt field.
 * \param[out] velBias The register's VelBias field.
 * \param[out] useFoam The register's UseFoam field.
 * \param[out] gpsCovType The register's GPSCovType field.
 * \param[out] velCount The register's VelCount field.
 * \param[out] velInit The register's VelInit field.
 * \param[out] moveOrigin The register's MoveOrigin field.
 * \param[out] gpsTimeout The register's GPSTimeout field.
 * \param[out] deltaLimitPos The register's DeltaLimitPos field.
 * \param[out] deltaLimitVel The register's DeltaLimitVel field.
 * \param[out] minPosUncertainty The register's MinPosUncertainty field.
 * \param[out] minVelUncertainty The register's MinVelUncertainty field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsAdvancedConfiguration(
    const char *response,
    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);

/**\brief Parses a response from reading the INS State - LLA register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] position The register's Position field.
 * \param[out] velocity The register's Velocity field.
 * \param[out] accel The register's Accel field.
 * \param[out] angularRate The register's AngularRate field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsStateLla(
    const char *response,
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3d *position, 
    union vn_vec3f *velocity, 
    union vn_vec3f *accel, 
    union vn_vec3f *angularRate);

/**\brief Parses a response from reading the INS State - ECEF register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] position The register's Position field.
 * \param[out] velocity The register's Velocity field.
 * \param[out] accel The register's Accel field.
 * \param[out] angularRate The register's AngularRate field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseInsStateEcef(
    const char *response,
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3d *position, 
    union vn_vec3f *velocity, 
    union vn_vec3f *accel, 
    union vn_vec3f *angularRate);

/**\brief Parses a response from reading the Startup Filter Bias Estimate register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] gyroBias The register's GyroBias field.
 * \param[out] accelBias The register's AccelBias field.
 * \param[out] pressureBias The register's PressureBias field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseStartupFilterBiasEstimate(
    const char *response,
    union vn_vec3f *gyroBias, 
    union vn_vec3f *accelBias, 
    float *pressureBias);

/**\brief Parses a response from reading the Delta Theta and Delta Velocity register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] deltaTime The register's DeltaTime field.
 * \param[out] deltaTheta The register's DeltaTheta field.
 * \param[out] deltaVelocity The register's DeltaVelocity field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseDeltaThetaAndDeltaVelocity(
    const char *response,
    float *deltaTime, 
    union vn_vec3f *deltaTheta, 
    union vn_vec3f *deltaVelocity);

/**\brief Parses a response from reading the Delta Theta and Delta Velocity Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] integrationFrame The register's IntegrationFrame field.
 * \param[out] gyroCompensation The register's GyroCompensation field.
 * \param[out] accelCompensation The register's AccelCompensation field.
 * \param[out] reserved1 The register's Reserved1 field.
 * \param[out] reserved2 The register's Reserved2 field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseDeltaThetaAndDeltaVelocityConfiguration(
    const char *response,
    uint8_t *integrationFrame, 
    uint8_t *gyroCompensation, 
    uint8_t *accelCompensation, 
    uint8_t *reserved1, 
    uint16_t *reserved2);

/**\brief Parses a response from reading the Reference Vector Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] useMagModel The register's UseMagModel field.
 * \param[out] useGravityModel The register's UseGravityModel field.
 * \param[out] resv1 The register's Resv1 field.
 * \param[out] resv2 The register's Resv2 field.
 * \param[out] recalcThreshold The register's RecalcThreshold field.
 * \param[out] year The register's Year field.
 * \param[out] position The register's Position field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseReferenceVectorConfiguration(
    const char *response,
    uint8_t *useMagModel, 
    uint8_t *useGravityModel, 
    uint8_t *resv1, 
    uint8_t *resv2, 
    uint32_t *recalcThreshold, 
    float *year, 
    union vn_vec3d *position);

/**\brief Parses a response from reading the Gyro Compensation register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] c The register's C field.
 * \param[out] b The register's B field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGyroCompensation(
    const char *response,
    union vn_mat3f *c, 
    union vn_vec3f *b);

/**\brief Parses a response from reading the IMU Filtering Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] magWindowSize The register's MagWindowSize field.
 * \param[out] accelWindowSize The register's AccelWindowSize field.
 * \param[out] gyroWindowSize The register's GyroWindowSize field.
 * \param[out] tempWindowSize The register's TempWindowSize field.
 * \param[out] presWindowSize The register's PresWindowSize field.
 * \param[out] magFilterMode The register's MagFilterMode field.
 * \param[out] accelFilterMode The register's AccelFilterMode field.
 * \param[out] gyroFilterMode The register's GyroFilterMode field.
 * \param[out] tempFilterMode The register's TempFilterMode field.
 * \param[out] presFilterMode The register's PresFilterMode field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseImuFilteringConfiguration(
    const char *response,
    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);

/**\brief Parses a response from reading the GPS Compass Baseline register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] position The register's Position field.
 * \param[out] uncertainty The register's Uncertainty field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsCompassBaseline(
    const char *response,
    union vn_vec3f *position, 
    union vn_vec3f *uncertainty);

/**\brief Parses a response from reading the GPS Compass Estimated Baseline register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] estBaselineUsed The register's EstBaselineUsed field.
 * \param[out] resv The register's Resv field.
 * \param[out] numMeas The register's NumMeas field.
 * \param[out] position The register's Position field.
 * \param[out] uncertainty The register's Uncertainty field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseGpsCompassEstimatedBaseline(
    const char *response,
    uint8_t *estBaselineUsed, 
    uint8_t *resv, 
    uint16_t *numMeas, 
    union vn_vec3f *position, 
    union vn_vec3f *uncertainty);

/**\brief Parses a response from reading the IMU Rate Configuration register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] imuRate The register's imuRate field.
 * \param[out] navDivisor The register's NavDivisor field.
 * \param[out] filterTargetRate The register's filterTargetRate field.
 * \param[out] filterMinRate The register's filterMinRate field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseImuRateConfiguration(
    const char *response,
    uint16_t *imuRate, 
    uint16_t *navDivisor, 
    float *filterTargetRate, 
    float *filterMinRate);

/**\brief Parses a response from reading the Yaw, Pitch, Roll, True Body Acceleration and Angular Rates register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] bodyAccel The register's BodyAccel field.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseYawPitchRollTrueBodyAccelerationAndAngularRates(
    const char *response,
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3f *bodyAccel, 
    union vn_vec3f *gyro);

/**\brief Parses a response from reading the Yaw, Pitch, Roll, True Inertial Acceleration and Angular Rates register
 *     using the SPI protocol.
 * \param[in] response Pointer to the buffer containing the response from
 *     the VectorNav sensor, including the leading 0x00 byte.
 * \param[out] yawPitchRoll The register's YawPitchRoll field.
 * \param[out] inertialAccel The register's InertialAccel field.
 * \param[out] gyro The register's Gyro field.
 * \return Indicates any error encountered. */
enum VnError
VnSpi_parseYawPitchRollTrueInertialAccelerationAndAngularRates(
    const char *response,
    union vn_vec3f *yawPitchRoll, 
    union vn_vec3f *inertialAccel, 
    union vn_vec3f *gyro);

/** \defgroup spi_genread_functions SPI Generate Read Functions
* \brief This set of functions will generate command strings for reading
*     registers on VectorNav sensors using the SPI protocol.
*
* These functions take the form of
* <c>VnError VnSpi_genReadXXX(char *buffer, size_t* size, size_t desiredLength, size_t* responseSize)</c>
* where XXX is replaced with the name of the register, <c>buffer</c> is provided by
* the user to be filled with the generated command, <c>size</c> is the number of
* bytes available in the provided buffer and will contain the number of bytes of the command
* to send, <c>desiredLength</c> is the total number of bytes to pad with 0x00 should
* the total constructed length of the command be less than the desiredLength,
* <c>responseSize</c> is the number of bytes to read during the SPI transaction to get this
* command's response.
*
* \{ */

/** \brief Generates a command to read the User Tag register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadUserTag(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Model Number register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadModelNumber(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Hardware Revision register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadHardwareRevision(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Serial Number register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadSerialNumber(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Firmware Version register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadFirmwareVersion(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Serial Baud Rate register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadSerialBaudRate(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Async Data Output Type register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAsyncDataOutputType(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Async Data Output Frequency register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAsyncDataOutputFrequency(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Yaw Pitch Roll register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadYawPitchRoll(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Attitude Quaternion register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAttitudeQuaternion(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Quaternion, Magnetic, Acceleration and Angular Rates register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadQuaternionMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Magnetic Measurements register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadMagneticMeasurements(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Acceleration Measurements register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAccelerationMeasurements(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Angular Rate Measurements register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAngularRateMeasurements(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Magnetic, Acceleration and Angular Rates register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Magnetic and Gravity Reference Vectors register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadMagneticAndGravityReferenceVectors(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Magnetometer Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadMagnetometerCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Acceleration Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadAccelerationCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Reference Frame Rotation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadReferenceFrameRotation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Yaw, Pitch, Roll, Magnetic, Acceleration and Angular Rates register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadYawPitchRollMagneticAccelerationAndAngularRates(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Communication Protocol Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadCommunicationProtocolControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Synchronization Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadSynchronizationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Synchronization Status register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadSynchronizationStatus(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the VPE Basic Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadVpeBasicControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the VPE Magnetometer Basic Tuning register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadVpeMagnetometerBasicTuning(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the VPE Accelerometer Basic Tuning register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadVpeAccelerometerBasicTuning(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Magnetometer Calibration Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadMagnetometerCalibrationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Calculated Magnetometer Calibration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadCalculatedMagnetometerCalibration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Velocity Compensation Measurement register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadVelocityCompensationMeasurement(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Velocity Compensation Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadVelocityCompensationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the IMU Measurements register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadImuMeasurements(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Antenna Offset register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsAntennaOffset(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Solution - LLA register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsSolutionLla(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Solution - ECEF register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsSolutionEcef(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS Solution - LLA register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsSolutionLla(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS Solution - ECEF register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsSolutionEcef(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS Basic Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsBasicConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS Basic Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsBasicConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS State - LLA register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsStateLla(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the INS State - ECEF register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadInsStateEcef(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Startup Filter Bias Estimate register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadStartupFilterBiasEstimate(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Delta Theta and Delta Velocity register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadDeltaThetaAndDeltaVelocity(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Delta Theta and Delta Velocity Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadDeltaThetaAndDeltaVelocityConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Reference Vector Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadReferenceVectorConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Gyro Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGyroCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the IMU Filtering Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadImuFilteringConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Compass Baseline register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsCompassBaseline(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the GPS Compass Estimated Baseline register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadGpsCompassEstimatedBaseline(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Yaw, Pitch, Roll, True Body Acceleration and Angular Rates register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/** \brief Generates a command to read the Yaw, Pitch, Roll, True Inertial Acceleration and Angular Rates register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize);

/* \}*/

/** \defgroup spi_genwrite_functions SPI Generate Write Functions
* \brief This set of functions will generate command strings for writing to
*     registers on VectorNav sensors using the SPI protocol.
*
* These functions take the form shown below. <c>XXX</c> is replaced by the name
* of the register, <c>buffer</c> is provided by the user to be filled with the
* generated command, <c>size</c> is the number of bytes available in the provided
* buffer and will contain the number of bytes of the command to send, <c>desiredLength</c>
* is the total number of bytes to pad with 0x00 should the total constructed length
* of the command be less than the desired length, and <c>[Variable argument list]</c>
* varies with the specified register being written to.
*
* \code
 * VnError VnSpi_genWriteXXX(
 *     char *buffer,
 *     size_t* size,
 *     size_t desiredLength,
 *     size_t* responseSize,
 *     [Variable argument list]);
 * \endcode
 *
 * \{ */

/**\brief Generates a command to write the User Tag register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] tag The register's Tag field. This should be a null-terminated string.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteUserTag(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    char* tag);

/**\brief Generates a command to write the Serial Baud Rate register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] baudrate The register's Baud Rate field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteSerialBaudRate(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t baudrate);

/**\brief Generates a command to write the Serial Baud Rate register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] baudrate The register's Baud Rate field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteSerialBaudRateWithOptions(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t baudrate);

/**\brief Generates a command to write the Async Data Output Type register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] ador The register's ADOR field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteAsyncDataOutputType(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t ador);

/**\brief Generates a command to write the Async Data Output Type register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] ador The register's ADOR field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteAsyncDataOutputTypeWithOptions(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t ador);

/**\brief Generates a command to write the Async Data Output Frequency register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] adof The register's ADOF field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteAsyncDataOutputFrequency(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t adof);

/**\brief Generates a command to write the Async Data Output Frequency register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] adof The register's ADOF field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteAsyncDataOutputFrequencyWithOptions(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t adof);

/**\brief Generates a command to write the Magnetic and Gravity Reference Vectors register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] magRef The register's MagRef field.
 * \param[in] accRef The register's AccRef field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteMagneticAndGravityReferenceVectors(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f magRef,
    union vn_vec3f accRef);

/**\brief Generates a command to write the Magnetometer Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] c The register's C field.
 * \param[in] b The register's B field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteMagnetometerCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_mat3f c,
    union vn_vec3f b);

/**\brief Generates a command to write the Acceleration Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] c The register's C field.
 * \param[in] b The register's B field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteAccelerationCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_mat3f c,
    union vn_vec3f b);

/**\brief Generates a command to write the Reference Frame Rotation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] c The register's C field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteReferenceFrameRotation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_mat3f c);

/**\brief Generates a command to write the Communication Protocol Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] serialCount The register's SerialCount field.
 * \param[in] serialStatus The register's SerialStatus field.
 * \param[in] spiCount The register's SPICount field.
 * \param[in] spiStatus The register's SPIStatus field.
 * \param[in] serialChecksum The register's SerialChecksum field.
 * \param[in] spiChecksum The register's SPIChecksum field.
 * \param[in] errorMode The register's ErrorMode field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteCommunicationProtocolControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t serialCount,
    uint8_t serialStatus,
    uint8_t spiCount,
    uint8_t spiStatus,
    uint8_t serialChecksum,
    uint8_t spiChecksum,
    uint8_t errorMode);

/**\brief Generates a command to write the Synchronization Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] syncInMode The register's SyncInMode field.
 * \param[in] syncInEdge The register's SyncInEdge field.
 * \param[in] syncInSkipFactor The register's SyncInSkipFactor field.
 * \param[in] reserved1 The register's RESERVED1 field.
 * \param[in] syncOutMode The register's SyncOutMode field.
 * \param[in] syncOutPolarity The register's SyncOutPolarity field.
 * \param[in] syncOutSkipFactor The register's SyncOutSkipFactor field.
 * \param[in] syncOutPulseWidth The register's SyncOutPulseWidth field.
 * \param[in] reserved2 The register's RESERVED2 field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteSynchronizationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    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);

/**\brief Generates a command to write the Synchronization Status register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] syncInCount The register's SyncInCount field.
 * \param[in] syncInTime The register's SyncInTime field.
 * \param[in] syncOutCount The register's SyncOutCount field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteSynchronizationStatus(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint32_t syncInCount,
    uint32_t syncInTime,
    uint32_t syncOutCount);

/**\brief Generates a command to write the VPE Basic Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] enable The register's Enable field.
 * \param[in] headingMode The register's HeadingMode field.
 * \param[in] filteringMode The register's FilteringMode field.
 * \param[in] tuningMode The register's TuningMode field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteVpeBasicControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t enable,
    uint8_t headingMode,
    uint8_t filteringMode,
    uint8_t tuningMode);

/**\brief Generates a command to write the VPE Magnetometer Basic Tuning register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] baseTuning The register's BaseTuning field.
 * \param[in] adaptiveTuning The register's AdaptiveTuning field.
 * \param[in] adaptiveFiltering The register's AdaptiveFiltering field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteVpeMagnetometerBasicTuning(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f baseTuning,
    union vn_vec3f adaptiveTuning,
    union vn_vec3f adaptiveFiltering);

/**\brief Generates a command to write the VPE Accelerometer Basic Tuning register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] baseTuning The register's BaseTuning field.
 * \param[in] adaptiveTuning The register's AdaptiveTuning field.
 * \param[in] adaptiveFiltering The register's AdaptiveFiltering field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteVpeAccelerometerBasicTuning(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f baseTuning,
    union vn_vec3f adaptiveTuning,
    union vn_vec3f adaptiveFiltering);

/**\brief Generates a command to write the Magnetometer Calibration Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] hsiMode The register's HSIMode field.
 * \param[in] hsiOutput The register's HSIOutput field.
 * \param[in] convergeRate The register's ConvergeRate field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteMagnetometerCalibrationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t hsiMode,
    uint8_t hsiOutput,
    uint8_t convergeRate);

/**\brief Generates a command to write the Velocity Compensation Measurement register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] velocity The register's Velocity field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteVelocityCompensationMeasurement(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f velocity);

/**\brief Generates a command to write the Velocity Compensation Control register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] mode The register's Mode field.
 * \param[in] velocityTuning The register's VelocityTuning field.
 * \param[in] rateTuning The register's RateTuning field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteVelocityCompensationControl(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t mode,
    float velocityTuning,
    float rateTuning);

/**\brief Generates a command to write the GPS Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] mode The register's Mode field.
 * \param[in] ppsSource The register's PpsSource field.
 * \param[in] reserved1 The register's Reserved1 field.
 * \param[in] reserved2 The register's Reserved2 field.
 * \param[in] reserved3 The register's Reserved3 field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteGpsConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t mode,
    uint8_t ppsSource,
    uint8_t reserved1,
    uint8_t reserved2,
    uint8_t reserved3);

/**\brief Generates a command to write the GPS Antenna Offset register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] position The register's Position field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteGpsAntennaOffset(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f position);

/**\brief Generates a command to write the INS Basic Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] scenario The register's Scenario field.
 * \param[in] ahrsAiding The register's AhrsAiding field.
 * \param[in] estBaseline The register's EstBaseline field.
 * \param[in] resv2 The register's Resv2 field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteInsBasicConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t scenario,
    uint8_t ahrsAiding,
    uint8_t estBaseline,
    uint8_t resv2);

/**\brief Generates a command to write the Startup Filter Bias Estimate register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] gyroBias The register's GyroBias field.
 * \param[in] accelBias The register's AccelBias field.
 * \param[in] pressureBias The register's PressureBias field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteStartupFilterBiasEstimate(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f gyroBias,
    union vn_vec3f accelBias,
    float pressureBias);

/**\brief Generates a command to write the Delta Theta and Delta Velocity Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] integrationFrame The register's IntegrationFrame field.
 * \param[in] gyroCompensation The register's GyroCompensation field.
 * \param[in] accelCompensation The register's AccelCompensation field.
 * \param[in] reserved1 The register's Reserved1 field.
 * \param[in] reserved2 The register's Reserved2 field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteDeltaThetaAndDeltaVelocityConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t integrationFrame,
    uint8_t gyroCompensation,
    uint8_t accelCompensation,
    uint8_t reserved1,
    uint16_t reserved2);

/**\brief Generates a command to write the Reference Vector Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] useMagModel The register's UseMagModel field.
 * \param[in] useGravityModel The register's UseGravityModel field.
 * \param[in] resv1 The register's Resv1 field.
 * \param[in] resv2 The register's Resv2 field.
 * \param[in] recalcThreshold The register's RecalcThreshold field.
 * \param[in] year The register's Year field.
 * \param[in] position The register's Position field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteReferenceVectorConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    uint8_t useMagModel,
    uint8_t useGravityModel,
    uint8_t resv1,
    uint8_t resv2,
    uint32_t recalcThreshold,
    float year,
    union vn_vec3d position);

/**\brief Generates a command to write the Gyro Compensation register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] c The register's C field.
 * \param[in] b The register's B field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteGyroCompensation(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_mat3f c,
    union vn_vec3f b);

/**\brief Generates a command to write the IMU Filtering Configuration register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] magWindowSize The register's MagWindowSize field.
 * \param[in] accelWindowSize The register's AccelWindowSize field.
 * \param[in] gyroWindowSize The register's GyroWindowSize field.
 * \param[in] tempWindowSize The register's TempWindowSize field.
 * \param[in] presWindowSize The register's PresWindowSize field.
 * \param[in] magFilterMode The register's MagFilterMode field.
 * \param[in] accelFilterMode The register's AccelFilterMode field.
 * \param[in] gyroFilterMode The register's GyroFilterMode field.
 * \param[in] tempFilterMode The register's TempFilterMode field.
 * \param[in] presFilterMode The register's PresFilterMode field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteImuFilteringConfiguration(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    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);

/**\brief Generates a command to write the GPS Compass Baseline register on a VectorNav sensor.
 * \param[in] buffer Caller provided buffer to place the generated command.
 * \param[in/out] size Number of bytes available in the buffer. Will contain on
 *     output the number of bytes in the command to send.
 * \param[in] desiredLength The total number of bytes to pad with 0x00 should
 *     the total constructed length of the command be less than the
 *     desiredLength. This is useful back-to-back command where the
 *     desiredLength will be the responseSize of the previous command sent.
 * \param[out] responseSize The number of bytes to read during the SPI transaction
 *     to get this commands response.
 * \param[in] position The register's Position field.
 * \param[in] uncertainty The register's Uncertainty field.
 * \return Indicates any errors encountered. */
enum VnError
VnSpi_genWriteGpsCompassBaseline(
    char *buffer,
    size_t *size,
    size_t desiredLength,
    size_t *responseSize,
    union vn_vec3f position,
    union vn_vec3f uncertainty);

#ifdef __cplusplus
}
#endif

#endif