Mtc Nucleo board connection

src/propulsion/can/can_sender.cpp

@@ -1,65 +1,15 @@
 #include "can_sender.hpp"
 
-#include <utils/timer.hpp>
-
 namespace hyped::propulsion {
-
-CanSender::CanSender(utils::Logger &log, const uint8_t node_id, IController &controller)
-    : log_(log),
-      node_id_(node_id),
-      can_(utils::io::Can::getInstance()),
-      controller_(controller)
+CanSender::CanSender(utils::Logger &log, utils::io::Can &can) : log_(log), can_(can)
 {
-  is_sending_ = false;
   can_.start();
 }
 
 bool CanSender::sendMessage(utils::io::can::Frame &message)
 {
   log_.info("Sending Message");
-  can_.send(message);
-  is_sending_    = true;
-  const auto now = utils::Timer::getTimeMicros();
-  while (is_sending_) {
-    if ((utils::Timer::getTimeMicros() - now) > kTimeout) {
-      // TODO(Iain): Test the latency and set the TIMEOUT to a reasonable value.
-      log_.error("Sender timeout reached");
-      return false;
-    }
-  }
-  return true;
-}
-
-void CanSender::registerController()
-{
-  can_.registerProcessor(this);
-}
-
-void CanSender::processNewData(utils::io::can::Frame &message)
-{
-  is_sending_ = false;
-  uint32_t id = message.id;
-  if (id == kEmgyTransmit + node_id_) {
-    controller_.processEmergencyMessage(message);
-  } else if (id == kSdoTransmit + node_id_) {
-    controller_.processSdoMessage(message);
-  } else if (id == kNmtTransmit + node_id_) {
-    controller_.processNmtMessage(message);
-  } else {
-    log_.error("Controller %d: CAN message not recognised", node_id_);
-  }
-}
-
-bool CanSender::hasId(uint32_t id, bool)
-{
-  for (uint32_t cobId : canIds) {
-    if (cobId + node_id_ == id) { return true; }
-  }
-  return false;
-}
-
-bool CanSender::getIsSending()
-{
-  return is_sending_;
+  bool sendSuccessful = can_.send(message);
+  return sendSuccessful;
 }
 }  // namespace hyped::propulsion

src/propulsion/can/can_sender.hpp

@@ -2,60 +2,18 @@
 
 #include "sender_interface.hpp"
 
-#include <atomic>
-#include <iostream>
-
-#include <propulsion/controller_interface.hpp>
-#include <utils/concurrent/thread.hpp>
 #include <utils/io/can.hpp>
 #include <utils/logger.hpp>
 
 namespace hyped::propulsion {
-
-class CanSender : public utils::io::CanProccesor, public ISender {
+class CanSender {
  public:
-  /**
-   * @brief Initialise the CanSender with the logger, the id and the controller as an attribute,
-   * to access it's attributes
-   */
-  CanSender(utils::Logger &log, const uint8_t node_id, IController &controller);
-
-  /**
-   * @brief Sends CAN messages
-   */
-  bool sendMessage(utils::io::can::Frame &message) override;
-
-  /**
-   * @brief Registers the controller to process incoming CAN messages
-   */
-  void registerController() override;
+  CanSender(utils::Logger &log, utils::io::Can &can);
 
-  /**
-   * @brief This function processes incoming CAN messages
-   */
-  void processNewData(utils::io::can::Frame &message) override;
-
-  /**
-   * @brief If this function returns true, the CAN message is ment for this CAN node
-   */
-  bool hasId(uint32_t id, bool extended) override;
-
-  /**
-   * @brief Return if the can_sender is sending a CAN message right now
-   */
-  bool getIsSending() override;
+  bool sendMessage(utils::io::can::Frame &message);
 
  private:
   utils::Logger &log_;
-  uint8_t node_id_;
   utils::io::Can &can_;
-  std::atomic<bool> is_sending_;
-  IController &controller_;
-
-  static constexpr uint32_t kEmgyTransmit = 0x80;
-  static constexpr uint32_t kSdoTransmit  = 0x580;
-  static constexpr uint32_t kNmtTransmit  = 0x700;
-  static constexpr uint64_t kTimeout      = 70000;  // us
 };
-
 }  // namespace hyped::propulsion

src/propulsion/can/can_transceiver.cpp

@@ -0,0 +1,56 @@
+#include "can_transceiver.hpp"
+
+namespace hyped::propulsion {
+
+CanTransceiver::CanTransceiver(utils::Logger &log, const uint8_t node_id, IController &controller)
+    : log_(log),
+      node_id_(node_id),
+      can_(utils::io::Can::getInstance()),
+      sender_(log_, can_),
+      controller_(controller)
+{
+  is_sending_ = false;
+  can_.start();
+}
+
+bool CanTransceiver::sendMessage(utils::io::can::Frame &message)
+{
+  log_.info("Sending Message");
+  bool messageSuccess = sender_.sendMessage(message);
+  is_sending_         = true;
+  return messageSuccess;
+}
+
+void CanTransceiver::registerController()
+{
+  can_.registerProcessor(this);
+}
+
+void CanTransceiver::processNewData(utils::io::can::Frame &message)
+{
+  is_sending_ = false;
+  uint32_t id = message.id;
+  if (id == kEmgyTransmit + node_id_) {
+    controller_.processEmergencyMessage(message);
+  } else if (id == kSdoTransmit + node_id_) {
+    controller_.processSdoMessage(message);
+  } else if (id == kNmtTransmit + node_id_) {
+    controller_.processNmtMessage(message);
+  } else {
+    log_.error("Controller %d: CAN message not recognised", node_id_);
+  }
+}
+
+bool CanTransceiver::hasId(uint32_t id, bool)
+{
+  for (uint32_t cobId : canIds) {
+    if (cobId + node_id_ == id) { return true; }
+  }
+  return false;
+}
+
+bool CanTransceiver::getIsSending()
+{
+  return is_sending_;
+}
+}  // namespace hyped::propulsion

src/propulsion/can/can_transceiver.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "can_sender.hpp"
+#include "sender_interface.hpp"
+
+#include <atomic>
+#include <iostream>
+
+#include <propulsion/controller_interface.hpp>
+#include <utils/concurrent/thread.hpp>
+#include <utils/io/can.hpp>
+#include <utils/logger.hpp>
+
+namespace hyped::propulsion {
+
+class CanTransceiver : public utils::io::CanProccesor, public ISender {
+ public:
+  /**
+   * @brief Initialise the CanTransceiver with the logger, the id and the controller as an
+   * attribute, to access it's attributes
+   */
+  CanTransceiver(utils::Logger &log, const uint8_t node_id, IController &controller);
+
+  /**
+   * @brief Sends CAN messages
+   */
+  bool sendMessage(utils::io::can::Frame &message) override;
+
+  /**
+   * @brief Registers the controller to process incoming CAN messages
+   */
+  void registerController() override;
+
+  /**
+   * @brief This function processes incoming CAN messages
+   */
+  void processNewData(utils::io::can::Frame &message) override;
+
+  /**
+   * @brief If this function returns true, the CAN message is ment for this CAN node
+   */
+  bool hasId(uint32_t id, bool extended) override;
+
+  /**
+   * @brief Return if the can_sender is sending a CAN message right now
+   */
+  bool getIsSending() override;
+
+ private:
+  utils::Logger &log_;
+  uint8_t node_id_;
+  utils::io::Can &can_;
+  std::atomic<bool> is_sending_;
+  IController &controller_;
+  CanSender sender_;
+
+  static constexpr uint32_t kEmgyTransmit = 0x80;
+  static constexpr uint32_t kSdoTransmit  = 0x580;
+  static constexpr uint32_t kNmtTransmit  = 0x700;
+  static constexpr uint64_t kTimeout      = 70000;  // us
+};
+
+}  // namespace hyped::propulsion

src/propulsion/can/sender_interface.hpp

@@ -7,22 +7,23 @@ namespace hyped {
 namespace propulsion {
 
 // Types of CANopen messages, these are used for CAN ID's
-constexpr uint32_t kEmgyTransmit = 0x80;
-constexpr uint32_t kSdoReceive   = 0x600;
-constexpr uint32_t kSdoTransmit  = 0x580;
-constexpr uint32_t kNmtReceive   = 0x000;
-constexpr uint32_t kNmtTransmit  = 0x700;
-constexpr uint32_t kPdo1Transmit = 0x180;
-constexpr uint32_t kPdo1Receive  = 0x200;
-constexpr uint32_t kPdo2Transmit = 0x280;
-constexpr uint32_t kPdo2Receive  = 0x300;
-constexpr uint32_t kPdo3Transmit = 0x380;
-constexpr uint32_t kPdo3Receive  = 0x400;
-constexpr uint32_t kPdo4Transmit = 0x480;
-constexpr uint32_t kPdo4Receive  = 0x500;
-
-constexpr uint32_t canIds[13]{0x80,  0x600, 0x580, 0x000, 0x700, 0x180, 0x200,
-                              0x280, 0x300, 0x380, 0x400, 0x480, 0x500};
+constexpr uint32_t kEmgyTransmit   = 0x80;
+constexpr uint32_t kSdoReceive     = 0x600;
+constexpr uint32_t kSdoTransmit    = 0x580;
+constexpr uint32_t kNmtReceive     = 0x000;
+constexpr uint32_t kNmtTransmit    = 0x700;
+constexpr uint32_t kPdo1Transmit   = 0x180;
+constexpr uint32_t kPdo1Receive    = 0x200;
+constexpr uint32_t kPdo2Transmit   = 0x280;
+constexpr uint32_t kPdo2Receive    = 0x300;
+constexpr uint32_t kPdo3Transmit   = 0x380;
+constexpr uint32_t kPdo3Receive    = 0x400;
+constexpr uint32_t kPdo4Transmit   = 0x480;
+constexpr uint32_t kPdo4Receive    = 0x500;
+constexpr uint32_t kNucleoTransmit = 0x900;  // currently lowest priority, might change
+
+constexpr uint32_t canIds[14]{0x80,  0x600, 0x580, 0x000, 0x700, 0x180, 0x200,
+                              0x280, 0x300, 0x380, 0x400, 0x480, 0x500, 0x900};
 
 class ISender {
  public:

src/propulsion/controller.cpp

@@ -13,7 +13,7 @@ Controller::Controller(utils::Logger &log, uint8_t id)
       actual_torque_(0),
       motor_temperature_(0),
       controller_temperature_(0),
-      sender_(log, node_id_, *this)
+      transceiver_(log, node_id_, *this)
 {
   sdo_message_.id       = kSdoReceive + node_id_;
   sdo_message_.extended = false;
@@ -33,7 +33,7 @@ bool Controller::sendControllerMessage(const ControllerMessage message_template)
 
 void Controller::registerController()
 {
-  sender_.registerController();
+  transceiver_.registerController();
 }
 
 void Controller::configure()
@@ -54,7 +54,7 @@ void Controller::enterOperational()
   nmt_message_.data[1] = node_id_;
 
   log_.info("Controller %d: Sending NMT Operational command", node_id_);
-  sender_.sendMessage(nmt_message_);
+  transceiver_.sendMessage(nmt_message_);
   // leave time for the controller to enter NMT Operational
   utils::concurrent::Thread::sleep(100);
 
@@ -105,7 +105,7 @@ void Controller::sendTargetVelocity(const int32_t target_velocity)
   sdo_message_.data[6] = (target_velocity >> 16) & 0xFF;
   sdo_message_.data[7] = (target_velocity >> 24) & 0xFF;
 
-  sender_.sendMessage(sdo_message_);
+  transceiver_.sendMessage(sdo_message_);
 }
 
 void Controller::sendTargetTorque(const int16_t target_torque)
@@ -161,7 +161,7 @@ void Controller::updateControllerTemp()
 
 void Controller::sendSdoMessage(utils::io::can::Frame &message)
 {
-  if (!sender_.sendMessage(message)) {
+  if (!transceiver_.sendMessage(message)) {
     log_.error("Controller %d: No response from controller", node_id_);
     throwCriticalFailure();
   }
@@ -181,7 +181,7 @@ void Controller::requestStateTransition(utils::io::can::Frame &message, Controll
   // Wait for max of 3 seconds, checking if the state has changed every second
   // If it hasn't changed by the end then throw critical failure.
   for (state_count = 0; state_count < 3; state_count++) {
-    sender_.sendMessage(message);
+    transceiver_.sendMessage(message);
     utils::concurrent::Thread::sleep(1000);
     checkState();
     if (state_ == state) { return; }

src/propulsion/controller.hpp

@@ -6,7 +6,7 @@
 #include <atomic>
 
 #include <data/data.hpp>
-#include <propulsion/can/can_sender.hpp>
+#include <propulsion/can/can_transceiver.hpp>
 #include <utils/io/can.hpp>
 #include <utils/logger.hpp>
 #include <utils/system.hpp>
@@ -49,6 +49,7 @@ class Controller : public IController {
    * @param target_velocity - in rpm (calculated in speed calculator)
    */
   void sendTargetVelocity(int32_t target_velocity) override;
+
   /**
    * @brief Send the target torque to the motor controller.
    *
@@ -174,7 +175,7 @@ class Controller : public IController {
   std::atomic<int16_t> actual_torque_;
   std::atomic<uint8_t> motor_temperature_;
   std::atomic<uint8_t> controller_temperature_;
-  CanSender sender_;
+  CanTransceiver transceiver_;
   utils::io::can::Frame sdo_message_;
   utils::io::can::Frame nmt_message_;
 

src/propulsion/nucleo_manager.cpp

@@ -0,0 +1,23 @@
+#include "nucleo_manager.hpp"
+
+namespace hyped::propulsion {
+
+NucleoManager::NucleoManager(utils::Logger &log)
+    : log_(log),
+      sender_(log, utils::io::Can::getInstance())
+{
+  nucleo_message_.id       = kNucleoTransmit;
+  nucleo_message_.extended = false;
+  nucleo_message_.len      = 4;
+}
+
+void NucleoManager::sendNucleoFrequency(const uint32_t target_frequency)
+{
+  log_.info("Nucleo board: Setting frequency to &d", target_frequency);
+  nucleo_message_.data[1] = target_frequency & 0xFF;
+  nucleo_message_.data[2] = (target_frequency >> 8) & 0xFF;
+  nucleo_message_.data[3] = (target_frequency >> 16) & 0xFF;
+  nucleo_message_.data[4] = (target_frequency >> 24) & 0xFF;
+  sender_.sendMessage(nucleo_message_);
+}
+}  // namespace hyped::propulsion