UbloxUartSensor.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <memory>
#include <vector>
 
#include "uart/sensors/sensors.hpp"
#include "util/Logger.hpp"
 
namespace NAV::vendor::ublox
{
class UbloxUartSensor
{
  public:
    explicit UbloxUartSensor(std::string name);
 
    UbloxUartSensor() = default;
    ~UbloxUartSensor() = default;
    UbloxUartSensor(const UbloxUartSensor&) = delete;
    UbloxUartSensor(UbloxUartSensor&&) = delete;
    UbloxUartSensor& operator=(const UbloxUartSensor&) = delete;
    UbloxUartSensor& operator=(UbloxUartSensor&&) = delete;
    uart::sensors::UartSensor* operator->() { return &_sensor; };
 
    std::unique_ptr<uart::protocol::Packet> findPacket(uint8_t dataByte);
 
    static constexpr uint8_t BINARY_SYNC_CHAR_1 = 0xB5; 
    static constexpr uint8_t BINARY_SYNC_CHAR_2 = 0x62; 
    static constexpr uint8_t ASCII_START_CHAR = '$';    
 
  private:
    const std::string _name;
 
    uart::sensors::UartSensor _sensor{ ENDIANNESS,
                                       packetFinderFunction,
                                       this,
                                       packetTypeFunction,
                                       checksumFunction,
                                       isErrorFunction,
                                       isResponseFunction,
                                       PACKET_HEADER_LENGTH };
 
    static void packetFinderFunction(const std::vector<uint8_t>& data,
                                     const uart::xplat::TimeStamp& timestamp,
                                     uart::sensors::UartSensor::ValidPacketFoundHandler dispatchPacket, void* dispatchPacketUserData,
                                     void* userData);
 
    static uart::protocol::Packet::Type packetTypeFunction(const uart::protocol::Packet& packet);
 
    static bool checksumFunction(const uart::protocol::Packet& packet);
 
    static bool isErrorFunction(const uart::protocol::Packet& packet);
 
    static bool isResponseFunction(const uart::protocol::Packet& packet);
 
    static constexpr uart::Endianness ENDIANNESS = uart::Endianness::ENDIAN_LITTLE; 
    static constexpr size_t PACKET_HEADER_LENGTH = 2;                               
    static constexpr uint8_t ASCII_END_CHAR_1 = '\r';                               
    static constexpr uint8_t ASCII_END_CHAR_2 = '\n';                               
    static constexpr uint8_t ASCII_ESCAPE_CHAR = '\0';                              
 
    bool _currentlyBuildingAsciiPacket{ false };  
    bool _currentlyBuildingBinaryPacket{ false }; 
 
    bool _asciiEndChar1Found{ false };        
    bool _binarySyncChar2Found{ false };      
    bool _binaryMsgClassFound{ false };       
    bool _binaryMsgIdFound{ false };          
    bool _binaryPayloadLength1Found{ false }; 
    bool _binaryPayloadLength2Found{ false }; 
 
    uint8_t _binaryMsgClass{ 0 };
    uint8_t _binaryMsgId{ 0 };
    uint16_t _binaryPayloadLength{ 0 };
 
    std::vector<uint8_t> _buffer;
 
    size_t _runningDataIndex{ 0 };
    size_t _numOfBytesRemainingForCompletePacket{ 0 };
 
#if LOG_LEVEL <= LOG_LEVEL_DATA
    std::vector<uint8_t> _unrecognizedBytes;
#endif
 
    void resetTracking();
};
 
} // namespace NAV::vendor::ublox