FWT-146 Solve Dat One (SDO) Issue

include/core/io/CANOpenMacros.hpp

@@ -131,6 +131,36 @@
         .Data = (CO_DATA) CO_COBID_SDO_RESPONSE(),      \
     }
 
+/**
+ * This macro helps create an SDO configuration range of the object dictionary.
+ * This lives at the key 0x1280 with 4 sub indices.
+ */
+#define SDO_CONFIGURATION_1280(SERVER_NODE_ID)          \
+    {                                                   \
+        /* Communication Object SDO Server */           \
+        .Key  = CO_KEY(0x1280, 0x00, CO_OBJ_D___R_),    \
+        .Type = CO_TUNSIGNED32,                         \
+        .Data = (CO_DATA) 0x03,                         \
+    },                                                  \
+    {                                                   \
+        /* SDO Server Request COBID */                  \
+        .Key  = CO_KEY(0x1280, 0x01, CO_OBJ_D___R_),    \
+        .Type = CO_TUNSIGNED32,                         \
+        .Data = (CO_DATA) CO_COBID_SDO_REQUEST(),       \
+    },                                                  \
+    {                                                   \
+        /* SDO Server Response COBID */                 \
+        .Key  = CO_KEY(0x1280, 0x02, CO_OBJ_D___R_),    \
+        .Type = CO_TUNSIGNED32,                         \
+        .Data = (CO_DATA) CO_COBID_SDO_RESPONSE(),      \
+    },                                                  \
+    {                                                   \
+        /* Node-ID of the SDO server */                 \
+        .Key  = CO_KEY(0x1280, 0x03, CO_OBJ_D___R_),    \
+        .Type = CO_TUNSIGNED8,                          \
+        .Data = (CO_DATA) SERVER_NODE_ID,               \
+    }
+
 /**
  * This macro creates an RPDO settings object. This macro itself is abstract,
  * allowing it to be used with any RPDO number supported by CANOpen. To make

include/core/io/CANopen.hpp

@@ -22,13 +22,15 @@
 
 namespace core::io {
 
+typedef void (*csdo_callback_t)(CO_CSDO* csdo, uint32_t entry, uint32_t status, void* context);
+
 /**
  * Get an instance of the CAN driver that can be used with the CANopen
  * stack. This will populate a struct with function pointers that can
  * handle CAN operations.
  *
  * @param[in] can The CAN interface that will be used for the stack driver
- * @param[in] messageQueue Queue that will be read from for receiveing CAN messages
+ * @param[in] messageQueue Queue that will be read from for receiving CAN messages
  * @param[out] canDriver The CANopen stack driver to populate
  */
 void getCANopenCANDriver(CAN* can, types::FixedQueue<CANOPEN_QUEUE_SIZE, io::CANMessage>* messageQueue,
@@ -94,6 +96,59 @@ void initializeCANopenNode(CO_NODE* canNode, CANDevice* canDevice, CO_IF_DRV* ca
  */
 void processCANopenNode(CO_NODE* canNode);
 
+/**
+ * This function starts an asynchronous SDO download (write) request to transfer data
+ * to the specified object dictionary entry on the target CANopen node.
+ *
+ * @param node[in]             Reference to the CANopen node object
+ * @param data[in]             Pointer to the data buffer that holds the data to send
+ * @param size[in]             Size of the data to transfer in bytes
+ * @param entry[in]            Object dictionary entry (index + subindex) to write to
+ * @param transferCallback[in] Callback function for the transfer operation
+ * @param transferContext[in]  Context for the callback function
+ * @return CO_ERR[out]         Returns the result of scheduling the transfer operation
+ */
+CO_ERR SDOTransfer(CO_NODE& node, uint8_t* data, uint8_t size, uint32_t entry, csdo_callback_t transferCallback,
+                   void* transferContext);
+
+/**
+ * This function starts an asynchronous SDO upload (read) request to fetch data from
+ * the specified object dictionary entry on the target CANopen node
+ *
+ * @param node[in]            Reference to the CANopen node object
+ * @param data[in]            Pointer to the buffer where received data will be stored
+ * @param size[in]            Size of the buffer provided to receive data
+ * @param entry[in]           Object dictionary entry (index + subindex) to read from
+ * @param receiveCallback[in] Callback function for the receive operation
+ * @param receiveContext[in]  Context for the callback function
+ * @return CO_ERR[out]        Returns the result of scheduling the receive operation
+ */
+CO_ERR SDOReceive(CO_NODE& node, uint8_t* data, uint8_t size, uint32_t entry, csdo_callback_t receiveCallback,
+                  void* receiveContext);
+
+/**
+ * This function performs a blocking SDO download (write) request to transfer data to the
+ * specified object dictionary entry on the target CANopen node and waits for the response.
+ *
+ * @param node[in]        Reference to the CANopen node object
+ * @param data[in]        Pointer to the data buffer that holds the data to send
+ * @param size[in]        Size of the data to transfer in bytes
+ * @param entry[in]       Object dictionary entry (index + subindex) to write to
+ * @return CO_ERR[out]    Returns the result of the transfer operation
+ */
+uint32_t SDOTransferBlocking(CO_NODE& node, uint8_t* data, uint8_t size, uint32_t entry);
+
+/**
+ * This function performs a blocking SDO upload (read) request to fetch data from
+ * the specified object dictionary entry on the target CANopen node.
+ *
+ * @param node[in]        Reference to the CANopen node object
+ * @param data[in]        Pointer to the buffer where received data will be stored
+ * @param size[in]        Size of the buffer provided to receive data
+ * @param entry[in]       Object dictionary entry (index + subindex) to read from
+ * @return CO_ERR[out]    Returns the result of the receive operation
+ */
+uint32_t SDOReceiveBlocking(CO_NODE& node, uint8_t* data, uint8_t size, uint32_t entry);
 } // namespace core::io
 
 #endif

samples/canopen/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(canopen_rpdo)
 add_subdirectory(canopen_sample)
+add_subdirectory(canopen_sdo)
 add_subdirectory(canopen_tpdo)

samples/canopen/canopen_rpdo/main.cpp

@@ -9,8 +9,11 @@
 #include <core/io/UART.hpp>
 #include <core/io/types/CANMessage.hpp>
 #include <core/manager.hpp>
+#include <core/utils/log.hpp>
 #include <core/utils/time.hpp>
 #include <core/utils/types/FixedQueue.hpp>
+#include <cstdio>
+#include <cstring>
 
 #include <core/io/CANopen.hpp>
 
@@ -19,6 +22,7 @@
 namespace io   = core::io;
 namespace dev  = core::dev;
 namespace time = core::time;
+namespace log  = core::log;
 
 ///////////////////////////////////////////////////////////////////////////////
 // EVT-core CAN callback and CAN setup. This will include logic to set
@@ -41,25 +45,37 @@ io::UART* uart;
 // create a can interrupt handler
 void canInterrupt(io::CANMessage& message, void* priv) {
     auto* queue = (core::types::FixedQueue<CANOPEN_QUEUE_SIZE, io::CANMessage>*) priv;
+    char messageString[50];
 
+#ifdef EVT_CORE_LOG_ENABLE
     // print out raw received data
-    uart->printf("Got RAW message from %X of length %d with data: ", message.getId(), message.getDataLength());
+    snprintf(&messageString[0],
+             25,
+             "Got RAW message from %X of length %d with data: ",
+             message.getId(),
+             message.getDataLength());
+#endif
+
     uint8_t* data = message.getPayload();
+
     for (int i = 0; i < message.getDataLength(); i++) {
-        uart->printf("%X ", *data);
+        snprintf(&messageString[strlen(messageString)], 1, "%X ", *data);
         data++;
     }
-    uart->printf("\r\n");
 
-    if (queue != nullptr)
+    log::LOGGER.log(log::Logger::LogLevel::INFO, "\r\n\t%s\r\n", messageString);
+
+    if (queue != nullptr) {
         queue->append(message);
+    }
 }
 
 int main() {
     // Initialize system
     core::platform::init();
 
     uart = &io::getUART<io::Pin::UART_TX, io::Pin::UART_RX>(9600);
+
     // Initialize the timer
     dev::Timer& timer = dev::getTimer<dev::MCUTimer::Timer2>(100);
 

samples/canopen/canopen_sdo/CMakeLists.txt

@@ -0,0 +1,4 @@
+include(../../../cmake/evt-core_build.cmake)
+
+set( SAMPLE_SOURCES main.cpp SDOCanNode.cpp)
+make_exe(canopen_sdo "${SAMPLE_SOURCES}")

samples/canopen/canopen_sdo/SDOCanNode.cpp

@@ -0,0 +1,58 @@
+#include "SDOCanNode.hpp"
+#include <core/utils/log.hpp>
+#include <cstdio>
+
+namespace log = core::log;
+
+SDOCanNode::SDOCanNode(CO_NODE& canNode) : node(canNode), transferBuff(0) {}
+
+void SDOCanNode::transferData(io::csdo_callback_t callback, void* context) {
+    // Get the value to be transferred
+    transferBuff = static_cast<uint8_t*>(context);
+
+    /*
+     * Initiates an SDO transfer for the specified node using the provided
+     * transfer buffer array. Targets the object dictionary entry at index 0x2100,
+     * sub-index 0x02. Registers and executes the SDOTransferCallback function upon completion.
+     */
+    CO_ERR err = io::SDOTransfer(node, transferBuff, 2, CO_DEV(0x2100, 0x02), callback, transferBuff);
+
+    /* Check if the SDO transfer was successfully started. */
+    if (err == CO_ERR_NONE) {
+        /* Transfer is started successfully */
+        log::LOGGER.log(log::Logger::LogLevel::INFO, "SDOTransfer Sent Request");
+    } else {
+        /* Unable to start the SDO transfer */
+        log::LOGGER.log(log::Logger::LogLevel::ERROR, "SDOTransfer Request Error");
+    }
+}
+
+void SDOCanNode::receiveData(io::csdo_callback_t callback, void* context) {
+    /*
+     * Initiates an SDO receive operation for the specified node, reading data into
+     * the provided receive buffer array. Targets the object dictionary entry at
+     * index 0x2100, sub-index 0x01. Registers and executes the SDOReceiveCallback function upon completion.
+     */
+    CO_ERR err = io::SDOReceive(node, (uint8_t*) context, 1, CO_DEV(0x2100, 0x01), callback, context);
+
+    /* Check if the SDO receive operation was successfully started. */
+    if (err == CO_ERR_NONE) {
+        /* Receive is started successfully */
+        log::LOGGER.log(log::Logger::LogLevel::INFO, "SDOReceive Sent Request");
+    } else {
+        /* Unable to start the SDO transfer */
+        log::LOGGER.log(log::Logger::LogLevel::ERROR, "SDOReceive Request Error");
+    }
+}
+
+CO_OBJ_T* SDOCanNode::getObjectDictionary() {
+    return &objectDictionary[0];
+}
+
+uint8_t SDOCanNode::getNumElements() {
+    return OBJECT_DICTIONARY_SIZE;
+}
+
+uint8_t SDOCanNode::getNodeID() {
+    return NODE_ID;
+}

samples/canopen/canopen_sdo/SDOCanNode.hpp

@@ -0,0 +1,92 @@
+#include <co_core.h>
+#include <core/io/CANDevice.hpp>
+#include <core/io/CANOpenMacros.hpp>
+#include <core/io/CANopen.hpp>
+
+namespace io = core::io;
+
+/**
+ * Representation of the CAN node. Handles constructing the object
+ * dictionary and other baseline settings. The idea is that each "board"
+ * will have a specific object dictionary associated with it. The object
+ * dictionary itself will also need to have information on "data of interest".
+ * For example, a temperature management system may to expose water pump
+ * flow rate in the object dictionary.
+ */
+class SDOCanNode : public CANDevice {
+public:
+    SDOCanNode(CO_NODE& canNode);
+
+    /**
+     * Update Object Dictionary entry
+     *
+     * @param callback[in] Callback function for the transfer operation
+     * @param context[in] Context for the callback function
+     */
+    void transferData(io::csdo_callback_t callback, void* context);
+
+    /**
+     * Read Object Dictionary entry
+     *
+     * @param callback[in] Callback function for the receive operation
+     * @param context[in] Context for the callback function
+     */
+    void receiveData(io::csdo_callback_t callback, void* context);
+
+    /**
+     * Get a pointer to the start of the object dictionary
+     *
+     * @return Pointer to the start of the object dictionary
+     */
+    CO_OBJ_T* getObjectDictionary() override;
+
+    /**
+     * Get the number of elements in the object dictionary.
+     *
+     * @return The number of elements in the object dictionary
+     */
+    uint8_t getNumElements() override;
+
+    /**
+     * Get the device's node ID
+     *
+     * @return The node ID of the can device.
+     */
+    uint8_t getNodeID() override;
+
+    /**
+     * Get the device's node ID
+     *
+     * @return The node ID of the can device.
+     */
+    static constexpr uint8_t NODE_ID = 2;
+
+private:
+    /** Holds the data to be transferred */
+    uint8_t* transferBuff;
+
+    CO_NODE& node;
+
+    /**
+     * Have to know the size of the object dictionary for initialization
+     * process.
+     */
+    static constexpr uint8_t OBJECT_DICTIONARY_SIZE = 24;
+
+    /**
+     * The object dictionary itself. Will be populated by this object during
+     * construction.
+     *
+     * The plus one is for the special "end of dictionary" marker.
+     */
+    CO_OBJ_T objectDictionary[OBJECT_DICTIONARY_SIZE + 1] = {
+        MANDATORY_IDENTIFICATION_ENTRIES_1000_1014,
+        HEARTBEAT_PRODUCER_1017(2000),
+        IDENTITY_OBJECT_1018,
+        SDO_CONFIGURATION_1200,
+        SDO_CONFIGURATION_1280(1),
+
+        // End of dictionary marker
+        CO_OBJ_DICT_ENDMARK,
+    };
+};