Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Ardupilot
GitHub Repository: Ardupilot/ardupilot
 Path: blob/master/libraries/AP_DroneCAN/AP_Canard_iface.h
9889 views
1
#pragma once

2
#include <AP_HAL/AP_HAL.h>

3
#if HAL_ENABLE_DRONECAN_DRIVERS

4
#include <canard/interface.h>

5
#include <dronecan_msgs.h>

6


7
class AP_DroneCAN;

8
class CANSensor;

9


10
class CanardInterface : public Canard::Interface {

11
    friend class AP_DroneCAN;

12
public:

13


14
    /// @brief delete copy constructor and assignment operator

15
    CanardInterface(const CanardInterface&) = delete;

16
    CanardInterface& operator=(const CanardInterface&) = delete;

17


18
    CanardInterface(uint8_t driver_index);

19


20
    void init(void* mem_arena, size_t mem_arena_size, uint8_t node_id);

21


22
    /// @brief broadcast message to all listeners on Interface

23
    /// @param bc_transfer

24
    /// @return true if message was added to the queue

25
    bool broadcast(const Canard::Transfer &bcast_transfer) override;

26


27
    /// @brief request message from

28
    /// @param destination_node_id

29
    /// @param req_transfer

30
    /// @return true if request was added to the queue

31
    bool request(uint8_t destination_node_id, const Canard::Transfer &req_transfer) override;

32


33
    /// @brief respond to a request

34
    /// @param destination_node_id

35
    /// @param res_transfer

36
    /// @return true if response was added to the queue

37
    bool respond(uint8_t destination_node_id, const Canard::Transfer &res_transfer) override;

38


39
    void processTx(bool raw_commands_only);

40
    void processRx();

41


42
    void process(uint32_t duration);

43


44
    static void onTransferReception(CanardInstance* ins, CanardRxTransfer* transfer);

45
    static bool shouldAcceptTransfer(const CanardInstance* ins,

46
                                     uint64_t* out_data_type_signature,

47
                                     uint16_t data_type_id,

48
                                     CanardTransferType transfer_type,

49
                                     uint8_t source_node_id);

50


51
    bool add_interface(AP_HAL::CANIface *can_drv);

52


53
    // add an auxillary driver for 11 bit frames

54
    bool add_11bit_driver(CANSensor *sensor);

55


56
    // handler for outgoing frames for auxillary drivers

57
    bool write_aux_frame(AP_HAL::CANFrame &out_frame, const uint32_t timeout_us);

58
    

59
#if AP_TEST_DRONECAN_DRIVERS

60
    static CanardInterface& get_test_iface() { return test_iface; }

61
    static void processTestRx();

62
#endif

63


64
    void update_rx_protocol_stats(int16_t res);

65


66
    uint8_t get_node_id() const override { return canard.node_id; }

67


68
    // get reference to the semaphore that is held during message receive

69
    HAL_Semaphore &get_sem_rx(void) { return _sem_rx; }

70


71
private:

72
    CanardInstance canard;

73
    AP_HAL::CANIface* ifaces[HAL_NUM_CAN_IFACES];

74
#if AP_TEST_DRONECAN_DRIVERS

75
    static CanardInterface* canard_ifaces[3];

76
    static CanardInterface test_iface;

77
#endif

78
    uint8_t num_ifaces;

79
    HAL_BinarySemaphore sem_handle;

80
    bool initialized;

81
    HAL_Semaphore _sem_tx;

82
    HAL_Semaphore _sem_rx;

83
    CanardTxTransfer tx_transfer;

84
    dronecan_protocol_Stats protocol_stats;

85


86
    // auxillary 11 bit CANSensor

87
    CANSensor *aux_11bit_driver;

88
};

89
#endif // HAL_ENABLE_DRONECAN_DRIVERS

90


91