RapidCode NetworkNode

Table of Contents

• 📜 Sample Code

The NetworkNode object represents an EtherCAT Node (SubDevice) (Drive, IO Block, etc) on the network. Accessible via MotionController and Axis objects.

Represents an EtherCAT node / SubDevice (Drive, I/O Block, etc) on the network. This class provides an interface to all digital and analog I/O on the node, as well as the ability to read and write SDOs. Get or create a NetworkNode using MotionController::NetworkNodeGet or the Axis property, NetworkNode.

Each RapidCodeNetworkNode represents a physical node (SubDevice) on the EtherCAT bus.

Multiple Axis objects can reference the same network node as seen by the Copley Multi-Axis node.

📜 Sample Code

The following sample apps shows how to print your network topology, including information about each network node.

• C++

   
  #include <iomanip>
  #include <iostream>
  #include <map>
  #include <sstream>
  #include <vector>
   
  #include "SampleAppsHelper.h" // Import our helper functions.
  #include "rsi.h"              // Import our RapidCode Library.
   
  using namespace RSI::RapidCode; // Import the RapidCode namespace
   
  // Map of the RSINetworkType enum to string
  static const std::map<RSINetworkType, std::string> RSINetworkTypeMap = {
      {RSINetworkType::RSINetworkTypeSTRING, "RSINetworkTypeSTRING"},
      {RSINetworkType::RSINetworkTypeDUAL_STRING, "RSINetworkTypeDUAL_STRING"},
      {RSINetworkType::RSINetworkTypeRING, "RSINetworkTypeRING"}
  };
   
  // Map of the RSINetworkState enum to string
  static const std::map<RSINetworkState, std::string> RSINetworkStateMap = {
      {RSINetworkState::RSINetworkStateUNINITIALIZED, "RSINetworkStateUNINITIALIZED"},
      {RSINetworkState::RSINetworkStateDISCOVERING, "RSINetworkStateDISCOVERING"},
      {RSINetworkState::RSINetworkStateDISCOVERED, "RSINetworkStateDISCOVERED"},
      {RSINetworkState::RSINetworkStatePREOPERATIONAL, "RSINetworkStatePREOPERATIONAL"},
      {RSINetworkState::RSINetworkStateOPERATIONAL, "RSINetworkStateOPERATIONAL"},
      {RSINetworkState::RSINetworkStateERROR, "RSINetworkStateERROR"},
      {RSINetworkState::RSINetworkStateSHUTDOWN, "RSINetworkStateSHUTDOWN"},
      {RSINetworkState::RSINetworkStateSTARTING, "RSINetworkStateSTARTING"}
  };
   
  // Constants for reading the device type from the Mdp
  struct MdpConstants
  {
    static constexpr int DEVICE_TYPE_INDEX = 0x1000;
    static constexpr int DEVICE_TYPE_SUB_INDEX = 0;
    static constexpr int DEVICE_TYPE_BYTE_SIZE = 4;
  };
   
  // Helper function to get the list of network nodes from the controller
  static std::vector<RapidCodeNetworkNode *> GetNodeList(MotionController *controller)
  {
    std::vector<RapidCodeNetworkNode *> nodes;
    for (int i = 0; i < controller->NetworkNodeCountGet(); ++i)
    {
      RapidCodeNetworkNode *node = controller->NetworkNodeGet(i);
   
      if (node == nullptr)
      {
        throw std::runtime_error("Error creating the network node, it is null.");
      }
   
      if (!node->Exists())
      {
        throw std::runtime_error("The network node should exist after we get it.");
      }
   
      nodes.push_back(node);
    }
    return nodes;
  }
   
  // Helper function to get the device type of a node from the Mdp
  static std::string GetDeviceType(RapidCodeNetworkNode *node)
  {
    std::string deviceType = "";
    try
    {
      uint32_t deviceTypeValue =
          node->ServiceChannelRead(MdpConstants::DEVICE_TYPE_INDEX, MdpConstants::DEVICE_TYPE_SUB_INDEX, MdpConstants::DEVICE_TYPE_BYTE_SIZE);
   
      std::ostringstream deviceTypeStream;
      deviceTypeStream << "0x" << std::uppercase << std::setfill('0') << std::setw(8) << std::hex << deviceTypeValue;
   
      deviceType = deviceTypeStream.str();
    }
    catch (std::exception err)
    {
      deviceType = "Exception trying to read device type";
    }
    return deviceType;
  }
   
  // Helper function to read the information of a node into a string
  static std::string ReadNodeInfo(RapidCodeNetworkNode *node)
  {
    std::ostringstream nodeInfo;
   
    nodeInfo << "\n"; // for spacing
    nodeInfo << "Node[" << node->NumberGet() << "] - " << node->NameGet() << " ______________________________________________\n";
   
    nodeInfo << " Vendor: " << node->VendorNameGet();
    nodeInfo << " Product: " << node->ProductNameGet() << "\n";
   
    nodeInfo << "  VendorID:      0x" << std::hex << std::setw(8) << std::setfill('0') << node->VendorIdGet();
    nodeInfo << " ProductCode:   0x" << std::setw(8) << node->ProductCodeGet() << "\n";
   
    nodeInfo << "  HardwareRev:   0x" << std::setw(8) << node->RevisionGet();
    nodeInfo << " SerialNumber:  " << node->SerialNumberGet() << "\n";
   
    nodeInfo << "  StationAlias:  0x" << std::setw(8) << node->StationAliasGet();
    nodeInfo << " AxisCount:     " << std::dec << node->AxisCountGet() << "\n";
   
    nodeInfo << "  DeviceType:    " << GetDeviceType(node);
    nodeInfo << " (For Mdp by reading SDO 0x" << std::hex << std::setw(4) << MdpConstants::DEVICE_TYPE_INDEX << ")\n";
   
    nodeInfo << "  SegmentCount:  " << node->SegmentCountGet() << "\n";
   
    nodeInfo << "  DI: " << node->DigitalInCountGet();
    nodeInfo << " DO: " << node->DigitalOutCountGet();
    nodeInfo << " AI: " << node->AnalogInCountGet();
    nodeInfo << " AO: " << node->AnalogOutCountGet() << "\n";
   
    return nodeInfo.str();
  }
   
  int main()
  {
    const std::string SAMPLE_APP_NAME = "Utilities: Print Network Topology";
   
    // Print a start message to indicate that the sample app has started
    SampleAppsHelper::PrintHeader(SAMPLE_APP_NAME);
   
    /* RAPIDCODE INITIALIZATION */
   
    // Create the controller
    MotionController::CreationParameters params = SampleAppsHelper::GetCreationParameters();
    MotionController *controller = MotionController::Create(&params);
   
    int exitCode = -1; // Set the exit code to an error value.
    try                // Ensure that the controller is deleted if an error occurs.
    {
      SampleAppsHelper::CheckErrors(controller);
   
      /* SAMPLE APP BODY */
   
      // Get the nodes
      std::vector<RapidCodeNetworkNode *> nodes = GetNodeList(controller);
   
      // Print the network topology
      std::ostringstream topologyInfo;
   
      // Add the overview information
      topologyInfo << "EtherCAT: " << std::to_string(nodes.size());
      topologyInfo << " Nodes, " << RSINetworkTypeMap.at(controller->NetworkTypeGet());
      topologyInfo << " " << RSINetworkStateMap.at(controller->NetworkStateGet()) << "\n";
   
      // Add information for each node
      for (RapidCodeNetworkNode *node : nodes)
      {
        topologyInfo << ReadNodeInfo(node);
      }
   
      // Add network input information
      topologyInfo << "\nNetworkInputs count: " << controller->NetworkInputCountGet() << " _________________________________\n";
      for (int i = 0; i < controller->NetworkInputCountGet(); ++i)
      {
        topologyInfo << "  [" << i << "] - " << std::setw(70) << controller->NetworkInputNameGet(i);
        topologyInfo << " Bits: " << controller->NetworkInputBitSizeGet(i) << "\n";
      }
   
      // Add network output information
      topologyInfo << "NetworkOutputs count: " << controller->NetworkOutputCountGet() << " _________________________________\n";
      for (int i = 0; i < controller->NetworkOutputCountGet(); ++i)
      {
        topologyInfo << "  [" << i << "] - " << std::setw(70) << controller->NetworkOutputNameGet(i);
        topologyInfo << " Bits: " << controller->NetworkOutputBitSizeGet(i) << "\n";
      }
   
      // Print the accumulated string
      std::cout << topologyInfo.str() << std::endl;
   
      exitCode = 0;
    }
    catch (const std::exception &ex)
    {
      std::cerr << ex.what() << std::endl;
      exitCode = -1;
    }
    // Delete the controller as the program exits to ensure memory is deallocated in the correct order
    controller->Delete();
   
    // Print a message to indicate the sample app has finished and if it was successful or not
    SampleAppsHelper::PrintFooter(SAMPLE_APP_NAME, exitCode);
   
    return exitCode;
  }