SampleAppsConsole.cpp

#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
 
#include "SampleAppsHelper.h"
 
// Include the sample apps
#include "SampleApps.h"
 
using namespace RSI::RapidCode;                     // Import the RapidCode namespace
 
constexpr int MAX_NUM_ARGS = 256;
 
// Status flags
bool noInput = false;
bool quit = false;
int exitCode = 0;
 
// Map the sample app names to their corresponding sample app
static std::map<std::string, std::shared_ptr<SampleApp>> SampleAppNamesMap =
{
  {"hardware-limits", std::make_shared<HardwareLimits>()},
  {"memory", std::make_shared<Memory>()},
  {"motion-hold-released-by-software-address", std::make_shared<MotionHoldReleasedBySoftwareAddress>()},
  {"multiaxis-motion", std::make_shared<MultiaxisMotion>()},
  {"path-motion", std::make_shared<PathMotion>()},
  {"pvt-motion-multiaxis", std::make_shared<PVTmotionMultiAxis>()},
  {"single-axis-sync-outputs", std::make_shared<SingleAxisSyncOutputs>()},
  {"sync-output-with-motion", std::make_shared<SyncOutputWithMotion>()},
  {"update-buffer-points", std::make_shared<UpdateBufferPoints>()},
  {"user-limit-digital-input-action", std::make_shared<UserLimitDigialInputAction>()}
};
 
// Print the list of available sample apps
static void ListSampleApps()
{
  std::cout << std::endl << "Available Sample Apps:" << std::endl;
 
  // Iterate over the sample app names and print them
  std::shared_ptr<SampleApp> sampleApp;
  for (auto const& sampleAppName : SampleAppNamesMap)
  {
    std::cout << " - " << sampleAppName.first << std::endl;
  }
}
 
// Print the information on running with hardware
static void PrintHardwareHelp()
{
  std::cout << std::endl << "To run a SampleApp with hardware you must complete the following steps:" << std::endl;
  std::cout << "  1.  In the source file for the SampleApp, set the axis configuration parameters." << std::endl;
  std::cout << "  2.  Still in the source file, set the 'USE_HARDWARE' flag to true in the class's run method." << std::endl;
  std::cout << "  3.  Rebuild this project." << std::endl;
  std::cout << "  4.  Ensure that you have taken all proper safety precautions appropriate to your particular hardware setup." << std::endl;
  std::cout << "  5.  Relaunch 'SampleAppsCPP.exe' and run the SampleApp to observe the results." << std::endl;
}
 
// Print the help message
static void PrintHelp()
{
  std::cout << std::endl << "Enter the name of a Sample App to run it." << std::endl;
  std::cout << " - Running on hardware requires additional configuration. Type 'hardware' for more information." << std::endl;
  std::cout << std::endl << "You may also use 'runall' to run all supported Sample Apps." << std::endl;
  std::cout << std::endl << "Type 'l' or 'list' to list the available Sample Apps." << std::endl;
}
 
static void PrintWelcomeMessage()
{
  std::cout << "Welcome to the RapidCode C++ Sample Apps!" << std::endl << std::endl;
  std::cout << "This program allows you to run the sample apps that are included with the RapidCode API." << std::endl;
  std::cout << std::endl << "WARNING: The sample apps are meant to be used as a reference and may not contain all of the logic and safety features that your application requires." << std::endl;
  std::cout << "Additionally, in order to mitigate unexpected behavior, running a sample app will reset your RMP controller, clearing any previous configuration." << std::endl;
  std::cout << std::endl << "It is recommended that you do not have any hardware connected when running the sample apps for the first time." << std::endl;
  std::cout << "Before you attempt to run a sample app with hardware, please ensure that you have completed the necessary configuration steps and reviewed the source files." << std::endl;
  std::cout << "Type 'hardware' for more information." << std::endl;
  ListSampleApps();
}
 
// Get the sample app using the string name
static std::shared_ptr<SampleApp> GetSampleApp(std::string sampleAppName)
{
  // Convert the input to lowercase
  std::transform(sampleAppName.begin(), sampleAppName.end(), sampleAppName.begin(),
    [](unsigned char c) { return std::tolower(c); });
 
  // Check if the input is a valid sample app name
  if (SampleAppNamesMap.find(sampleAppName) == SampleAppNamesMap.end())
  {
    throw std::invalid_argument("Error: Invalid Sample App name.");
  }
 
  // Get the sample app
  return SampleAppNamesMap.at(sampleAppName);
}
 
// Run the sample app
static int RunSampleApp(std::string sampleAppName)
{
  // Initialize the exit code
  int appExitCode = 0;
 
  // Try find the specified sample app
  std::shared_ptr<SampleApp> sampleApp;
  try
  {
    sampleApp = GetSampleApp(sampleAppName);
  }
  catch (std::invalid_argument& e)
  {
    std::cout << std::endl << e.what() << std::endl;
    ListSampleApps();
    return -1;
  }
  
  // Run the requested sample app
  std::cout << std::endl << "--------------------------------------------------" << std::endl;
  std::cout << "Running " << sampleAppName << "..." << std::endl;
  std::cout << "--------------------------------------------------" << std::endl << std::endl;
  try
  {
    appExitCode = sampleApp->Run();
  }
  catch (std::exception& e)
  {
    std::cout << std::endl << "Error: " << e.what() << std::endl;
    appExitCode = -2;
  }
 
  std::cout << std::endl << "--------------------------------------------------" << std::endl;
 
  // Print the result of the sample app
  if (appExitCode == 0)
  {
    std::cout << "Sample App " << sampleAppName << " completed successfully." << std::endl;
  }
  else
  {
    std::cout << "Sample App " << sampleAppName << " completed with errors." << std::endl;
  }
 
  std::cout << "--------------------------------------------------" << std::endl << std::endl;
 
  return appExitCode;
}
 
// Run all the sample apps that are set to run that are configured for the specified hardware mode
static int RunAll()
{
  int runallExitCode = 0;
  int appExitCode = 0;
  std::vector<std::string> failedSampleApps;
  for (auto const& sampleAppName : SampleAppNamesMap)
  {
    appExitCode = RunSampleApp(sampleAppName.first);
 
    // Record the apps that failed
    if (appExitCode != 0)
    {
      failedSampleApps.push_back(sampleAppName.first);
    }
 
    // Lower exit codes are more severe, so we want to keep the lowest exit code
    if (appExitCode < runallExitCode)
    {
      runallExitCode = appExitCode;
    }
  }
 
  // Print the list of failed sample apps
  if (failedSampleApps.size() > 0)
  {
    std::cout << std::endl << "The following Sample Apps failed:" << std::endl;
    for (auto const& sampleAppName : failedSampleApps)
    {
      std::cout << " - " << sampleAppName << std::endl;
    }
  }
 
  return runallExitCode;
}
 
// Get the arguments from the user
static std::vector<std::string> GetInput()
{
  std::string input;
  std::cout << std::endl << "Enter a Sample App name or 'runall'. Type 'h' or 'help' for more info. Type 'q' or 'quit' to end program." << std::endl;
  std::cout << std::endl << ">> ";
  std::getline(std::cin, input);
 
  std::istringstream streamInput(input);
  std::string token;
  std::vector<std::string> args;
  while (std::getline(streamInput, token, ' '))
  {
    args.push_back(token);
  }
 
  return args;
}
 
static int ProcessInput(std::vector<std::string> args)
{
  // If no arguments are provided print the help message
  if (args.size() < 1 ||
    args[0] == "h" ||
    args[0] == "help")
  {
    PrintHelp();
    return 0;
  }
 
  // If the first argument is 'hardware', print the hardware information
  if (args[0] == "hardware")
  {
    PrintHardwareHelp();
    return 0;
  }
 
  // If the first argument is 'list', list the available sample apps
  if (args[0] == "l" || args[0] == "list")
  {
    ListSampleApps();
    return 0;
  }
 
  // If the first argument is 'q' or 'quit', end the program
  if (args[0] == "q" || args[0] == "quit")
  {
    quit = true;
    return 0;
  }
 
  // If the first argument is 'runall', check if the second argument is 'phantoms' or 'hardware'
  if (args[0] == "runall")
  {
    return RunAll();
  }
 
  // Try to run the specified sample app
  return RunSampleApp(args[0]);
}
 
// Parse the command line arguements
std::vector<std::string> ParseArgs(int argc, char* argv[])
{
  std::vector<std::string> args;
  std::string arg;
  for (int i = 1; i < argc; i++)
  {
    arg = argv[i];    // Convert the char* to a string
    // Check for special arguments which all start with "--"
    if (arg == "--no-input")
    {
      noInput = true;
    }
    else // All other arguments are added to the args vector
    {
      args.push_back(arg);
    }
  }
 
  return args;
}
 
int main(int argc, char* argv[])
{
  // Check for too many arguments
  if (argc > MAX_NUM_ARGS)
  {
    std::cout << "Error: Too many arguments." << std::endl;
    return -1;
  }
 
  // Parse the command line arguments
  std::vector<std::string> args;
  if (argc > 1)
  {
    args = ParseArgs(argc, argv);
    exitCode = ProcessInput(args);
  }
 
  // If the --no-input flag is set, then exit the program after processing the command line arguments
  if (noInput)
  {
    return exitCode;
  }
 
  // Print the welcome message
  PrintWelcomeMessage();
 
  // Get the input from the user and process it until they quit
  while (!quit)
  {
    args = GetInput();
    exitCode = ProcessInput(args);
  }
 
  return exitCode;
}