---

emcdummy.cc

Go to the documentation of this file.

/*
  emcdummy.cc

  Dummy EMC that just accepts any NML command, and echoes a done status
  right away. Used for debugging external processes, e.g., FBICS.

  Note to coders: interface to this dummy process like this:

  // open NML buffers
  static RCS_CMD_CHANNEL * emcCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "emc", "emc.nml");
  static RCS_STAT_CHANNEL * emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "emc", "emc.nml");
  static EMC_STAT emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
  static int serial_number = 0;
  EMC_TASK_PLAN_OPEN open_msg;
  EMC_TASK_PLAN_RUN run_msg;

  // send open message
  strcpy(open_msg.file, "test.ngc");
  open_msg.serial_number = ++serial_number;
  commandBuffer->write(open_msg);

  // check for done
  for (;;)
  {
    statusBuffer->read();
    if (emcStatus->echo_serial_number == serial_number &&
        emcStatus->status == RCS_DONE)
    {
      break;
    }
    // else it's still executing

    // send run message
    run_msg.serial_number = ++serial_number;
    run_msg.line = 0; // run from beginning
    commandBuffer->write(run_msg);

    // check for done
    for (;;)
    {
      statusBuffer->read();
      if (emcStatus->echo_serial_number == serial_number &&
          emcStatus->status == RCS_DONE)
      {
        break;
      }
      // else it's still executing
    }

    // repeat
*/

#include <stdlib.h>             // exit()
#include <signal.h>             // signal(), SIGINT
#include <string.h>             // strncpy()

#include "rcs.hh"               // RCS_CMD_MSG, etc, esleep()
#include "emc.hh"               // EMC NML

// NML channels
static RCS_CMD_CHANNEL * emcCommandBuffer = 0;
static RCS_STAT_CHANNEL * emcStatusBuffer = 0;
static NML * emcErrorBuffer = 0;

// NML command channel data pointer
static RCS_CMD_MSG * emcCommand = 0;

// global EMC status
EMC_STAT * emcStatus = 0;

// name of NML file
static char nmlFile[256] = "emc.nml";

static int startup()
{
  // get the NML command buffer
  emcCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "emc", nmlFile);
  if (! emcCommandBuffer->valid())
    {
      rcs_print_error("can't get emcCommand buffer\n");
      return -1;
    }

  // get our command data structure
  emcCommand = emcCommandBuffer->get_address();

  // get the NML status buffer
  emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "emc", nmlFile);
  if (! emcStatusBuffer->valid())
    {
      rcs_print_error("can't get emcStatus buffer\n");
      return -1;
    }

  // get our status data structure
  emcStatus = new EMC_STAT;

  // get the error log buffer
  emcErrorBuffer = new NML(nmlErrorFormat, "emcError", "emc", nmlFile);
  if (! emcErrorBuffer->valid())
    {
      rcs_print_error("can't get emcError buffer\n");
      return -1;
    }

  return 0;
}

// called to deallocate resources
static int shutdown()
{
  // delete the NML channels

  if (0 != emcErrorBuffer)
    {
      delete emcErrorBuffer;
      emcErrorBuffer = 0;
    }

  if (0 != emcStatusBuffer)
    {
      delete emcStatusBuffer;
      emcStatusBuffer = 0;
      emcStatus = 0;
    }

  if (0 != emcCommandBuffer)
    {
      delete emcCommandBuffer;
      emcCommandBuffer = 0;
      emcCommand = 0;
    }

  if( 0 != emcStatus)
    {
      delete emcStatus;
      emcStatus = 0;
    }

  return 0;
}

// signal handling code to stop main loop
static int done;
static void quit(int sig)
{
  // set main's done flag
  done = 1;

  // restore signal handler
  signal(SIGINT, quit);
}

/*
  syntax: a.out {<nml file>}

  If <nml file> is provided, it will use this, otherwise it will use the
  default "emc.nml".

  This process will access the buffers "emcCommand", "emcStatus", and
  "emcError", as process "emc".

  ^C will nicely terminate this process.
*/
int main(int argc, char *argv[])
{
  NMLTYPE type;

  // set print destination to stdout, for console apps
  set_rcs_print_destination(RCS_PRINT_TO_STDOUT);

  // blank out the annoying RCS version message
  rcs_version_printed = 1;

  if (argc > 1)
    {
      // first arg is NML file-- copy it to global used in startup()
      strcpy(nmlFile, argv[1]);
    }

  // set up NML
  if (0 != startup())
    {
      exit(1);
    }

  // fill in NML status with initial blank values
  emcStatus->command_type = 0;
  emcStatus->echo_serial_number = 0;
  emcStatus->status = RCS_DONE;

  // enter dummy loop
  done = 0;
  while (! done)
    {
      // read command
      type = emcCommandBuffer->read();

      if (0 != type &&
          -1 != type)
        {
          // new command-- show "executing" immediately
          emcStatus->command_type = emcCommand->type;
          emcStatus->echo_serial_number = emcCommand->serial_number;
          emcStatus->status = RCS_EXEC;
          emcStatusBuffer->write(emcStatus);
        }

      // wait a second
      esleep(1.0);

      // now show "done"
      emcStatus->status = RCS_DONE;
      emcStatusBuffer->write(emcStatus);
    }

  if (0 != shutdown())
    {
      exit(1);
    }

  exit(0);
}

---