CanProtocol.h

Go to the documentation of this file.

/* Copyright (c) 2022 Skyward Experimental Rocketry
 * Author: Federico Mandelli
 *
 * 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/canbus/CanDriver/CanDriver.h>
#include <utils/Debug.h>
#include <utils/collections/SyncCircularBuffer.h>
 
#include "CanProtocolData.h"
#include "CanProtocolTypes.h"
 
namespace Boardcore
{
 
namespace Canbus
{
 
class CanProtocol
{
    using MsgHandler = std::function<void(const CanMessage& data)>;
 
public:
    CanProtocol(CanbusDriver* can, MsgHandler onReceive,
                miosix::Priority threadPriority);
 
    bool start();
 
    bool isStarted();
 
    void stop();
 
    bool addFilter(uint8_t src, uint64_t dst);
 
    bool enqueueMsg(const CanMessage& msg);
 
    bool enqueueEvent(uint8_t priority, uint8_t primaryType, uint8_t source,
                      uint8_t destination, uint8_t secondaryType);
 
    bool enqueueSimplePacket(uint8_t priority, uint8_t primaryType,
                             uint8_t source, uint8_t destination,
                             uint8_t secondaryType, uint64_t payload);
 
    template <typename T>
    bool enqueueData(uint8_t priority, uint8_t primaryType, uint8_t source,
                     uint8_t destination, uint8_t secondaryType, const T& t);
 
private:
    void sendMessage(const CanMessage& msg);
 
    void runReceiver();
 
    void runSender();
 
    static void rcvLauncher(void* arg);
 
    static void sndLauncher(void* arg);
 
    uint8_t byteForUint64(uint64_t number);
 
    CanbusDriver* can;     
    MsgHandler onReceive;  
 
    // Threads
    bool stopFlag   = false;
    bool sndStarted = false;
    bool rcvStarted = false;
 
    miosix::Thread* sndThread = nullptr;
    miosix::Thread* rcvThread = nullptr;
    miosix::Priority threadPriority;
 
    SyncCircularBuffer<CanMessage, 10> outQueue;
 
    PrintLogger logger = Logging::getLogger("canprotocol");
};
 
template <typename T>
bool CanProtocol::enqueueData(uint8_t priority, uint8_t primaryType,
                              uint8_t source, uint8_t destination,
                              uint8_t secondaryType, const T& t)
{
    if (priority > 0xF || primaryType > 0x3F || source > 0xF ||
        destination > 0xF || secondaryType > 0xF)
    {
        return false;
    }
 
    CanMessage msg = toCanMessage(t);
 
    // clang-format off
    msg.id =  priority      << static_cast<uint32_t>(CanProtocolShiftInformation::PRIORITY);
    msg.id |= primaryType   << static_cast<uint32_t>(CanProtocolShiftInformation::PRIMARY_TYPE);
    msg.id |= source        << static_cast<uint32_t>(CanProtocolShiftInformation::SOURCE);
    msg.id |= destination   << static_cast<uint32_t>(CanProtocolShiftInformation::DESTINATION);
    msg.id |= secondaryType << static_cast<uint32_t>(CanProtocolShiftInformation::SECONDARY_TYPE);
    // clang-format off
 
    return enqueueMsg(msg);
}
 
}  // namespace Canbus
 
}  // namespace Boardcore