CanProtobuf.hpp

Go to the documentation of this file.

// Copyright (C) 2021 COGIP Robotics association <cogip35@gmail.com>
// This file is subject to the terms and conditions of the GNU Lesser
// General Public License v2.1. See the file LICENSE in the top level
// directory for more details.
 
 
#pragma once
 
#include "etl/delegate.h"
 
// RIOT includes
#include <mutex.h>
#include "can/conn/raw.h"
#include "periph/can.h"
#include "ringbuffer.h"
#include "thread.h"
#include "etl/map.h"
 
#include "canpb/canpb.hpp"
#include "canpb/ReadBuffer.hpp"
#include "canpb/WriteBuffer.hpp"
 
#include "MessageInterface.h"
 
// Double the size of the ringbuffer receiving input bytes,
// so we can continue receiving data even if the thread decoding
// the message has not consumed previous message immediately.
#define CAN_BUFFER_SIZE CANPB_INPUT_MESSAGE_LENGTH_MAX*2
 
namespace cogip {
 
namespace canpb {
 
using uuid_t = uint32_t;
 
using message_handler_t = etl::delegate<void(cogip::canpb::ReadBuffer &)>;
 
void *message_reader_wrapper(
    void *arg                                     
    );
 
class CanProtobuf {
public:
 
    explicit CanProtobuf(
        uint8_t can_interface_number    
        );
 
    bool init(struct can_filter *filter);
 
    void start_reader();
 
    void can_rx_cb(
        uint8_t data                              
        );
 
    void message_reader();
 
    bool send_message(
        uuid_t uuid,                              
        const EmbeddedProto::MessageInterface *message = nullptr
        );
 
    void register_message_handler(
        uuid_t uuid,                              
        message_handler_t handler                 
        );
 
private:
    conn_can_raw_t conn_can_raw_;                 
    uint8_t can_interface_number_;                
    kernel_pid_t reader_pid_;                     
    ringbuffer_t rx_buf_;                         
    uint32_t msg_length_ = 0;                     
    mutex_t mutex_ = MUTEX_INIT;                  
    etl::map<uuid_t, message_handler_t, CANPB_MAX_HANDLERS> message_handlers_;
    char reader_stack_[CANPB_READER_STACKSIZE];  
    char rx_mem_[CAN_BUFFER_SIZE];               
    ReadBuffer read_buffer_;                      
    WriteBuffer write_buffer_;                    
};
 
} // namespace canpb
 
} // namespace cogip