VCR/lib/interfaces/include/HytechCANInterface.h at 296628d78c334bd44f466c2ba7d72a4c2a3e2ccd · hytech-racing/VCR · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#ifndef HYTECHCANINTERFACE
#define HYTECHCANINTERFACE

#include <FlexCAN_T4.h>
#include <hytech.h>
#include <etl/delegate.h>
#include <stdint.h>
#include <InverterInterface.h>
#include <MessageQueueDefine.h>

/* Recieve Buffers */
extern CANBufferType CAN1_rxBuffer;
extern CANBufferType CAN2_rxBuffer;
extern CANBufferType CAN3_rxBuffer;

/* Transfer Buffers */
extern CANBufferType CAN1_txBuffer;
extern CANBufferType CAN2_txBuffer;
extern CANBufferType CAN3_txBuffer;

/**
 * Struct holding the interfaces processed by the ring buffer
 */

struct CANInterfaces
{
    InverterInterface front_left_inv;
    InverterInterface front_right_inv;
    InverterInterface back_left_inv;
    InverterInterface back_right_inv;
};

/** Methods called on can recieve */
void on_can1_recieve(const CAN_message_t &msg);

void on_can2_recieve(const CAN_message_t &msg);

void on_can3_recieve(const CAN_message_t &msg);

/**
 * Recieving CAN messages
 * (needs to be called in a loop)
 */
template <typename BufferType>
void process_ring_buffer(BufferType &rx_buffer, CANInterfaces interfaces) {
    while (rx_buffer.available())
    {
        CAN_message_t recvd_msg;
        uint8_t buf[sizeof(CAN_message_t)];
        rx_buffer.pop_front(buf, sizeof(CAN_message_t));
        memmove(&recvd_msg, buf, sizeof(recvd_msg));
        switch (recvd_msg.id)
        {
            // FL Inverter
            case (MCI1_STATUS_CANID):
                interfaces.front_left_inv.recieve_MCI_STATUS(recvd_msg);
                break;

            case (MCI1_TEMPS_CANID):
                interfaces.front_left_inv.recieve_MCI_TEMPS(recvd_msg);
                break;

            case (MCI1_DYNAMICS_CANID):
                interfaces.front_left_inv.recieve_MCI_DYNAMICS(recvd_msg);
                break;

            case (MCI1_POWER_CANID):
                interfaces.front_left_inv.recieve_MCI_POWER(recvd_msg);
                break;

            case (MCI1_FEEDBACK_CANID):
                interfaces.front_left_inv.recieve_MCI_FEEDBACK(recvd_msg);

            // FR inverter
            case (MCI2_STATUS_CANID):
                interfaces.front_right_inv.recieve_MCI_STATUS(recvd_msg);
                break;

            case (MCI2_TEMPS_CANID):
                interfaces.front_right_inv.recieve_MCI_TEMPS(recvd_msg);
                break;

            case (MCI2_DYNAMICS_CANID):
                interfaces.front_right_inv.recieve_MCI_DYNAMICS(recvd_msg);
                break;

            case (MCI2_POWER_CANID):
                interfaces.front_right_inv.recieve_MCI_POWER(recvd_msg);
                break;

            case (MCI2_FEEDBACK_CANID):
                interfaces.front_right_inv.recieve_MCI_FEEDBACK(recvd_msg);

            // RL Inverter
            case (MCI3_STATUS_CANID):
                interfaces.back_left_inv.recieve_MCI_STATUS(recvd_msg);
                break;

            case (MCI3_TEMPS_CANID):
                interfaces.back_left_inv.recieve_MCI_TEMPS(recvd_msg);
                break;

            case (MCI3_DYNAMICS_CANID):
                interfaces.back_left_inv.recieve_MCI_DYNAMICS(recvd_msg);
                break;

            case (MCI3_POWER_CANID):
                interfaces.back_left_inv.recieve_MCI_POWER(recvd_msg);
                break;

            case (MCI3_FEEDBACK_CANID):
                interfaces.back_left_inv.recieve_MCI_FEEDBACK(recvd_msg);

            // RR Inverter
            case (MCI4_STATUS_CANID):
                interfaces.back_right_inv.recieve_MCI_STATUS(recvd_msg);
                break;

            case (MCI4_TEMPS_CANID):
                interfaces.back_right_inv.recieve_MCI_TEMPS(recvd_msg);
                break;

            case (MCI4_DYNAMICS_CANID):
                interfaces.back_right_inv.recieve_MCI_DYNAMICS(recvd_msg);
                break;

            case (MCI4_POWER_CANID):
                interfaces.back_right_inv.recieve_MCI_POWER(recvd_msg);
                break;

            case (MCI4_FEEDBACK_CANID):
                interfaces.back_right_inv.recieve_MCI_FEEDBACK(recvd_msg);

        }

    }
}

/**
* Sending CAN messages
* (needs to be called in loop)
* */
template <typename bufferType>
void send_all_CAN_msgs(bufferType &tx_buffer, FlexCAN_T4_Base *can_interface)
{
    CAN_message_t msg;
    while (tx_buffer.available())
    {
        CAN_message_t msg;
        uint8_t buf[sizeof(CAN_message_t)];
        tx_buffer.pop_front(buf, sizeof(CAN_message_t));
        memmove(&msg, buf, sizeof(msg));
        can_interface->write(msg);
    }
}

#endif /* HYTECHCANINTERFACE */