274 lines
9.2 KiB
C
274 lines
9.2 KiB
C
#ifndef VNUTIL_H_INCLUDED
|
|
#define VNUTIL_H_INCLUDED
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "vn/int.h"
|
|
#include "vn/bool.h"
|
|
#include "vn/error.h"
|
|
#include "vn/math/matrix.h"
|
|
#include "vn/math/vector.h"
|
|
#include "vn/util/export.h"
|
|
#include "vn/types.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/** \brief Defines for the specific version of the VectorNav library. */
|
|
#define VNAPI_MAJOR 1
|
|
#define VNAPI_MINOR 2
|
|
#define VNAPI_PATCH 0
|
|
#define VNAPI_REVISION 126
|
|
|
|
/** \brief Returns the major version of the VectorNav library.
|
|
*
|
|
* \return The major version. */
|
|
int VnApi_major(void);
|
|
|
|
/** \brief Returns the minor version of the VectorNav library.
|
|
*
|
|
* \return The minor version. */
|
|
int VnApi_minor(void);
|
|
|
|
/** \brief Returns the patch version of the VectorNav library.
|
|
*
|
|
* \return The patch version. */
|
|
int VnApi_patch(void);
|
|
|
|
/** \brief Returns the revision version of the VectorNav library.
|
|
*
|
|
* \return The revision version. */
|
|
int VnApi_revision(void);
|
|
|
|
/** \brief Returns the full version of the VectorNav library as a string.
|
|
*
|
|
* \param[out] out The buffer to place the string.
|
|
* \param[in] outLength The number of characters available in the out buffer.
|
|
* \return Any errors encountered. */
|
|
VnError VnApi_getVersion(char *out, size_t outLength);
|
|
|
|
/** \brief Converts the single hexadecimal character to a uint8_t.
|
|
*
|
|
* \param[in] c The hexadecimal character to convert.
|
|
* \return The converted value.
|
|
*/
|
|
uint8_t VnUtil_toUint8FromHexChar(char c);
|
|
|
|
/** \brief Converts a 2 character hexadecimal string to a uint8_t.
|
|
*
|
|
* \param[in] str Pointer to 2 characters representing a hexadecimal
|
|
* number.
|
|
* \return The converted value.
|
|
*/
|
|
uint8_t VnUtil_toUint8FromHexStr(char const *str);
|
|
|
|
/** \brief Converts a 4 character hexadecimal string to a uint16_t.
|
|
*
|
|
* \param[in] str Pointer to 4 characters representing a hexadecimal
|
|
* number.
|
|
* \return The converted value.
|
|
*/
|
|
uint16_t VnUtil_toUint16FromHexStr(char const *str);
|
|
|
|
/** \brief Converts a uint8_t to a hexadecimal string.
|
|
*
|
|
* \param[in] toConvert The uint8_t to convert.
|
|
* \param[in] output Pointer to the char array to write the converted value.
|
|
* This will take 2 bytes for the output.
|
|
*/
|
|
void VnUtil_toHexStrFromUint8(uint8_t toConvert, char *output);
|
|
|
|
/** \brief Converts a uint16_t to a hexadecimal string.
|
|
*
|
|
* \param[in] toConvert The uint16_t to convert.
|
|
* \param[in] output Pointer to the char array to write the converted value.
|
|
* This will take 4 bytes for the output.
|
|
*/
|
|
void VnUtil_toHexStrFromUint16(uint16_t toConvert, char *output);
|
|
|
|
/** \brief Converts a uint16_t to a string.
|
|
*
|
|
* \param[in] toConvert The uint16_t to convert.
|
|
* \param[in] output Pointer to the char array to write the converted value.
|
|
* \return The number of characters that were written.
|
|
*/
|
|
size_t VnUtil_toStrFromUint16(uint16_t toConvert, char *output);
|
|
|
|
/** \brief Returns the number of bits set.
|
|
*
|
|
* \param[in] data The data value to count the number of bits set.
|
|
* \return The number of bits set.
|
|
*/
|
|
uint8_t DllExport VnUtil_countSetBitsUint8(uint8_t data);
|
|
|
|
/** \brief Converts a boolean value into a string.
|
|
*
|
|
* \param[out] out The value converted to a string.
|
|
* \param[in] val The value to convert.
|
|
*/
|
|
void strFromBool(char *out, bool val);
|
|
|
|
/** \defgroup byteOrderers Byte Ordering Functions
|
|
* \brief This group of functions are useful for ordering of bytes
|
|
* sent/received from VectorNav sensors.
|
|
*
|
|
* \{ */
|
|
|
|
/** \brief Converts a 16-bit integer in sensor order to host order.
|
|
*
|
|
* \param[in] sensorOrdered The 16-bit integer in sensor order.
|
|
* \return The value converted to host ordered. */
|
|
uint16_t stoh16(uint16_t sensorOrdered);
|
|
|
|
/** \brief Converts a 32-bit integer in sensor order to host order.
|
|
*
|
|
* \param[in] sensorOrdered The 32-bit integer in sensor order.
|
|
* \return The value converted to host ordered. */
|
|
uint32_t stoh32(uint32_t sensorOrdered);
|
|
|
|
/** \brief Converts a 64-bit integer in sensor order to host order.
|
|
*
|
|
* \param[in] sensorOrdered The 64-bit integer in sensor order.
|
|
* \return The value converted to host ordered. */
|
|
uint64_t stoh64(uint64_t sensorOrdered);
|
|
|
|
/** \brief Converts a 16-bit integer in host order to sensor order.
|
|
*
|
|
* \param[in] hostOrdered The 16-bit integer in host order.
|
|
* \return The value converted to sensor ordered. */
|
|
uint16_t htos16(uint16_t hostOrdered);
|
|
|
|
/** \brief Converts a 32-bit integer in host order to sensor order.
|
|
*
|
|
* \param[in] hostOrdered The 32-bit integer in host order.
|
|
* \return The value converted to sensor ordered. */
|
|
uint32_t htos32(uint32_t hostOrdered);
|
|
|
|
/** \brief Converts a 64-bit integer in host order to sensor order.
|
|
*
|
|
* \param[in] hostOrdered The 64-bit integer in host order.
|
|
* \return The value converted to sensor ordered. */
|
|
uint64_t htos64(uint64_t hostOrdered);
|
|
|
|
/** \brief Converts a 4-byte float in host order to sensor order.
|
|
*
|
|
* \param[in] hostOrdered The 4-byte float in host order.
|
|
* \return The value converted to sensor ordered. */
|
|
float htosf4(float hostOrdered);
|
|
|
|
/** \brief Converts an 8-byte float in host order to sensor order.
|
|
*
|
|
* \param[in] hostOrdered The 8-byte float in host order.
|
|
* \return The value converted to sensor ordered. */
|
|
double htosf8(double hostOrdered);
|
|
|
|
/** \} */
|
|
|
|
/** \defgroup sensorValueExtractors Sensor Value Extractors
|
|
* \brief This group of methods is useful for extracting data from binary
|
|
* data received from a VectorNav sensor either from a UART binary or a
|
|
* SPI packet. Any necessary byte ordering will be performed.
|
|
*
|
|
* \{ */
|
|
|
|
/** \brief Extracts a uint16_t with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
uint16_t VnUtil_extractUint16(const char* pos);
|
|
|
|
/** \brief Extracts a uint32_t with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
uint32_t VnUtil_extractUint32(const char* pos);
|
|
|
|
/** \brief Extracts a <c>float</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
float VnUtil_extractFloat(const char* pos);
|
|
|
|
/** \brief Extracts a <c>double</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
double VnUtil_extractDouble(const char* pos);
|
|
|
|
/*#if THIS_SHOULD_BE_MOVED_TO_MATH_C_PACK*/
|
|
|
|
/** \brief Extracts a <c>vec3f</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
vec3f VnUtil_extractVec3f(const char* pos);
|
|
|
|
/** \brief Extracts a <c>vec4f</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
vec4f VnUtil_extractVec4f(const char* pos);
|
|
|
|
/** \brief Extracts a <c>vec3d</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
vec3d VnUtil_extractVec3d(const char* pos);
|
|
|
|
/** \brief Extracts a <c>mat3f</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
mat3f VnUtil_extractMat3f(const char* pos);
|
|
|
|
/** \brief Extracts a <c>GpsDop</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
GpsDop VnUtil_extractGpsDop(const char* pos);
|
|
|
|
/** \brief Extracts a <c>TimeUtc</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
TimeUtc VnUtil_extractTimeUtc(const char* pos);
|
|
|
|
/** \brief Extracts a <c>TimeInfo</c> with appropriate byte reordering from the binary
|
|
* array received from a VectorNav sensor either from the UART binary or
|
|
* SPI packet.
|
|
*
|
|
* \param[in] pos The current position to extract the value from.
|
|
* \return The extracted value. */
|
|
TimeInfo VnUtil_extractTimeInfo(const char* pos);
|
|
|
|
/*#endif*/
|
|
|
|
/* \} */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|