functions.hpp

Go to the documentation of this file.

#ifndef NIX_LIBS_NMEA_NMEATOOLS_HPP_
#define NIX_LIBS_NMEA_NMEATOOLS_HPP_
 
#include "comms/nmea/enums.hpp"
#include "core/CStringTools.hpp"
#include "core/defines.hpp"
#include "core/parsers.hpp"
 
#include <sstream>
#include <vector>
 
#define MINUTE_LENGTH 8
#define KNOTS_TO_MPS 0.514444444
 
namespace iv::comms::nmea0183
{
inline std::string nmeaChecksum(const std::string &completeMsg)
{
    uint16_t checkSum {0};
 
    // Obtener el mensaje desde el $ hasta el ultimo * del CRC, sin incluir estos caracteres
 
    // Compute the checkSum by XORing all the character values in the string.
    for (std::string msgFiltered =
                 completeMsg.substr(completeMsg.find_first_not_of(iv::constants::comms::nmea::nmeaHeaderStart),
                                    completeMsg.find_last_of(iv::constants::comms::nmea::nmeaChecksumDelimiter) -
                                            completeMsg.find_first_not_of(iv::constants::comms::nmea::nmeaHeaderStart));
         const char c: msgFiltered)
    {
        checkSum ^= static_cast<uint8_t>(c);
    }
 
    // Convert it to hexadecimal (base-16, upper case, most significant nybble first).
    std::stringstream stream;
    stream << std::uppercase << std::hex << checkSum;
 
    std::string hexCheckSum = stream.str();
    if (hexCheckSum.length() < 2)
    {
        hexCheckSum = "0" + hexCheckSum;
    }
 
    return hexCheckSum;
}
[[nodiscard]]
inline double degreesToDecimal(const int32_t degrees, const double minutes, const int32_t seconds = 0)
{
    return (degrees * 60) + minutes + static_cast<float>(seconds) / 3600.0f;
}
 
inline std::vector<std::string> splitStringBy(const std::string &sentence, const char delimiter)
{
    std::vector<std::string> returnVector;
    std::stringstream ssSentence(sentence);
    std::string element;
 
    while (std::getline(ssSentence, element, delimiter))
    {
        returnVector.push_back(element);
    }
 
    return returnVector;
}
 
[[nodiscard]]
inline bool getCoordinates(std::string array, double &decimalDegrees)
{
    bool isOk {false};
 
    if (array.length() > MINUTE_LENGTH)
    {
        std::string degreeArray;
        std::string minuteArray;
 
        isOk = true;
        degreeArray.assign(array.begin(), array.end() - MINUTE_LENGTH);
        minuteArray.assign(array.end() - MINUTE_LENGTH, array.end());
 
        const int32_t degrees = iv::utils::parseNumber<int32_t>(degreeArray).value_or(0);
        const double minutes = iv::utils::parseNumber<double>(minuteArray).value_or(0);
        decimalDegrees = degreesToDecimal(degrees, minutes);
    }
 
    return isOk;
}
 
[[nodiscard]] inline std::optional<bool> nmea0183FieldToBoolean(std::string_view data)
{
    if (data == "1")
    {
        return true;
    }
    if (data == "0")
    {
        return false;
    }
 
    IV_ASSERT_MSG("Invalid boolean value");
 
    return std::nullopt;
}
 
[[nodiscard]] inline std::optional<uint16_t> nmea0183FieldToInteger(std::string_view data)
{
    return iv::utils::parseNumber<uint16_t>(data);
}
 
[[nodiscard]] inline std::optional<float> nmea0183FieldToFloat(std::string_view data)
{
    return iv::utils::parseNumber<float>(data);
}
[[nodiscard]] inline std::optional<std::string> nmea0183FieldToTime(std::string_view data)
{
    //Hacer alguna comprobación de validez cuando se vaya a usar esto
    std::string_view hours = data.substr(0, 2);
    std::string_view minutes = data.substr(2, 2);
    std::string_view seconds = data.substr(4, 2);
    return fmt::format("Hours: {}, Minutes: {}, Seconds: {}", hours, minutes, seconds);
}
[[nodiscard]] inline std::optional<iv::comms::nmea0183::Pole> nmeaField0183ToPole(std::string_view data)
{
    if (data == "T")
    {
        return Pole::True;
    }
    else if (data == "M")
    {
        return Pole::Magnetic;
    }
 
    IV_ASSERT_MSG("Invalid pole value");
 
    return std::nullopt;
}
 
inline std::optional<iv::types::channelValue> processValue(std::string_view stringValue,
                                                           iv::comms::nmea0183::eFieldType nmeaFieldType)
{
    std::optional<iv::types::channelValue> retValue;
 
    switch (nmeaFieldType)
    {
        case iv::comms::nmea0183::eFieldType::Boolean:
            retValue = nmea0183FieldToBoolean(stringValue);
            break;
 
        case iv::comms::nmea0183::eFieldType::Integer:
            retValue = nmea0183FieldToInteger(stringValue);
            break;
 
        case iv::comms::nmea0183::eFieldType::Decimal:
            retValue = nmea0183FieldToFloat(stringValue);
            break;
 
        case iv::comms::nmea0183::eFieldType::String:
            // TODO: Implementar el parseo de string
            retValue = stringValue.at(0);
            break;
 
        default:
            throw iv::exception::NotImplemented("NMEA0183 Field Type not implemented", __FILE__, __LINE__);
            break;
    }
    return retValue;
}
 
}// namespace iv::comms::nmea0183
 
#endif//NIX_LIBS_NMEA_NMEATOOLS_HPP_