2482 lines
123 KiB
C
2482 lines
123 KiB
C
#ifndef _VNSPI_H_
|
|
#define _VNSPI_H_
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "vn/int.h"
|
|
#include "vn/error.h"
|
|
#include "vn/math/vector.h"
|
|
#include "vn/math/matrix.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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseYawPitchRoll(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseAttitudeQuaternion(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseQuaternionMagneticAccelerationAndAngularRates(
|
|
const char* response,
|
|
vec4f* quat,
|
|
vec3f* mag,
|
|
vec3f* accel,
|
|
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. */
|
|
VnError VnSpi_parseMagneticMeasurements(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseAccelerationMeasurements(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseAngularRateMeasurements(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseMagneticAccelerationAndAngularRates(
|
|
const char* response,
|
|
vec3f* mag,
|
|
vec3f* accel,
|
|
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. */
|
|
VnError VnSpi_parseMagneticAndGravityReferenceVectors(
|
|
const char* response,
|
|
vec3f* magRef,
|
|
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. */
|
|
VnError VnSpi_parseFilterMeasurementsVarianceParameters(
|
|
const char* response,
|
|
float* angularWalkVariance,
|
|
vec3f* angularRateVariance,
|
|
vec3f* magneticVariance,
|
|
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. */
|
|
VnError VnSpi_parseMagnetometerCompensation(
|
|
const char* response,
|
|
mat3f* c,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseAccelerationCompensation(
|
|
const char* response,
|
|
mat3f* c,
|
|
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. */
|
|
VnError VnSpi_parseReferenceFrameRotation(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseYawPitchRollMagneticAccelerationAndAngularRates(
|
|
const char* response,
|
|
vec3f* yawPitchRoll,
|
|
vec3f* mag,
|
|
vec3f* accel,
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseFilterBasicControl(
|
|
const char* response,
|
|
uint8_t* magMode,
|
|
uint8_t* extMagMode,
|
|
uint8_t* extAccMode,
|
|
uint8_t* extGyroMode,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseVpeMagnetometerBasicTuning(
|
|
const char* response,
|
|
vec3f* baseTuning,
|
|
vec3f* adaptiveTuning,
|
|
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. */
|
|
VnError VnSpi_parseVpeMagnetometerAdvancedTuning(
|
|
const char* response,
|
|
vec3f* minFiltering,
|
|
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. */
|
|
VnError VnSpi_parseVpeAccelerometerBasicTuning(
|
|
const char* response,
|
|
vec3f* baseTuning,
|
|
vec3f* adaptiveTuning,
|
|
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. */
|
|
VnError VnSpi_parseVpeAccelerometerAdvancedTuning(
|
|
const char* response,
|
|
vec3f* minFiltering,
|
|
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. */
|
|
VnError VnSpi_parseVpeGyroBasicTuning(
|
|
const char* response,
|
|
vec3f* angularWalkVariance,
|
|
vec3f* baseTuning,
|
|
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. */
|
|
VnError VnSpi_parseFilterStartupGyroBias(
|
|
const char* response,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseCalculatedMagnetometerCalibration(
|
|
const char* response,
|
|
mat3f* c,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseVelocityCompensationMeasurement(
|
|
const char* response,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseVelocityCompensationStatus(
|
|
const char* response,
|
|
float* x,
|
|
float* xDot,
|
|
vec3f* accelOffset,
|
|
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. */
|
|
VnError VnSpi_parseImuMeasurements(
|
|
const char* response,
|
|
vec3f* mag,
|
|
vec3f* accel,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseGpsAntennaOffset(
|
|
const char* response,
|
|
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. */
|
|
VnError VnSpi_parseGpsSolutionLla(
|
|
const char* response,
|
|
double* time,
|
|
uint16_t* week,
|
|
uint8_t* gpsFix,
|
|
uint8_t* numSats,
|
|
vec3d* lla,
|
|
vec3f* nedVel,
|
|
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. */
|
|
VnError VnSpi_parseGpsSolutionEcef(
|
|
const char* response,
|
|
double* tow,
|
|
uint16_t* week,
|
|
uint8_t* gpsFix,
|
|
uint8_t* numSats,
|
|
vec3d* position,
|
|
vec3f* velocity,
|
|
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. */
|
|
VnError VnSpi_parseInsSolutionLla(
|
|
const char* response,
|
|
double* time,
|
|
uint16_t* week,
|
|
uint16_t* status,
|
|
vec3f* yawPitchRoll,
|
|
vec3d* position,
|
|
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. */
|
|
VnError VnSpi_parseInsSolutionEcef(
|
|
const char* response,
|
|
double* time,
|
|
uint16_t* week,
|
|
uint16_t* status,
|
|
vec3f* yawPitchRoll,
|
|
vec3d* position,
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseInsStateLla(
|
|
const char* response,
|
|
vec3f* yawPitchRoll,
|
|
vec3d* position,
|
|
vec3f* velocity,
|
|
vec3f* accel,
|
|
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. */
|
|
VnError VnSpi_parseInsStateEcef(
|
|
const char* response,
|
|
vec3f* yawPitchRoll,
|
|
vec3d* position,
|
|
vec3f* velocity,
|
|
vec3f* accel,
|
|
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. */
|
|
VnError VnSpi_parseStartupFilterBiasEstimate(
|
|
const char* response,
|
|
vec3f* gyroBias,
|
|
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. */
|
|
VnError VnSpi_parseDeltaThetaAndDeltaVelocity(
|
|
const char* response,
|
|
float* deltaTime,
|
|
vec3f* deltaTheta,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseReferenceVectorConfiguration(
|
|
const char* response,
|
|
uint8_t* useMagModel,
|
|
uint8_t* useGravityModel,
|
|
uint8_t* resv1,
|
|
uint8_t* resv2,
|
|
uint32_t* recalcThreshold,
|
|
float* year,
|
|
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. */
|
|
VnError VnSpi_parseGyroCompensation(
|
|
const char* response,
|
|
mat3f* c,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseGpsCompassBaseline(
|
|
const char* response,
|
|
vec3f* position,
|
|
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. */
|
|
VnError VnSpi_parseGpsCompassEstimatedBaseline(
|
|
const char* response,
|
|
uint8_t* estBaselineUsed,
|
|
uint8_t* resv,
|
|
uint16_t* numMeas,
|
|
vec3f* position,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_parseYawPitchRollTrueBodyAccelerationAndAngularRates(
|
|
const char* response,
|
|
vec3f* yawPitchRoll,
|
|
vec3f* bodyAccel,
|
|
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. */
|
|
VnError VnSpi_parseYawPitchRollTrueInertialAccelerationAndAngularRates(
|
|
const char* response,
|
|
vec3f* yawPitchRoll,
|
|
vec3f* inertialAccel,
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteMagneticAndGravityReferenceVectors(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
vec3f magRef,
|
|
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. */
|
|
VnError VnSpi_genWriteMagnetometerCompensation(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
mat3f c,
|
|
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. */
|
|
VnError VnSpi_genWriteAccelerationCompensation(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
mat3f c,
|
|
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. */
|
|
VnError VnSpi_genWriteReferenceFrameRotation(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteVpeMagnetometerBasicTuning(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
vec3f baseTuning,
|
|
vec3f adaptiveTuning,
|
|
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. */
|
|
VnError VnSpi_genWriteVpeAccelerometerBasicTuning(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
vec3f baseTuning,
|
|
vec3f adaptiveTuning,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteVelocityCompensationMeasurement(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
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. */
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteGpsAntennaOffset(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteStartupFilterBiasEstimate(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
vec3f gyroBias,
|
|
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. */
|
|
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. */
|
|
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,
|
|
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. */
|
|
VnError VnSpi_genWriteGyroCompensation(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
mat3f c,
|
|
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. */
|
|
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. */
|
|
VnError VnSpi_genWriteGpsCompassBaseline(
|
|
char* buffer,
|
|
size_t* size,
|
|
size_t desiredLength,
|
|
size_t* responseSize,
|
|
vec3f position,
|
|
vec3f uncertainty);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|