can_io.hpp

Go to the documentation of this file.

/*
 * CAN bus IO logic.
 * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
 * Copyright (C) 2019 Theodoros Ntakouris <zarkopafilis@gmail.com>
 */
 
#ifndef UAVCAN_TRANSPORT_CAN_IO_HPP_INCLUDED
#define UAVCAN_TRANSPORT_CAN_IO_HPP_INCLUDED
 
#include <cassert>
#include <uavcan/error.hpp>
#include <uavcan/std.hpp>
#include <uavcan/util/linked_list.hpp>
#include <uavcan/util/avl_tree.hpp>
#include <uavcan/dynamic_memory.hpp>
#include <uavcan/build_config.hpp>
#include <uavcan/util/templates.hpp>
#include <uavcan/util/lazy_constructor.hpp>
#include <uavcan/driver/can.hpp>
#include <uavcan/driver/system_clock.hpp>
#include <uavcan/time.hpp>
 
namespace uavcan
{
struct UAVCAN_EXPORT CanRxFrame : public CanFrame
{
    MonotonicTime ts_mono;
    UtcTime ts_utc;
    uint8_t iface_index;
 
    CanRxFrame()
        : iface_index(0)
    { }
 
#if UAVCAN_TOSTRING
    std::string toString(StringRepresentation mode = StrTight) const;
#endif
};
 
struct UAVCAN_EXPORT CanTxQueueEntry  // Not required to be packed - fits the block in any case
{
    MonotonicTime deadline;
    const CanFrame frame;
    CanIOFlags flags;
 
    CanTxQueueEntry(const CanFrame& arg_frame, const MonotonicTime arg_deadline, CanIOFlags arg_flags)
        : deadline(arg_deadline)
        , frame(arg_frame)
        , flags(arg_flags)
    {
        IsDynamicallyAllocatable<CanTxQueueEntry>::check();
    }
 
    static void destroy(CanTxQueueEntry*& obj, IPoolAllocator& allocator);
 
    bool isExpired(const MonotonicTime timestamp) const { return timestamp > deadline; }
 
    bool operator<(const CanTxQueueEntry& other) const
    {
        return this->frame.priorityLowerThan(other.frame);
    }
 
    bool operator>(const CanTxQueueEntry& other) const
    {
        return this->frame.priorityHigherThan(other.frame);
    }
 
    bool operator==(const CanTxQueueEntry& other) const
    {
        return this->frame == other.frame;
    }
 
#if UAVCAN_TOSTRING
        std::string toString() const;
#endif
};
 
class UAVCAN_EXPORT CanTxQueue : public AvlTree<CanTxQueueEntry>
{
private:
    void postOrderTraverseEntryCleanup(Node* n);
 
protected:
    ISystemClock& sysclock_;
    uint32_t rejected_frames_cnt_;
 
    bool linkedListContains(Node* head, const CanFrame& frame) const;
    void safeIncrementRejectedFrames();
    AvlTree::Node* searchForNonExpiredMax(Node* n);
 
public:
    CanTxQueue(IPoolAllocator& allocator, ISystemClock& sysclock, std::size_t allocator_quota) :
        AvlTree(allocator, allocator_quota),
        sysclock_(sysclock),
        rejected_frames_cnt_(0)
    {}
 
    ~CanTxQueue() override;
 
    /* Avl Tree allocates the AvlTree::Node, while this(CanTxQueue) allocates the CanTxQueueEntry
     * Same logic for removal. */
    void push(const CanFrame& frame, MonotonicTime tx_deadline, CanIOFlags flags);
    void remove(CanTxQueueEntry* entry);
 
    uint32_t getRejectedFrameCount() const { return rejected_frames_cnt_; }
 
    bool contains(const CanFrame& frame) const;
 
    /* Tries to look up rightmost Node. If the frame is expired, removes it and continues traversing */
    CanTxQueueEntry* peek();
 
    bool topPriorityHigherOrEqual(const CanFrame& rhs_frame);
};
 
struct UAVCAN_EXPORT CanIfacePerfCounters
{
    uint64_t frames_tx;
    uint64_t frames_rx;
    uint64_t errors;
 
    CanIfacePerfCounters()
        : frames_tx(0)
        , frames_rx(0)
        , errors(0)
    { }
};
 
class UAVCAN_EXPORT CanIOManager : Noncopyable
{
    struct IfaceFrameCounters
    {
        uint64_t frames_tx;
        uint64_t frames_rx;
 
        IfaceFrameCounters()
            : frames_tx(0)
            , frames_rx(0)
        { }
    };
 
    ICanDriver& driver_;
    ISystemClock& sysclock_;
 
    LazyConstructor<CanTxQueue> tx_queues_[MaxCanIfaces];
    IfaceFrameCounters counters_[MaxCanIfaces];
 
    const uint8_t num_ifaces_;
 
    int sendToIface(uint8_t iface_index, const CanFrame& frame, MonotonicTime tx_deadline, CanIOFlags flags);
    int sendFromTxQueue(uint8_t iface_index);
    int callSelect(CanSelectMasks& inout_masks, const CanFrame* (& pending_tx)[MaxCanIfaces],
                   MonotonicTime blocking_deadline);
 
public:
    CanIOManager(ICanDriver& driver, IPoolAllocator& allocator, ISystemClock& sysclock,
                 std::size_t mem_blocks_per_iface = 0);
 
    uint8_t getNumIfaces() const { return num_ifaces_; }
 
    CanIfacePerfCounters getIfacePerfCounters(uint8_t iface_index) const;
 
    const ICanDriver& getCanDriver() const { return driver_; }
    ICanDriver& getCanDriver()             { return driver_; }
 
    uint8_t makePendingTxMask() const;
 
    int send(const CanFrame& frame, MonotonicTime tx_deadline, MonotonicTime blocking_deadline,
             uint8_t iface_mask, CanIOFlags flags);
    int receive(CanRxFrame& out_frame, MonotonicTime blocking_deadline, CanIOFlags& out_flags);
};
 
}
 
#endif // UAVCAN_TRANSPORT_CAN_IO_HPP_INCLUDED