CanReader.hpp

[詳解]

//
//    CAN通信 受信クラス
//
//    Copyright (c) 2022 udonrobo
//
 
#pragma once
 
#include "ICanBus.hpp"
 
#include <Udon/Serializer/Serializer.hpp>
#include <Udon/Serializer/SerializerTraits.hpp>
#include <Udon/Utility/Show.hpp>
#include <Udon/Utility/Time.hpp>
#include <Udon/Utility/Printf.hpp>
 
namespace Udon
{

    template <typename Message>
    class CanReader
    {
 
        static_assert(Traits::IsSerializable<Message>::value, "Message must be parsable.");
 
    public:
        using MessageType = Message;

        static constexpr size_t Size = Udon::SerializedSize<Message>();

        CanReader(ICanBus& bus, const uint32_t id)
            : node{ bus.createRx(id, Size) }
        {
            node->onReceive = [](void* p)
            {
                auto self = static_cast<CanReader*>(p);
                self->message = Udon::Deserialize<Message>({ self->node->data });
            };
            node->param = this;
        }

        CanReader(const CanReader&) = delete;

        CanReader(CanReader&& other)
            : node{ other.node }
        {
            node->param = this;    // ここでotherに登録されていたthisポインタを上書きするため、コピーすることができない
        }

        explicit operator bool() const
        {
            return Millis() - node->transmitMs < 100;
        }

        Udon::Optional<MessageType> getMessage() const
        {
            if (*this)
            {
                return message;
            }
            else
            {
                return Udon::nullopt;
            }
        }

        void show() const
        {
            Udon::Printf("0x%03x ", node->id);
            if (const auto m = getMessage())
            {
                Udon::Show(*m);
            }
            else
            {
                Udon::Show(F("receive failed!"));
            }
        }

        void showRaw() const
        {
            Udon::Printf("0x%03x ", node->id);
            for (const auto n : node->data)
            {
                Udon::Show(n);
            }
        }
 
    private:
        CanRxNode* node;
 
        Udon::Optional<MessageType> message;
    };
 
}    // namespace Udon