BenchmarkCan.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_BENCHMARKCAN_HXX_
#define _FREERTOS_DRIVERS_COMMON_BENCHMARKCAN_HXX_
 
#include "freertos_drivers/common/Can.hxx"
#include "utils/Atomic.hxx"
 
class BenchmarkCan : public Can, private Atomic
{
public:
    BenchmarkCan(const char *name)
        : Can(name)
        , readTimeLast_(0)
        , readCount_(0)
    {
    }
 
    ~BenchmarkCan()
    {
    }
 
    void start_benchmark(const struct can_frame *frame, unsigned count)
    {
        bool need_signal = false;
        {
            AtomicHolder h(this);
            packet_ = *frame;
            readCount_ = count;
            need_signal = refill_locked();
        }
        if (need_signal)
        {
            rxBuf->signal_condition();
        }
    }
 
    long long get_timestamp(unsigned *count)
    {
        *count = readCount_;
        return readTimeLast_;
    }
 
private:
    ssize_t read(File *file, void *buf, size_t count) override
    {
        ssize_t result = Can::read(file, buf, count);
 
        bool need_signal = false;
        if (result > 0)
        {
            AtomicHolder lock(this);
            readTimeLast_ = OSTime::get_monotonic();
            unsigned num_frames = result / sizeof(struct can_frame);
            if (readCount_ > num_frames)
            {
                readCount_ -= num_frames;
            }
            else
            {
                readCount_ = 0;
            }
            need_signal = refill_locked();
        }
        if (need_signal)
        {
            rxBuf->signal_condition();
        }
        return result;
    }
 
    ssize_t write(File *file, const void *buf, size_t count) override
    {
        /* drop all the written data on the floor */
        return count;
    }
 
    bool refill_locked()
    {
        bool need_signal = false;
        while ((rxBuf->pending() < readCount_) && (rxBuf->space()))
        {
            if (rxBuf->pending() == 0)
            {
                need_signal = true;
            }
            rxBuf->put(&packet_, 1);
        }
        return need_signal;
    }
 
    void enable() override
    {
    }
    void disable() override
    {
    }
    void tx_msg() override
    {
    }
 
    struct can_frame packet_; 
    long long readTimeLast_;  
    size_t readCount_;        
    DISALLOW_COPY_AND_ASSIGN(BenchmarkCan);
};
 
#endif /* _FREERTOS_DRIVERS_COMMON_BENCHMARKCAN_HXX_ */