partial formatting pass

Author: samuelsadok

src/ODriveCAN.h

@@ -38,167 +38,167 @@ class ODriveCAN {
 
     /**
      * @brief Clear all errors on the ODrive.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool clearErrors();
-    
+
     /**
      * @brief Tells the ODrive to change its axis state.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setState(ODriveAxisState requested_state);
-    
+
     /**
      * @brief Sets the control mode and input mode of the ODrive.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setControllerMode(uint8_t control_mode, uint8_t input_mode);
-    
+
     /**
      * @brief Sends a position setpoint with optional velocity and torque feedforward.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setPosition(float position, float velocity_feedforward = 0.0f, float torque_feedforward = 0.0f);
 
     /**
      * @brief Sends a velocity setpoint with optional torque feedforward.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setVelocity(float velocity, float torque_feedforward = 0.0f);
 
     /**
      * @brief Sends a torque setpoint to the ODrive.
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setTorque(float torque);
 
     /**
      * @brief Sets the velocity and current limits
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setLimits(float velocity_limit, float current_soft_max);
 
     /**
      * @brief Sets the position gain
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setPosGain(float pos_gain);
-    
+
     /**
      * @brief Sets the velocity and velocity integrator gains
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setVelGains(float vel_gain, float vel_integrator_gain);
-    
+
     /**
      * @brief Sets the encoder's absolute position and enables absolute positioning
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setAbsolutePosition(float abs_pos);
-    
+
     /**
      * @brief Sets the coast velocity for subsequent trapezoidal moves
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setTrapezoidalVelLimit(float vel_limit);
-    
+
     /**
      * @brief Sets the acceleration and deceleration values for subsequent trapezoidal moves
-     * 
+     *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
     bool setTrapezoidalAccelLimits(float accel_limit, float decel_limit);
 
     /**
      * @brief Requests motor current.  Iq_measured represents torque-generating current
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getCurrents(Get_Iq_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
-     * @brief Requests motor temperature 
-     * 
+     * @brief Requests motor temperature
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getTemperature(Get_Temperature_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
      * @brief Requests error information
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getError(Get_Error_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
      * @brief Requests hardware and firmware version information
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getVersion(Get_Version_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
      * @brief Requests encoder feedback data.
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getFeedback(Get_Encoder_Estimates_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
      * @brief Requests ODrive DC bus voltage and current
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      * May trigger onBusVI callback if it's registered.
      */
     bool getBusVI(Get_Bus_Voltage_Current_msg_t& msg, uint16_t timeout_ms = 10);
 
     /**
      * @brief Requests mechanical and electrical power data (used for spinout detection)
-     * 
+     *
      * This function will block and wait for up to timeout_ms (default 10msec) for ODrive to reply
      */
     bool getPower(Get_Powers_msg_t& msg, uint16_t timeout_ms = 10);
-    
+
     enum ResetAction {
         Reboot,
         SaveConfiguration,
-        EraseConfiguration
+        EraseConfiguration,
     };
-    
+
     /**
      * @brief Resets the ODrive with the given action
-     * 
+     *
      * Valid actions:
      *   - Reboot (0)
      *   - Save (1)
      *   - Erase (2)
      *
      */
     bool reset(ResetAction action = ResetAction::Reboot);
-    
+
     /**
      * @brief Registers a callback for ODrive feedback processing.
      */
@@ -211,15 +211,15 @@ class ODriveCAN {
      * @brief Registers a callback for ODrive axis state feedback.
      */
     void onStatus(void (*callback)(Heartbeat_msg_t& feedback, void* user_data), void* user_data = nullptr) {
-        axis_state_callback_ = callback; 
+        axis_state_callback_ = callback;
         axis_state_user_data_ = user_data;
     }
-    
+
     /**
      * @brief Registers a callback for ODrive torques feedback processing.
      */
     void onTorques(void (*callback)(Get_Torques_msg_t& feedback, void* user_data), void* user_data = nullptr) {
-        torques_callback_ = callback; 
+        torques_callback_ = callback;
         torques_user_data_ = user_data;
     }
 
@@ -262,7 +262,7 @@ class ODriveCAN {
 
     /**
      * @brief Sends a request message and awaits a response.
-     * 
+     *
      * Blocks until the response is received or the timeout is reached. Returns
      * false if the ODrive does not respond within the specified timeout.
      */
@@ -274,7 +274,9 @@ class ODriveCAN {
             0, // no data
             nullptr // RTR=1
         );
-        if (!awaitMsg(timeout_ms)) return false;
+        if (!awaitMsg(timeout_ms)) {
+            return false;
+        }
         msg.decode_buf(buffer_);
         return true;
     }
@@ -295,17 +297,17 @@ class ODriveCAN {
 
     /**
      * @brief Get value at the endpoint
-     * 
+     *
      * @tparam T The data type expected from the endpoint
      * @param endpoint_id Unique ID from flat_endpoints.json
      * @param timeout_ms Time to wait for a response from ODrive
-     * 
+     *
      * @return T Data from the endpoint, or 0 on timeout
      *
      * Blocks until the response is received or the timeout is reached.
      *
      */
-    template <typename T>
+    template<typename T>
     T getEndpoint(uint16_t endpoint_id, uint16_t timeout_ms = 10) {
         uint8_t data[8] = {};
         data[0] = 0; // Opcode read
@@ -316,7 +318,9 @@ class ODriveCAN {
 
         requested_msg_id_ = 0x005; // Await TxSdo message
         can_intf_.sendMsg((node_id_ << ODriveCAN::kNodeIdShift) | 0x004, 8, data);
-        if (!awaitMsg(timeout_ms)) return T{};
+        if (!awaitMsg(timeout_ms)) {
+            return T{};
+        }
 
         T ret{};
         memcpy(&ret, &buffer_[4], sizeof(T));
@@ -325,15 +329,15 @@ class ODriveCAN {
 
     /**
      * @brief Set endpoint to value
-     * 
+     *
      * @tparam T Type of the value from flat_endpoints.json
      * @param endpoint_id Unique ID of endpoint from flat_endpoints.json
      * @param value value to write to the endpoint
      *
      * This function returns immediately and does not check if the ODrive
      * received the CAN message.
      */
-    template <typename T>
+    template<typename T>
     bool setEndpoint(uint16_t endpoint_id, T value) {
         uint8_t data[8] = {};
         data[0] = 1; // Opcode write
@@ -371,7 +375,7 @@ class ODriveCAN {
     void* busVI_user_data_;
     void* currents_user_data_;
     void* error_user_data_;
-    
+
     void (*axis_state_callback_)(Heartbeat_msg_t& feedback, void* user_data) = nullptr;
     void (*feedback_callback_)(Get_Encoder_Estimates_msg_t& feedback, void* user_data) = nullptr;
     void (*torques_callback_)(Get_Torques_msg_t& feedback, void* user_data) = nullptr;

src/ODriveFlexCAN.hpp

@@ -3,8 +3,8 @@
 
 #pragma once
 
-#include "ODriveCAN.h"
 #include "FlexCAN_T4.h"
+#include "ODriveCAN.h"
 
 using CanMsg = CAN_message_t;
 
@@ -14,7 +14,7 @@ static bool sendMsg(FlexCAN_T4_Base& can_intf, uint32_t id, uint8_t length, cons
         .flags = {.extended = (bool)(id & 0x80000000), .remote = !data},
         .len = length,
     };
-    
+
     if (data) {
         memcpy(teensy_msg.buf, data, length);
     }

src/ODriveHardwareCAN.hpp

@@ -3,14 +3,15 @@
 #pragma once
 
 #include "ODriveCAN.h"
+
 #include <api/HardwareCAN.h>
 
 // Must be defined by the application
 void onCanMessage(const CanMsg& msg);
 
 /**
  * @brief Sends a CAN message over the specified platform-specific interface.
- * 
+ *
  * @param can_intf A platform-specific reference to the CAN interface to use.
  * @param id: The CAN message ID to send.
  *        Bit 31 indicates if the ID is extended (29-bit) or standard (11-bit).
@@ -36,7 +37,7 @@ static bool sendMsg(HardwareCAN& can_intf, uint32_t id, uint8_t length, const ui
 /**
  * @brief Receives a CAN message from the platform-specific interface and passes
  * it to the ODriveCAN instance.
- * 
+ *
  * @param msg: The received CAN message in a platform-specific format.
  * @param odrive: The ODriveCAN instance to pass the message to.
  */
@@ -47,10 +48,10 @@ static void onReceive(const CanMsg& msg, ODriveCAN& odrive) {
 /**
  * @brief Processes the CAN interface's RX buffer and calls onCanMessage for
  * each pending message.
- * 
+ *
  * On hardware interfaces where onCanMessage() is already called from the
  * interrupt handler, this function is a no-op.
- * 
+ *
  * @param intf: The platform-specific CAN interface to process.
  * @param max_events: The maximum number of events to process. This prevents
  *        an infinite loop if messages come at a high rate.

src/ODriveSTM32CAN.hpp

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "ODriveCAN.h"
+
 #include <STM32_CAN.h>
 
 using CanMsg = CAN_message_t;
@@ -12,17 +13,17 @@ using CanMsg = CAN_message_t;
 void onCanMessage(const CanMsg& msg);
 
 static bool sendMsg(STM32_CAN& can_intf, uint32_t id, uint8_t length, const uint8_t* data) {
-  CanMsg msg;
-  msg.id = id & 0x1ffffff;
-  msg.flags.extended = id & 0x80000000;
-  msg.flags.remote = (data == nullptr);
-  msg.len = length;
-  if (data) {
-    for (int i = 0; i < length; ++i) {
-      msg.buf[i] = data[i];
+    CanMsg msg;
+    msg.id = id & 0x1ffffff;
+    msg.flags.extended = id & 0x80000000;
+    msg.flags.remote = (data == nullptr);
+    msg.len = length;
+    if (data) {
+        for (int i = 0; i < length; ++i) {
+            msg.buf[i] = data[i];
+        }
     }
-  }
-  return can_intf.write(msg) >= 0;
+    return can_intf.write(msg) >= 0;
 }
 
 static void onReceive(const CanMsg& msg, ODriveCAN& odrive) {