VNCommonSerial.h

Go to the documentation of this file.

/* Copyright (c) 2024 Skyward Experimental Rocketry
 * Authors: Matteo Pignataro, Lorenzo Cucchi, Fabrizio Monti
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <diagnostic/PrintLogger.h>
#include <drivers/usart/USART.h>
#include <sensors/SensorData.h>
 
namespace Boardcore
{
 
class VNCommonSerial
{
public:
    enum class CRCOptions : uint8_t
    {
        CRC_NO        = 0x00,
        CRC_ENABLE_8  = 0x08,
        CRC_ENABLE_16 = 0x10
    };
 
    VNCommonSerial(USART& usart, int baudrate, const char* sensorName,
                   CRCOptions crc, const std::chrono::milliseconds timeout);
 
    ~VNCommonSerial();
 
    bool closeAndReset();
 
    bool startHSIEstimator(uint8_t convergeRate);
 
    bool stopHSIEstimator();
 
    std::string getHSIEstimatorValues();
 
    bool setMagnetometerCompensation(const Eigen::Matrix3f& c,
                                     const Eigen::Vector3f& b);
 
    bool setAccelerometerCompensation(const Eigen::Matrix3f& c,
                                      const Eigen::Vector3f& b);
 
    bool setGyroscopeCompensation(const Eigen::Matrix3f& c,
                                  const Eigen::Vector3f& b);
 
    bool saveConfiguration();
 
    bool restoreFactorySettings();
 
protected:
    uint8_t calculateChecksum8(const uint8_t* message, int length);
 
    uint16_t calculateChecksum16(const uint8_t* message, int length);
 
    bool verifyChecksum(char* command, int maxLength);
 
    bool disableAsyncMessages(bool waitResponse);
 
    bool setCrc(bool waitResponse = true);
 
    void configDefaultSerialPort();
 
    bool configUserSerialPort();
 
    bool verifyModelNumber(const char* expectedModelNumber);
 
    template <typename T>
    bool getBinaryOutput(T& binaryData, const char* const sampleCommand);
 
    uint8_t checkErrorVN(const char* message);
 
    bool sendStringCommand(std::string command);
 
    bool recvStringCommand(char* command, int maxLength);
 
    bool writeRegister(const std::string& command);
 
    USART& usart;
    int baudRate;
 
    CRCOptions crc;
 
    PrintLogger logger;
 
    static const int DEFAULT_BAUDRATE = 115200;
 
    static const uint8_t recvStringMaxDimension = 200;
 
    std::array<char, recvStringMaxDimension> recvString;
 
    uint8_t recvStringLength = 0;
 
    bool isInit = false;
 
private:
    const std::chrono::milliseconds maxTimeout;
};
 
template <typename T>
bool VNCommonSerial::getBinaryOutput(T& binaryData,
                                     const char* const sampleCommand)
{
    uint8_t initByte = 0;
 
    // Remove any junk
    usart.clearQueue();
 
    usart.writeString(sampleCommand);
 
    // Check the read of the 0xFA byte to find the start of the message
    if (usart.readBlocking(&initByte, 1, maxTimeout) && initByte == 0xFA)
    {
        if (usart.readBlocking(&binaryData, sizeof(T), maxTimeout))
            return true;
    }
 
    return false;
}
 
}  // namespace Boardcore