gc_config.cc

Go to the documentation of this file.

/*
 * This file is part of the rc_genicam_api package.
 *
 * Copyright (c) 2017-2024 Roboception GmbH
 * All rights reserved
 *
 * Author: Heiko Hirschmueller
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 * may be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <rc_genicam_api/system.h>
#include <rc_genicam_api/interface.h>
#include <rc_genicam_api/device.h>
#include <rc_genicam_api/config.h>
 
#include <iostream>
 
int main(int argc, char *argv[])
{
  int ret=0;
 
  try
  {
    if (argc > 1 && std::string(argv[1]) != "-h")
    {
      // list all available GigE Vision devices
 
      if (std::string(argv[1]) == "-l")
      {
        std::cout << "Available GigE Vision devices:" << std::endl;
 
        std::vector<std::shared_ptr<rcg::System> > system=rcg::System::getSystems();
 
        for (size_t i=0; i<system.size(); i++)
        {
          system[i]->open();
 
          std::vector<std::shared_ptr<rcg::Interface> > interf=system[i]->getInterfaces();
 
          for (size_t k=0; k<interf.size(); k++)
          {
            interf[k]->open();
 
            std::vector<std::shared_ptr<rcg::Device> > device=interf[k]->getDevices();
 
            for (size_t j=0; j<device.size(); j++)
            {
              if (device[j]->getTLType() == "GEV")
              {
                std::cout << "  " << interf[k]->getID() << ":" << device[j]->getSerialNumber() << " (";
 
                std::string uname=device[j]->getDisplayName();
 
                if (uname.size() > 0)
                {
                  std::cout << uname << ", ";
                }
 
                std::cout << device[j]->getID() << ")" << std::endl;
              }
            }
 
            interf[k]->close();
          }
 
          system[i]->close();
        }
      }
      else
      {
        // discover and open a specific device
 
        int i=1;
        std::shared_ptr<rcg::Device> dev=rcg::getDevice(argv[i++]);
 
        if (dev != 0)
        {
          bool showsummary=false;
          bool readonly=false;
          bool iponly=false;
 
          // open device with control or read only access, depending on the
          // given parameters
 
          if (i == argc || (i+1 == argc && std::string(argv[i]) == "--iponly"))
          {
            try
            {
              // try to open with control to also show PTP status, which
              // requires calling data latch
              dev->open(rcg::Device::CONTROL);
            }
            catch (const std::exception &)
            {
              // fallback if another application is blocking the device, which
              // means that PTP status cannot be shown
              dev->open(rcg::Device::READONLY);
              readonly=true;
            }
 
            showsummary=true;
          }
          else
          {
            dev->open(rcg::Device::CONTROL);
          }
 
          // change setting according to given parameters
 
          std::shared_ptr<GenApi::CNodeMapRef> nodemap=dev->getRemoteNodeMap();
 
          // default interface is 0 (allowed to fail)
          rcg::setInteger(nodemap, "GevInterfaceSelector", 0);
 
          while (i < argc)
          {
            std::string p=argv[i++];
 
            if (p == "--iponly")
            {
              iponly=true;
            }
            else if (p[0] == '-' && i < argc)
            {
              showsummary=true;
 
              if (p == "-n") // change user defined device name
              {
                rcg::setString(nodemap, "DeviceUserID", argv[i++], true);
              }
              else if (p == "-f") // switch to specified interface
              {
                rcg::setString(nodemap, "GevInterfaceSelector", argv[i++], true);
              }
              else if (p == "-d") // switch dhcp on or off
              {
                rcg::setString(nodemap, "GevCurrentIPConfigurationDHCP", argv[i++], true);
              }
              else if (p == "-p") // switch persistent IP on or off
              {
                rcg::setString(nodemap, "GevCurrentIPConfigurationPersistentIP", argv[i++], true);
              }
              else if (p == "-t") // switch precision time protocol on or off
              {
                rcg::setString(nodemap, "PtpEnable", argv[i++], true);
              }
              else if (p == "-i") // set persistent IP address
              {
                rcg::setIPV4Address(nodemap, "GevPersistentIPAddress", argv[i++], true);
              }
              else if (p == "-s") // set persistent subnet mask
              {
                rcg::setIPV4Address(nodemap, "GevPersistentSubnetMask", argv[i++], true);
              }
              else if (p == "-g") // set persistent gateway
              {
                rcg::setIPV4Address(nodemap, "GevPersistentDefaultGateway", argv[i++], true);
              }
              else
              {
                std::cerr << "Unknown parameter: " << p << std::endl;
                exit(1);
              }
            }
            else if (p.size() > 0 && p[0] == '@')
            {
              // load streamable parameters from file into nodemap
 
              try
              {
                rcg::loadStreamableParameters(nodemap, p.substr(1).c_str(), true);
              }
              catch (const std::exception &ex)
              {
                std::cerr << "Warning: Loading of parameters from file '" << p.substr(1) <<
                  "' failed at least partially" << std::endl;
                std::cerr << ex.what() << std::endl;
              }
            }
            else if (p.find('=') != std::string::npos)
            {
              // split argument in key and value
 
              size_t k=p.find('=');
              std::string value=p.substr(k+1);
              std::string key=p.substr(0, k);
 
              // set key=value pair through GenICam
 
              rcg::setString(nodemap, key.c_str(), value.c_str(), true);
            }
            else
            {
              // call the command
              rcg::callCommand(nodemap, p.c_str(), true);
            }
          }
 
          // print network configuration of the device
 
          if (iponly)
          {
            std::cout << rcg::getString(nodemap, "GevCurrentIPAddress") << std::endl;
          }
          else if (showsummary)
          {
            std::cout << "ID:                         " << dev->getParent()->getID() << ":"
                                                        << rcg::getString(nodemap, "DeviceID") << std::endl;
            std::cout << "GenTL ID:                   " << dev->getID() << std::endl;
            std::cout << "Serial number:              " << rcg::getString(nodemap, "DeviceID") << std::endl;
            std::cout << "User defined ID:            " << rcg::getString(nodemap, "DeviceUserID") << std::endl;
            std::cout << std::endl;
 
            int64_t n=0;
            rcg::getInteger(nodemap, "GevInterfaceSelector", 0, &n);
 
            try
            {
              // just test if GEV interface parameters are available
              rcg::getString(nodemap, "GevCurrentIPAddress", true);
 
              for (int64_t i=0; i<=n; i++)
              {
                rcg::setInteger(nodemap, "GevInterfaceSelector", i);
 
                std::cout << "Interface " << i << ":" << std::endl;
 
                std::cout << "  MAC Address:              " << rcg::getString(nodemap, "GevMACAddress") << std::endl;
                std::cout << std::endl;
 
                std::cout << "  Current IP:               " << rcg::getString(nodemap, "GevCurrentIPAddress") << std::endl;
                std::cout << "  Current subnet mask:      " << rcg::getString(nodemap, "GevCurrentSubnetMask") << std::endl;
                std::cout << "  Current gateway:          " << rcg::getString(nodemap, "GevCurrentDefaultGateway") << std::endl;
                std::cout << std::endl;
 
                std::cout << "  Persistent IP on/off:     " << rcg::getString(nodemap, "GevCurrentIPConfigurationPersistentIP") << std::endl;
                std::cout << "    Persistent IP:          " << rcg::getString(nodemap, "GevPersistentIPAddress") << std::endl;
                std::cout << "    Persistent subnet mask: " << rcg::getString(nodemap, "GevPersistentSubnetMask") << std::endl;
                std::cout << "    Persistent gateway:     " << rcg::getString(nodemap, "GevPersistentDefaultGateway") << std::endl;
                std::cout << "  DHCP on/off:              " << rcg::getString(nodemap, "GevCurrentIPConfigurationDHCP") << std::endl;
                std::cout << "  Link local on/off:        " << rcg::getString(nodemap, "GevCurrentIPConfigurationLLA") << std::endl;
                std::cout << std::endl;
              }
            }
            catch (const std::exception &)
            {
              std::cout << "Gev interface parameters are not available" << std::endl;
              std::cout << std::endl;
            }
 
            try
            {
              // just test if Ptp parameters are available
              rcg::getString(nodemap, "PtpEnable", true);
 
              if (!readonly)
              {
                rcg::callCommand(nodemap, "PtpDataSetLatch");
 
                std::cout << "PTP:                        " << rcg::getString(nodemap, "PtpEnable") << std::endl;
                std::cout << "PTP status:                 " << rcg::getString(nodemap, "PtpStatus") << std::endl;
                std::cout << "PTP offset:                 " << rcg::getInteger(nodemap, "PtpOffsetFromMaster") << " ns" << std::endl;
              }
              else
              {
                std::cout << "Ptp cannot be shown due to another application with control access." << std::endl;
                std::cout << std::endl;
              }
            }
            catch (const std::exception &)
            {
              std::cout << "Ptp parameters are not available" << std::endl;
              std::cout << std::endl;
            }
          }
 
          dev->close();
        }
        else
        {
          std::cerr << "Cannot find device: " << argv[1] << std::endl;
          ret=1;
        }
      }
    }
    else
    {
      std::cout << argv[0] << " -h | -l | ([<interface-id>:]<device-id> <options> ...)" << std::endl;
      std::cout << std::endl;
      std::cout << "Configuration of a GigE Vision device via GenICam." << std::endl;
      std::cout << std::endl;
      std::cout << "-h             Prints help information and exits" << std::endl;
      std::cout << "-l             Lists all available GigE Vision devices" << std::endl;
      std::cout << std::endl;
      std::cout << "Parameters:" << std::endl;
      std::cout << "<interface-id> Optional GenICam ID of interface for connecting to the device" << std::endl;
      std::cout << "<device-id>    GenICam device ID, serial number or user defined name of device" << std::endl;
      std::cout << std::endl;
      std::cout << "Options:" << std::endl;
      std::cout << "-n <id>        Set user defined id" << std::endl;
      std::cout << "-f <n>         Apply all further IP settings to interface with specified number. Default: 0" << std::endl;
      std::cout << "-d 1|0         Switch DHCP on or off" << std::endl;
      std::cout << "-p 1|0         Switch persistent IP on or off" << std::endl;
      std::cout << "-t 1|0         Switch precision time protocol (ptp) on or off" << std::endl;
      std::cout << "-i <ip>        Set persistent IP address" << std::endl;
      std::cout << "-s <ip>        Set subnet mask for persistent IP address" << std::endl;
      std::cout << "-g <ip>        Set default gateway for persistent IP address" << std::endl;
      std::cout << "--iponly       Show current IP of device instead of full summary" << std::endl;
      std::cout << "@<file>        Optional file with parameters as store with parameter 'gc_info -p ...'" << std::endl;
      std::cout << "<key>=<value>  Optional GenICam parameters to be changed in the given order" << std::endl;
      ret=1;
    }
  }
  catch (const std::exception &ex)
  {
    std::cerr << ex.what() << std::endl;
    ret=2;
  }
 
  rcg::System::clearSystems();
 
  return ret;
}