Mtc Nucleo board connection

src/propulsion/can/can_ids.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <stdint.h>
+
+#include <array>
+namespace hyped {
+
+namespace propulsion {
+
+// Types of CANopen messages, these are used for CAN ID's
+static constexpr uint32_t kNmtReceive     = 0x000;
+static constexpr uint32_t kEmgyTransmit   = 0x80;
+static constexpr uint32_t kPdo1Transmit   = 0x180;
+static constexpr uint32_t kPdo1Receive    = 0x200;
+static constexpr uint32_t kPdo2Transmit   = 0x280;
+static constexpr uint32_t kPdo2Receive    = 0x300;
+static constexpr uint32_t kPdo3Transmit   = 0x380;
+static constexpr uint32_t kPdo3Receive    = 0x400;
+static constexpr uint32_t kPdo4Transmit   = 0x480;
+static constexpr uint32_t kPdo4Receive    = 0x500;
+static constexpr uint32_t kSdoTransmit    = 0x580;
+static constexpr uint32_t kSdoReceive     = 0x600;
+static constexpr uint32_t kNmtTransmit    = 0x700;
+static constexpr uint32_t kNucleoTransmit = 0x900;  // currently lowest priority, might change
+
+static constexpr std::array<uint32_t, 14> kCanIds
+  = {kNmtReceive,  kEmgyTransmit, kPdo1Transmit, kPdo1Receive,   kPdo2Transmit,
+     kPdo2Receive, kPdo3Transmit, kPdo3Receive,  kPdo4Transmit,  kPdo4Receive,
+     kSdoTransmit, kSdoReceive,   kNmtTransmit,  kNucleoTransmit};
+
+}  // namespace propulsion
+}  // namespace hyped

src/propulsion/can/can_receiver.cpp

@@ -0,0 +1,40 @@
+#include "can_receiver.hpp"
+
+namespace hyped::propulsion {
+
+CanReceiver::CanReceiver(const uint8_t node_id, IController &controller)
+    : log_("CAN-TRANSCEIVER", utils::System::getSystem().config_.log_level_propulsion),
+      node_id_(node_id),
+      controller_(controller),
+      can_(utils::io::Can::getInstance())
+{
+  can_.start();
+}
+
+void CanReceiver::registerController()
+{
+  can_.registerProcessor(this);
+}
+
+void CanReceiver::processNewData(utils::io::can::Frame &message)
+{
+  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 CanReceiver::hasId(const uint32_t id, bool)
+{
+  for (uint32_t cobId : kCanIds) {
+    if (cobId + node_id_ == id) { return true; }
+  }
+  return false;
+}
+}  // namespace hyped::propulsion

src/propulsion/can/can_receiver.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "can_ids.hpp"
+#include "receiver_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>
+#include <utils/system.hpp>
+
+namespace hyped::propulsion {
+
+class CanReceiver : public utils::io::CanProccesor, public ICanReceiver {
+ public:
+  /**
+   * @brief Initialise the CanReceiver with the id and the controller as an
+   * attribute, to access it's attributes
+   */
+  CanReceiver(const uint8_t node_id, IController &controller);
+
+  /**
+   * @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(const uint32_t id, bool extended) override;
+
+ private:
+  utils::Logger log_;
+  uint8_t node_id_;
+  utils::io::Can &can_;
+  IController &controller_;
+
+  static constexpr uint64_t kTimeout = 70000;  // us
+};
+
+}  // namespace hyped::propulsion

src/propulsion/can/can_sender.cpp

@@ -1,65 +1,16 @@
 #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()
+    : log_("CAN-SENDER", utils::System::getSystem().config_.log_level_propulsion),
+      can_(utils::io::Can::getInstance())
 {
-  is_sending_ = false;
   can_.start();
 }
 
-bool CanSender::sendMessage(utils::io::can::Frame &message)
+bool CanSender::sendMessage(const 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_;
+  return can_.send(message);
 }
 }  // namespace hyped::propulsion

src/propulsion/can/can_sender.hpp

@@ -2,60 +2,19 @@
 
 #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>
+#include <utils/system.hpp>
 
 namespace hyped::propulsion {
-
-class CanSender : public utils::io::CanProccesor, public ISender {
+class CanSender : public ICanSender {
  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();
 
-  /**
-   * @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(const utils::io::can::Frame &message) override;
 
  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
+  utils::Logger log_;
 };
-
 }  // namespace hyped::propulsion

src/propulsion/can/fake_can_receiver.cpp

@@ -0,0 +1,30 @@
+#include "fake_can_receiver.hpp"
+
+namespace hyped::propulsion {
+FakeCanReceiver::FakeCanReceiver(uint8_t)
+    : log_("FAKE-CAN-SENDER", utils::System::getSystem().config_.log_level_propulsion),
+      is_sending_(false),
+      can_endpoint_(*this)
+{
+}
+
+void FakeCanReceiver::registerController()
+{
+}
+
+void FakeCanReceiver::processNewData(utils::io::can::Frame &)
+{
+  log_.info("processNewData");
+  is_sending_ = false;
+}
+
+bool FakeCanReceiver::hasId(const uint32_t, bool)
+{
+  return true;
+}
+
+bool FakeCanReceiver::getIsSending()
+{
+  return is_sending_;
+}
+}  // namespace hyped::propulsion

src/propulsion/can/fake_can_receiver.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "fake_can_endpoint.hpp"
+#include "receiver_interface.hpp"
+
+#include <atomic>
+#include <iostream>
+
+#include <utils/io/can.hpp>
+#include <utils/logger.hpp>
+#include <utils/system.hpp>
+
+namespace hyped::propulsion {
+
+class FakeCanReceiver : public utils::io::CanProccesor, public ICanReceiver {
+ public:
+  FakeCanReceiver(uint8_t id);
+
+  void registerController() override;
+
+  void processNewData(utils::io::can::Frame &message) override;
+
+  bool hasId(const uint32_t id, bool extended) override;
+
+  bool getIsSending();
+
+ private:
+  utils::Logger log_;
+  // Can& can_;
+  std::atomic<bool> is_sending_;
+  FakeCanEndpoint can_endpoint_;
+};
+
+}  // namespace hyped::propulsion

src/propulsion/can/fake_can_sender.cpp

@@ -1,14 +1,14 @@
 #include "fake_can_sender.hpp"
 
 namespace hyped::propulsion {
-FakeCanSender::FakeCanSender(utils::Logger &log_, uint8_t)
-    : log_(log_),
+FakeCanSender::FakeCanSender(uint8_t)
+    : log_("FAKE-CAN-SENDER", utils::System::getSystem().config_.log_level_propulsion),
       is_sending_(false),
       can_endpoint_(*this)
 {
 }
 
-bool FakeCanSender::sendMessage(utils::io::can::Frame &)
+bool FakeCanSender::sendMessage(const utils::io::can::Frame &)
 {
   log_.info("sending");
   is_sending_ = true;
@@ -19,21 +19,6 @@ bool FakeCanSender::sendMessage(utils::io::can::Frame &)
   return true;
 }
 
-void FakeCanSender::registerController()
-{
-}
-
-void FakeCanSender::processNewData(utils::io::can::Frame &)
-{
-  log_.info("processNewData");
-  is_sending_ = false;
-}
-
-bool FakeCanSender::hasId(uint32_t, bool)
-{
-  return true;
-}
-
 bool FakeCanSender::getIsSending()
 {
   return is_sending_;

src/propulsion/can/fake_can_sender.hpp

@@ -8,22 +8,17 @@
 
 #include <utils/io/can.hpp>
 #include <utils/logger.hpp>
+#include <utils/system.hpp>
 
 namespace hyped::propulsion {
 
-class FakeCanSender : public utils::io::CanProccesor, public ISender {
+class FakeCanSender : public utils::io::CanProccesor, public ICanSender {
  public:
-  FakeCanSender(utils::Logger &log_, uint8_t id);
+  FakeCanSender(uint8_t id);
 
-  bool sendMessage(utils::io::can::Frame &message) override;
+  bool sendMessage(const utils::io::can::Frame &message) override;
 
-  void registerController() override;
-
-  void processNewData(utils::io::can::Frame &message) override;
-
-  bool hasId(uint32_t id, bool extended) override;
-
-  bool getIsSending() override;
+  bool getIsSending();
 
  private:
   utils::Logger log_;