sbgEComBinaryLogGps.h

Go to the documentation of this file.

 
#ifndef __SBG_ECOM_BINARY_LOG_GPS_H__
#define __SBG_ECOM_BINARY_LOG_GPS_H__
 
#include <sbgCommon.h>
#include <streamBuffer/sbgStreamBuffer.h>
 
//----------------------------------------------------------------------//
//- Log GPS velocity const definitions                                 -//
//----------------------------------------------------------------------//
 
#define SBG_ECOM_GPS_VEL_STATUS_SHIFT           (0u)                                    
#define SBG_ECOM_GPS_VEL_STATUS_MASK            (0x0000003Fu)                   
#define SBG_ECOM_GPS_VEL_TYPE_SHIFT                     (6u)                                    
#define SBG_ECOM_GPS_VEL_TYPE_MASK                      (0x0000003Fu)                   
//----------------------------------------------------------------------//
//- Log GPS position const definitions                                 -//
//----------------------------------------------------------------------//
 
#define SBG_ECOM_GPS_POS_STATUS_SHIFT           (0u)                                    
#define SBG_ECOM_GPS_POS_STATUS_MASK            (0x0000003Fu)                   
#define SBG_ECOM_GPS_POS_TYPE_SHIFT                     (6u)                                    
#define SBG_ECOM_GPS_POS_TYPE_MASK                      (0x0000003Fu)                   
#define SBG_ECOM_GPS_POS_GPS_L1_USED            (0x00000001u << 12)             
#define SBG_ECOM_GPS_POS_GPS_L2_USED            (0x00000001u << 13)             
#define SBG_ECOM_GPS_POS_GPS_L5_USED            (0x00000001u << 14)             
#define SBG_ECOM_GPS_POS_GLO_L1_USED            (0x00000001u << 15)             
#define SBG_ECOM_GPS_POS_GLO_L2_USED            (0x00000001u << 16)             
//----------------------------------------------------------------------//
//- Log GPS HDT const definitions                                      -//
//----------------------------------------------------------------------//
 
#define SBG_ECOM_GPS_HDT_STATUS_SHIFT           (0u)                                    
#define SBG_ECOM_GPS_HDT_STATUS_MASK            (0x0000003Fu)                   
#define SBG_ECOM_GPS_HDT_BASELINE_VALID         (0x0001 << 6)                   
//----------------------------------------------------------------------//
//- Log GPS RAW const definitions                                      -//
//----------------------------------------------------------------------//
 
#define SBG_ECOM_GPS_RAW_MAX_BUFFER_SIZE        (4086u)                                 
//----------------------------------------------------------------------//
//- Log GPS velocity enums definitions                                 -//
//----------------------------------------------------------------------//
 
typedef enum _SbgEComGpsVelStatus
{
        SBG_ECOM_VEL_SOL_COMPUTED               = 0,                                                    
        SBG_ECOM_VEL_INSUFFICIENT_OBS   = 1,                                                    
        SBG_ECOM_VEL_INTERNAL_ERROR             = 2,                                                    
        SBG_ECOM_VEL_LIMIT                              = 3                                                             
} SbgEComGpsVelStatus;
 
typedef enum _SbgEComGpsVelType
{
        SBG_ECOM_VEL_NO_SOLUTION                = 0,                                                    
        SBG_ECOM_VEL_UNKNOWN_TYPE               = 1,                                                    
        SBG_ECOM_VEL_DOPPLER                    = 2,                                                    
        SBG_ECOM_VEL_DIFFERENTIAL               = 3                                                             
} SbgEComGpsVelType;
 
//----------------------------------------------------------------------//
//- Log GPS position enums definitions                                 -//
//----------------------------------------------------------------------//
 
typedef enum _SbgEComGpsPosStatus
{
        SBG_ECOM_POS_SOL_COMPUTED               = 0,                                                    
        SBG_ECOM_POS_INSUFFICIENT_OBS   = 1,                                                    
        SBG_ECOM_POS_INTERNAL_ERROR             = 2,                                                    
        SBG_ECOM_POS_HEIGHT_LIMIT               = 3                                                             
} SbgEComGpsPosStatus;
 
typedef enum _SbgEComGpsPosType
{
        SBG_ECOM_POS_NO_SOLUTION                = 0,                                                    
        SBG_ECOM_POS_UNKNOWN_TYPE               = 1,                                                    
        SBG_ECOM_POS_SINGLE                             = 2,                                                    
        SBG_ECOM_POS_PSRDIFF                    = 3,                                                    
        SBG_ECOM_POS_SBAS                               = 4,                                                    
        SBG_ECOM_POS_OMNISTAR                   = 5,                                                    
        SBG_ECOM_POS_RTK_FLOAT                  = 6,                                                    
        SBG_ECOM_POS_RTK_INT                    = 7,                                                    
        SBG_ECOM_POS_PPP_FLOAT                  = 8,                                                    
        SBG_ECOM_POS_PPP_INT                    = 9,                                                    
        SBG_ECOM_POS_FIXED                              = 10                                                    
} SbgEComGpsPosType;
 
//----------------------------------------------------------------------//
//- Log GPS HDT enums definitions                                      -//
//----------------------------------------------------------------------//
 
typedef enum _SbgEComGpsHdtStatus
{
        SBG_ECOM_HDT_SOL_COMPUTED               = 0,                                                    
        SBG_ECOM_HDT_INSUFFICIENT_OBS   = 1,                                                    
        SBG_ECOM_HDT_INTERNAL_ERROR             = 2,                                                    
        SBG_ECOM_HDT_HEIGHT_LIMIT               = 3                                                             
} SbgEComGpsHdtStatus;
 
//----------------------------------------------------------------------//
//- Helpers methods for velocity status access                         -//
//----------------------------------------------------------------------//
 
SBG_INLINE SbgEComGpsVelStatus sbgEComLogGpsVelGetStatus(uint32_t status)
{
        return (SbgEComGpsVelStatus)((status >> SBG_ECOM_GPS_VEL_STATUS_SHIFT) & SBG_ECOM_GPS_VEL_STATUS_MASK);
}
 
SBG_INLINE SbgEComGpsVelType sbgEComLogGpsVelGetType(uint32_t status)
{
        return (SbgEComGpsVelType)((status >> SBG_ECOM_GPS_VEL_TYPE_SHIFT) & SBG_ECOM_GPS_VEL_TYPE_MASK);
}
 
SBG_INLINE uint32_t sbgEComLogGpsVelBuildStatus(SbgEComGpsVelStatus status, SbgEComGpsVelType type)
{
        //
        // Create the combined status field
        //
        return  ((((uint32_t)status)&SBG_ECOM_GPS_VEL_STATUS_MASK) << SBG_ECOM_GPS_VEL_STATUS_SHIFT) |
                        ((((uint32_t)type)&SBG_ECOM_GPS_VEL_TYPE_MASK) << SBG_ECOM_GPS_VEL_TYPE_SHIFT);
}
 
//----------------------------------------------------------------------//
//- Helpers methods for position status access                         -//
//----------------------------------------------------------------------//
 
SBG_INLINE SbgEComGpsPosStatus sbgEComLogGpsPosGetStatus(uint32_t status)
{
        return (SbgEComGpsPosStatus)((status >> SBG_ECOM_GPS_POS_STATUS_SHIFT) & SBG_ECOM_GPS_POS_STATUS_MASK);
}
 
SBG_INLINE SbgEComGpsPosType sbgEComLogGpsPosGetType(uint32_t status)
{
        return (SbgEComGpsPosType)((status >> SBG_ECOM_GPS_POS_TYPE_SHIFT) & SBG_ECOM_GPS_POS_TYPE_MASK);
}
 
SBG_INLINE uint32_t sbgEComLogGpsPosBuildStatus(SbgEComGpsPosStatus status, SbgEComGpsPosType type, uint32_t masks)
{
        //
        // Create the combined status field
        //
        return  ((((uint32_t)status)&SBG_ECOM_GPS_POS_STATUS_MASK) << SBG_ECOM_GPS_POS_STATUS_SHIFT) |
                        ((((uint32_t)type)&SBG_ECOM_GPS_POS_TYPE_MASK) << SBG_ECOM_GPS_POS_TYPE_SHIFT) | masks;
}
 
//----------------------------------------------------------------------//
//- Helpers methods for HDT status access                              -//
//----------------------------------------------------------------------//
 
SBG_INLINE SbgEComGpsHdtStatus sbgEComLogGpsHdtGetStatus(uint32_t status)
{
        return (SbgEComGpsHdtStatus)((status >> SBG_ECOM_GPS_HDT_STATUS_SHIFT) & SBG_ECOM_GPS_HDT_STATUS_MASK);
}
 
SBG_INLINE uint32_t sbgEComLogGpsHdtBuildStatus(SbgEComGpsHdtStatus status, uint32_t masks)
{
        //
        // Create the combined status field
        //
        return  ((((uint32_t)status)&SBG_ECOM_GPS_HDT_STATUS_MASK) << SBG_ECOM_GPS_HDT_STATUS_SHIFT) | masks;
}
 
//----------------------------------------------------------------------//
//- Log structure definitions                                          -//
//----------------------------------------------------------------------//
 
typedef struct _SbgLogGpsVel
{
        uint32_t                        timeStamp;                              
        uint32_t                        status;                                 
        uint32_t                        timeOfWeek;                             
        float                   velocity[3];                    
        float                   velocityAcc[3];                 
        float                   course;                                 
        float                   courseAcc;                              
} SbgLogGpsVel;
 
typedef struct _SbgLogGpsPos
{
        uint32_t                        timeStamp;                              
        uint32_t                        status;                                 
        uint32_t                        timeOfWeek;                             
        double                  latitude;                               
        double                  longitude;                              
        double                  altitude;                               
        float                   undulation;                             
        float                   latitudeAccuracy;               
        float                   longitudeAccuracy;              
        float                   altitudeAccuracy;               
        uint8_t                 numSvUsed;                              
        uint16_t                        baseStationId;                  
        uint16_t                        differentialAge;                
} SbgLogGpsPos;
 
typedef struct _SbgLogGpsHdt
{
        uint32_t                        timeStamp;                              
        uint16_t                        status;                                 
        uint32_t                        timeOfWeek;                             
        float                   heading;                                
        float                   headingAccuracy;                
        float                   pitch;                                  
        float                   pitchAccuracy;                  
        float                   baseline;                               
} SbgLogGpsHdt;
 
typedef struct _SbgLogGpsRaw
{
        uint8_t                 rawBuffer[SBG_ECOM_GPS_RAW_MAX_BUFFER_SIZE];    
        size_t                  bufferSize;                                                                             
} SbgLogGpsRaw;
 
//----------------------------------------------------------------------//
//- Operations                                                         -//
//----------------------------------------------------------------------//
 
SbgErrorCode sbgEComBinaryLogParseGpsVelData(SbgStreamBuffer *pInputStream, SbgLogGpsVel *pOutputData);
 
SbgErrorCode sbgEComBinaryLogWriteGpsVelData(SbgStreamBuffer *pOutputStream, const SbgLogGpsVel *pInputData);
 
SbgErrorCode sbgEComBinaryLogParseGpsPosData(SbgStreamBuffer *pInputStream, SbgLogGpsPos *pOutputData);
 
SbgErrorCode sbgEComBinaryLogWriteGpsPosData(SbgStreamBuffer *pOutputStream, const SbgLogGpsPos *pInputData);
 
SbgErrorCode sbgEComBinaryLogParseGpsHdtData(SbgStreamBuffer *pInputStream, SbgLogGpsHdt *pOutputData);
 
SbgErrorCode sbgEComBinaryLogWriteGpsHdtData(SbgStreamBuffer *pOutputStream, const SbgLogGpsHdt *pInputData);
 
SbgErrorCode sbgEComBinaryLogParseGpsRawData(SbgStreamBuffer *pInputStream, SbgLogGpsRaw *pOutputData);
 
SbgErrorCode sbgEComBinaryLogWriteGpsRawData(SbgStreamBuffer *pOutputStream, const SbgLogGpsRaw *pInputData);
 
#endif