GmZedF9pPpkGps.hpp

#ifndef GEO_GPS_ZEDF9P_PPK_HPP
#define GEO_GPS_ZEDF9P_PPK_HPP
 
#include <GmBufferedSensor.hpp>
 
#ifndef GMMFAMDATA_HPP_
#include <GmMfamData.hpp>
#endif
#include <GmError.hpp>
 
#include <GmRingBuffer.hpp>
#include <GmManagedRingBuffer.hpp>
#include <GmChildRingBuffer.hpp>
#include "GmUartLineSensor.hpp"
#include "GmTivaGpsUartSensor.hpp"
#include <ti/sysbios/knl/Clock.h>
 
 
namespace Geometrics
{
   class GeoZedF9pPpkGps : public CTivaGpsUartSensor
   {
     public:
       GeoZedF9pPpkGps (UInt8                     iSubject,
                        GmManagedArrayRingBuffer<uint8_t,GM_SIZE_OF_APP_DATA_QUEUE> *mainEventQueue);
     int             Initialize                 (int        iBoardID);
 
 
     /*
      * 5.2 UBX Frame Structure
The structure of a basic UBX Frame is shown in the following diagram.
• Every Frame starts with a 2-byte Preamble consisting of two synchronization characters: 0xB5
0x62.
• A 1-byte Message Class field follows. A Class is a group of messages that are related to each
other.
• A 1-byte Message ID field defines the message that is to follow.
• A 2-byte Length field follows. The length is defined as being that of the payload only. It does not
include the Preamble, Message Class, Message ID, Length, or CRC fields. The number format of
the length field is a Little-Endian unsigned 16-bit integer.
• The Payload field contains a variable number of bytes.
• The two 1-byte CK_A and CK_B fields hold a 16-bit checksum whose calculation is defined below.
This concludes the Frame.
      */
 
     /*
      * A Configuration Key ID is a 32 bit integer value, which is split into three parts (Note that bits 31, 27.
.24 and 15..8 are reserved for future use and are currently unused.):
• bits 30..28: 3 bits that indicate the storage size of a Configuration Value (range 0x01-0x05, see
below)
• bits 23..16: 8 bits that define a unique group ID (range 0x01-0xfe)
• bits 7..0: 8 bits that define a unique item ID within a group (range 0x01-0xfe)
The entire 32 bit value is the unique Key ID, which uniquely identifies a particular item. The
numeric representation of the Key ID uses the lower-case hexadecimal format, such as
0x20c400a1. An easier, more readable text representation uses the form CFG-GROUP-ITEM. This
is also referred to as the (Configuration) Key Name.
Supported storage size identifiers (bits 30..28 of the Key ID) are:
• 0x01: one bit (the actual storage used is one byte, but only the least significant bit is used)
• 0x02: one byte
• 0x03: two bytes
• 0x04: four bytes
• 0x05: eight bytes
 
Each Configuration Item is of a certain type, which defines the interpretation of the raw binary
data (see also number formats):
• U1, U2, U4, U8: unsigned little-endian integers of 8-, 16-, 32- and 64-bit widths
• I1, I2, I4, I8: signed little-endian, two's complement integers of 8-, 16-, 32- and 64-bit widths
• R4, R8: IEEE754 single (32-bit) and double (64-bit) precision floats
• E1, E2, E4: unsigned little-endian enumeration of 8-, 16-, and 32-bit widths (like U1, U2 and U4)
• X1, X2, X4, X8: unsigned little-endian integers of 8-, 16-, 32- and 64-bit widths for bitfields and
other binary data, such as strings
• L: single-bit boolean (true = 1, false = 0), stored as U1
      */
 
 
     /* Public getters and setters from the ZedF9P */
     /* Use UBX-CFG-VALGET to get value from connected ZedF9P */
     int             GetUbxVal (uint32_t key, uint8_t layer, bool &answer );
     int             SetUbxVal (uint32_t key, uint8_t layer, bool newValue);
 
     int             GetUbxVal (uint32_t key, uint8_t layer, uint8_t &answer );
     int             SetUbxVal (uint32_t key, uint8_t layer, uint8_t newValue);
 
     int             GetUbxVal (uint32_t key, uint8_t layer, uint16_t &answer );
     int             SetUbxVal (uint32_t key, uint8_t layer, uint16_t newValue);
 
     int             GetUbxVal (uint32_t key, uint8_t layer, uint32_t &answer );
     int             SetUbxVal (uint32_t key, uint8_t layer, uint32_t newValue);
 
private:
     /* Utilities for communication with the ZedF9P */
     char *WriteHeaderToBuffer (char *buffer);
     char *WriteKeyToBuffer    (char *buffer, uint32_t key );
     char *WriteLayerToBuffer  (char *buffer, uint8_t  layer);
     char *WriteMessageLengthToBuffer (char *buffer, uint16_t length);
     char *WriteTransactionAndReservedToBuffer (char *buffer, uint8_t transaction);
   //  char *WriteBooleanToBuffer (char *buffer, const boolean value);
     char *WriteUint8ToBuffer   (char *buffer, const uint8_t value);
     char *WriteUint16ToBuffer   (char *buffer, const uint16_t value);
     char *WriteUint32ToBuffer   (char *buffer, const uint32_t value);
 
     int  SendConfigMessage (char *buffer);
   };
 
} // End namespace Geometrics
 
#endif