WIP: inverter interface add in (ignore branch name)

lib/interfaces/README.md

@@ -22,7 +22,6 @@ below is the description of the control messages that will be configured within
 
 - Control Input Message (will be attempted to be sent every 5ms, monitored by the inverter to be expected at least every 20ms)
     - `int16_t speed_setpoint` 
-        - __NOTE: active only when in speed control mode__
         - AKA (`AMK_TargetVelocity`) / Special Signal index 6 / AKA 16-bit version of SERCOS parameter ID36 (unknown why this is 16 bit vs the 32 bit SERCOS parameter in manual)
         - the RPM setpoint for the inverter in units of RPM.
     - `int16_t positive_torque_limit` 
@@ -33,10 +32,6 @@ below is the description of the control messages that will be configured within
     - `int16_t negative_torque_limit`
         - AKA (`AMK_TorqueLimitNegativ`) / SERCOS parameter ID83 / Special Signal index 14
         - `positive_torque_limit` with a negative sign.
-    - `int16_t torque_setpoint` 
-        - __NOTE: active only when in torque control mode.__
-        - AKA SERCOS parameter ID80 / Special Signal index 17
-        - the torque setpoint for the inverter in units of percentage as described in the `positive_torque_limit` message member above
 
 - Control parameter message (will be sent intermitently, not monitored by the inverter to be expected at any regular period)
     - `uint16_t speed_control_kp`

lib/interfaces/include/HytechCANInterface.h

@@ -0,0 +1,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 */

lib/interfaces/include/InverterInterface.h

@@ -2,6 +2,12 @@
 #define INVERTERINTERFACE_H
 #include <stdint.h>
 
+#include "FlexCAN_T4.h"
+#include "MessageQueueDefine.h"
+
+#include <hytech.h>
+#include "DrivetrainSystem.h"
+
 namespace HTUnits
 {
     using celcius = float;
@@ -12,10 +18,41 @@ namespace HTUnits
     using volts = float;
 };
 
-// for the most part these are mirrors of the lower-level CAN struct data, except with already fully float-ized data
+/**
+ * Struct containing id info for this specific inverter interface
+ */
+struct InverterIds_s
+{
+    uint32_t mc_setpoint_commands_id; 
+    uint32_t mc_torque_command_id; 
+};
+
+/** 
+ * Drivetrain system accessible structs for 
+ * requesting change of state
+ */
+struct InverterSetpoints_s 
+{
+    int16_t speed_rpm_setpoint;
+    int16_t positive_torque_limit; 
+    int16_t negative_torque_limit;
+};
+
+struct InverterControlWord_s 
+{
+    bool inverter_enable : 1;
+    bool hv_enable : 1;
+    bool driver_enable : 1;
+    bool remove_error : 1;
+};
 
+/** 
+ * For the most part these are mirrors of the lower-level CAN struct data, 
+ * except with already fully float-ized data
+**/
 struct InverterStatus_s
 {
+    bool new_data : 1;
     bool system_ready : 1;
     bool error : 1;
     bool warning : 1;
@@ -30,26 +67,30 @@ struct InverterStatus_s
 
 struct InverterTemps_s
 {
+    bool new_data : 1;
     HTUnits::celcius motor_temp;
     HTUnits::celcius inverter_temp;
     HTUnits::celcius igbt_temp;
 };
 
 struct InverterPower_s
 {
+    bool new_data : 1;
     HTUnits::watts active_power;
     HTUnits::var reactive_power;
 };
 
 struct MotorMechanics_s
 {
+    bool new_data : 1;
     HTUnits::watts actual_power;
     HTUnits::torque_nm actual_torque;
     HTUnits::speed_rpm actual_speed;
 };
 
 struct InverterControlParams_s
 {
+    bool new_data : 1;
     uint16_t speed_control_kp;
     uint16_t speed_control_ki;
     uint16_t speed_control_kd;
@@ -64,13 +105,70 @@ struct InverterFeedbackData_s
     InverterControlParams_s control_params;
 };
 
-// struct InverterMotorControl_s
-// {
-
-// }
-
+/**
+ * Inverter interface
+ */
 class InverterInterface
 {
 
+    public: 
+
+        InverterInterface(
+            CANBufferType *msg_output_queue, 
+            uint32_t mc_setpoint_commands_id,
+            uint32_t mc_torque_command_id) : msg_queue_(msg_output_queue) 
+        { 
+            inverter_ids.mc_setpoint_commands_id = mc_setpoint_commands_id;
+            inverter_ids.mc_torque_command_id = mc_torque_command_id;
+        }
+
+        // TODO un-public these (they are public for testing)
+
+        /* Recieving callbacks */
+        void recieve_MCI_STATUS(CAN_message_t &can_msg);
+
+        void recieve_MCI_TEMPS(CAN_message_t &can_msg);
+
+        void recieve_MCI_DYNAMICS(CAN_message_t &can_msg);
+
+        void recieve_MCI_POWER(CAN_message_t &can_msg);
+
+        void recieve_MCI_FEEDBACK(CAN_message_t &can_msg);
+
+        /* Sending */
+        template <typename U>
+        void enqueue_new_CAN(U *structure, uint32_t (*pack_function)(U *, uint8_t *, uint8_t *, uint8_t *), uint32_t id);
+
+        void send_MC_SETPOINT_COMMAND();
+
+        void send_MC_CONTROL_WORD();
+
+        /* Inverter Functs */
+        void set_speed(float desired_rpm, float torque_limit_nm); 
+
+        void set_torque(float torque_nm); 
+
+        void set_idle();
+
+        void set_inverter_control_word(InverterControlWord_s control_word);
+
+        InverterStatus_s get_inverter_status();
+
+    private: 
+
+        InverterIds_s inverter_ids;
+        InverterSetpoints_s _inverter_setpoints;
+        InverterControlWord_s _inverter_control_word;
+        InverterFeedbackData_s _feedback_data;
+
+        /* Getters */
+        InverterStatus_s get_status(); 
+        InverterTemps_s get_temps();
+        InverterPower_s get_power();
+        MotorMechanics_s get_motor_mechanics();
+        InverterControlParams_s get_control_params();
+
+        CANBufferType *msg_queue_;
 };
-#endif // __INVERTERINTERFACE_H__
+#endif // __INVERTERINTERFACE_H__
+

lib/interfaces/include/MessageQueueDefine.h

@@ -0,0 +1,8 @@
+#ifndef MESAGE_QUEUE_DEFINE_H
+#define MESAGE_QUEUE_DEFINE_H
+
+#include "FlexCAN_T4.h"
+
+using CANBufferType = Circular_Buffer<uint8_t, (uint32_t)128, sizeof(CAN_message_t)>;
+
+#endif

lib/interfaces/library.json

@@ -0,0 +1,13 @@
+{
+    "name": "interfaces-lib",
+    "version": "1.0.0",
+    "license": "MIT",
+    "dependencies": {
+        "can_lib": "*",
+        "shared_data": "*",
+        "CASE_lib": "*",
+        "nanopb": "*"
+    },
+    "frameworks": "*",
+    "platforms": "*"
+  }