---

emcpanel.cc

Go to the documentation of this file.

/*
  emcpanel.cc

  New, improved EMC text operator interface

  Modification history:

  1-Jun-2001  FMP added printing of debug levels in task, IO
  23-May-2001  FMP added display of program units
  30-Mar-2000 WPS added ferrorCurrent display.
  22-Jan-2000  FMP added "out" for setting axis output
  17-Aug-1999  FMP took out EMC_TASK_INTERP_STEPPING
  16-Jun-1999  FMP added printing of axis setpoint
  21-May-1999  FMP added EMC_LOG_TYPE_TRAJ_POS, changing TRAJ_INPOS,OUTPOS
  to AXES_INPOS,OUTPOS
  22-Mar-1999  FMP added line to emc_task_plan_run_msg
  7-Jan-1999  FMP added -noerror flag for catchErrors
  21-Oct-1998  FMP added EMC_COMMAND_TIMEOUT,DELAY instead of
  task cycle time ini file var in emcCommandWait()
  15-Oct-1998  FMP changed from NML_ERROR to EMC_OPERATOR_ERROR, etc.
  25-Jun-1998  FMP added better program line number, program text printing
  25-Mar-1998  FMP changed usleep() to esleep()
  4-Mar-1998  FMP added command line arg processing for -nml; added
  EMC_NMLFILE from emcglb.h
  26-Feb-1998  FMP added brake off/on for emctask
  24-Feb-1998  FMP added printing of origin in showProgram()
  23-Feb-1998  FMP grouped 0 and id matches when peeking together, so
  0 reads still update status. This has the effect of re-reading the
  serial number, which doesn't change anything but it does make it
  consistent with safe programming practice.
  20-Feb-1998  FMP added printing of axis enabled flags
  19-Feb-1998  FMP added /, // for axis, traj abort
  17-Feb-1998  FMP added homing, homed to axis status printing
  15-Jan-1998  FMP added null check on emcStatus before printing, in
  emcpanelShow()
  16-Oct-1997  FMP created
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>              // isspace()
#include "getinput.h"           // getinput()

#include "rcs.hh"               // rcs_print_error(), esleep()
#include "emc.hh"               // EMC NML
#include "canon.hh"             // CANON_UNITS
#include "rs274ngc.hh"          // NUM_G_CODES, NUM_M_CODES
#include "nml_mod.hh"           // SO, S1, RCS_DONE
#include "emcglb.h"             // EMC_NMLFILE

/* ident tag */
#ifndef __GNUC__
#ifndef __attribute__
#define __attribute__(x)
#endif
#endif

static char __attribute__((unused)) ident[] = "$Id: emcpanel.cc,v 1.7 2001/06/29 20:27:29 wshackle Exp $";

// the NML channels to the EMC task
static RCS_CMD_CHANNEL *emcCommandBuffer = 0;
static RCS_STAT_CHANNEL *emcStatusBuffer = 0;
EMC_STAT *emcStatus = 0;

// the NML channels to the EMCIO controller
static RCS_CMD_CHANNEL *emcIoCommandBuffer = 0;
static RCS_STAT_CHANNEL *emcIoStatusBuffer = 0;
EMC_IO_STAT *emcIoStatus = 0;

// the NML channel for errors
static NML *emcErrorBuffer = 0;

// the current command numbers, set up updateStatus(), used in main()
static int emcCommandSerialNumber = 0;
static int emcIoCommandSerialNumber = 0;

// internal params

// the saved program name
static char programFile[EMC_TASK_FILENAME_LEN] = "";
static int programOpened = 0;
static FILE * programFp = 0;
static int programFpLine = 0;
static int programActiveLine = 0;
static char programLineText[EMC_TASK_COMMAND_LEN] = "";

// saved log file params
static char saveLogFile[EMC_LOG_FILENAME_LEN] = "emc.log";
static int saveLogType = EMC_LOG_TYPE_AXIS_POS;
static int saveLogSize = 1000;
static int saveLogSkip = 0;
static int saveLogAxis = 0;

// paths to awk and xgraph, using to plot logs
// fill these in for your system, if these are not in user's path
#define AWK_PATH "awk"
#define XGRAPH_PATH "xgraph"
#define SYSTEM_STRING_LEN 1024

static int plotLog(const char * logfile, int logtype, int which)
{
  char string[SYSTEM_STRING_LEN];
  int retval;

  if (logfile == 0)
    {
      return -1;
    }

  switch (logtype)
    {
    case EMC_LOG_TYPE_AXIS_POS:
      sprintf(string, "( %s '{print $1 \" \" $2}' < %s ; echo \"\" ; %s '{print $1 \" \" $3}' < %s ) 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, AWK_PATH, logfile, XGRAPH_PATH);
      break;

    case EMC_LOG_TYPE_AXES_INPOS:
    case EMC_LOG_TYPE_AXES_OUTPOS:
      sprintf(string, "%s '{print $2 \" \" $3}' < %s 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, XGRAPH_PATH);
      break;

    default:
      return -1;
      break;
    }

  retval = system(string);

  return retval;
}

// values for axisSelect, set so they can be used as 'axis' arg in NML
enum {AXIS_X = 0,
      AXIS_Y,
      AXIS_Z};

// values for jogSelect
enum {JOG_CONT = 1,
      JOG_INCR};

static int axisSelect = AXIS_X;
static double speedSelect = 1.0;
static double jogIncr = 1.0;
static int jogSelect = JOG_CONT;

// flag to signify that the prompt should be reprinted
static int printPrompt;

// size of input buffer
#define INPUTLEN 80

// microseconds to sleep between calls to getinput()
#define SLEEP_SECS 0.100

static enum {
  DISPLAY_ABS = 1,
  DISPLAY_REL
} displayMode = DISPLAY_ABS;

// takes a string, and returns 0 if all whitespace, 1 otherwise
static int anyprintable(const char *string)
{
  int cnt = 0;
  char c;

  while (0 != (c = string[cnt++]))
    {
      if (!isspace(c))
        {
          return 1;
        }
    }

  return 0;
}

static int emcTaskNmlGet()
{
  int retval = 0;

  // try to connect to NC cmd
  if (emcCommandBuffer == 0)
    {
      printf("trying emcCommand...");
      emcCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "emcpanel", EMC_NMLFILE);
      if (! emcCommandBuffer->valid())
        {
          delete emcCommandBuffer;
          emcCommandBuffer = 0;
          retval = -1;
          printf("failed\n");
        }
      printf("got it\n");
    }

  // try to connect to NC status
  if (emcStatusBuffer == 0)
    {
      printf("trying emcStatus...");
      emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "emcpanel", EMC_NMLFILE);
      if (! emcStatusBuffer->valid() ||
          EMC_STAT_TYPE != emcStatusBuffer->peek())
        {
          delete emcStatusBuffer;
          emcStatusBuffer = 0;
          emcStatus = 0;
          retval = -1;
          printf("failed\n");
        }
      else
        {
          emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
          printf("got it\n");
        }
    }

  return retval;
}

static int emcErrorNmlGet()
{
  int retval = 0;

  if (emcErrorBuffer == 0)
    {
      printf("trying emcError...");
      emcErrorBuffer = new NML(nmlErrorFormat, "emcError", "emcpanel", EMC_NMLFILE);
      if (! emcErrorBuffer->valid())
        {
          rcs_print_error("emcError channel not available\n");
          delete emcErrorBuffer;
          emcErrorBuffer = 0;
          retval = -1;
          printf("failed\n");
        }
      printf("got it\n");
    }

  return retval;
}

static int emcIoNmlGet()
{
  int retval = 0;

  if (emcIoCommandBuffer == 0)
    {
      printf("trying toolCmd...");
      emcIoCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "toolCmd", "emcpanel", EMC_NMLFILE);
      if (! emcIoCommandBuffer->valid())
        {
          delete emcIoCommandBuffer;
          emcIoCommandBuffer = 0;
          retval = -1;
          printf("failed\n");
        }
      printf("got it\n");
    }

  if (emcIoStatusBuffer == 0)
    {
      printf("tring toolSts...");
      emcIoStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "toolSts", "emcpanel", EMC_NMLFILE);
      if (! emcIoStatusBuffer->valid() ||
          EMC_IO_STAT_TYPE != emcIoStatusBuffer->peek())
        {
          delete emcIoStatusBuffer;
          emcIoStatusBuffer = 0;
          emcIoStatus = 0;
          retval = -1;
          printf("failed\n");
        }
      else
        {
          emcIoStatus = (EMC_IO_STAT *) emcIoStatusBuffer->get_address();
          printf("got it\n");
        }
    }

  return retval;
}

static int emcpanelQuit()
{
  if (emcIoStatusBuffer != 0)
    {
      delete emcIoStatusBuffer;
      emcIoStatusBuffer = 0;
      emcIoStatus = 0;
    }

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

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

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

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

  return 0;
}

#define STRLEN 80
static char *state_to_string(int state)
{
  static char scratch[STRLEN];

  switch (state)
    {
    case NEW_COMMAND:
      return "NEW_COMMAND";
    case S0:
      return "S0";
    case S1:
      return "S1";
    case S2:
      return "S2";
    case S3:
      return "S3";
    case S4:
      return "S4";
    case S5:
      return "S5";
    case S6:
      return "S6";
    case S7:
      return "S7";
    case S8:
      return "S8";
    case S9:
      return "S9";
    case S10:
      return "S10";
    case S11:
      return "S11";
    case S12:
      return "S12";
    default:
      sprintf(scratch, "%d", state);
      return scratch;
    }
}

static char *status_to_string(int status)
{
  static char scratch[STRLEN];

  switch (status)
    {
    case RCS_DONE:
      return "DONE";
    case RCS_EXEC:
      return "EXEC";
    case RCS_ERROR:
      return "ERROR";
    default:
      sprintf(scratch, "%d", status);
      return scratch;
    }
}

/*
 btostr()

 converts byte to 0-1 style string, in s. Assumes a byte is 8 bits.
*/
static int btostr(char * s, unsigned char b)
{
  int t;

  for (t = 7; t >= 0; t--)
    {
      s[t] = b % 2 ? '1' : '0';
      b >>= 1;
    }
  s[8] = 0;                     /* null terminate */

  return 0;
}

static void showState()
{
  if (0 == emcStatus)
    {
      return;
    }

  printf("Heartbeat: \t%lu\n", emcStatus->task.heartbeat);
  printf("Debug:     \t%d\n", emcStatus->debug);
  printf("State:     \t");
  switch (emcStatus->task.state)
    {
    case EMC_TASK_STATE_OFF:
      printf("OFF\n");
      break;
    case EMC_TASK_STATE_ON:
      printf("ON\n");
      break;
    case EMC_TASK_STATE_ESTOP:
      printf("ESTOP\n");
      break;
    case EMC_TASK_STATE_ESTOP_RESET:
      printf("ESTOP RESET\n");
      break;
    default:
      printf("%d (?)\n", emcStatus->task.state);
      break;
    }
}

static void showMode()
{
  if (0 == emcStatus)
    {
      return;
    }

  printf("Mode:\t\t");
  switch (emcStatus->task.mode)
    {
    case EMC_TASK_MODE_AUTO:
      printf("AUTO\n");
      break;
    case EMC_TASK_MODE_MDI:
      printf("MDI\n");
      break;
    case EMC_TASK_MODE_MANUAL:
      printf("MANUAL\n");
      break;
    default:
      printf("%d (?)\n", emcStatus->task.mode);
      break;
    }
}

static void showPosition()
{
  int axis;

  if (0 == emcStatus)
    {
      return;
    }

  if (displayMode == DISPLAY_ABS)
    {
      printf("Cmd Pos: \t%f\t%f\t%f\n",
             emcStatus->motion.traj.position.tran.x,
             emcStatus->motion.traj.position.tran.y,
             emcStatus->motion.traj.position.tran.z);
      printf("Act Pos: \t%f\t%f\t%f\n",
             emcStatus->motion.traj.actualPosition.tran.x,
             emcStatus->motion.traj.actualPosition.tran.y,
             emcStatus->motion.traj.actualPosition.tran.z);
    }
  else if (displayMode == DISPLAY_REL)
    {
      printf("Cmd Pos: \t%f\t%f\t%f\n",
             emcStatus->motion.traj.position.tran.x -
             emcStatus->task.origin.tran.x,
             emcStatus->motion.traj.position.tran.y -
             emcStatus->task.origin.tran.y,
             emcStatus->motion.traj.position.tran.z -
             emcStatus->task.origin.tran.z);
      printf("Act Pos: \t%f\t%f\t%f\n",
             emcStatus->motion.traj.actualPosition.tran.x -
             emcStatus->task.origin.tran.x,
             emcStatus->motion.traj.actualPosition.tran.y -
             emcStatus->task.origin.tran.y,
             emcStatus->motion.traj.actualPosition.tran.z -
             emcStatus->task.origin.tran.z);
    }
  else
    {
      printf("Position:\t(display mode not abs or rel: %d)\n",
             displayMode);
    }

  printf("Axes:    ");
  for (axis = 0; axis < EMC_AXIS_MAX; axis++) {
    printf("\t%f", emcStatus->motion.axis[axis].setpoint);
  }
  printf("\n");

  printf("Queue:   \t%d\n",
         emcStatus->motion.traj.queue);
  printf("Inpos:   \t%d\n",
         emcStatus->motion.traj.inpos);
  printf("V Scale: \t%.2f\n",
         emcStatus->motion.traj.scale);
}

static void showParams()
{
  printf("Axis:    \t%s\n",
         axisSelect == AXIS_X ? "X" :
         axisSelect == AXIS_Y ? "Y" :
         axisSelect == AXIS_Z ? "Z" : "?");
  printf("Speed:   \t%f\n", speedSelect);
  printf("Jog Type:\t%s\n",
         jogSelect == JOG_CONT ? "CONT" :
         jogSelect == JOG_INCR ? "INCR" : "?");
  printf("Jog Incr:\t%f\n", jogIncr);
}

static void showProgram()
{
  if (0 == emcStatus) {
    return;
  }

  if (! programOpened) {
    // print the last one opened, since we'll send this by default
    printf("Program: \t%s\n", programFile);
  }
  else {
    // print the one the controller knows about
    printf("Program: \t%s\n", emcStatus->task.file);
  }

  if (emcStatus->task.currentLine > 0) {
    if (emcStatus->task.motionLine > 0 &&
        emcStatus->task.motionLine < emcStatus->task.currentLine) {
      programActiveLine = emcStatus->task.motionLine;
    }
    else {
      programActiveLine = emcStatus->task.currentLine;
    }

    if (programFp != 0) {
      if (programFpLine > programActiveLine) {
        rewind(programFp);
        programFpLine = 0;
        programLineText[0] = 0;
      }
      else {
        while (programFpLine < programActiveLine) {
          fgets(programLineText, EMC_TASK_COMMAND_LEN, programFp);
          programFpLine++;
        }
      }
    }
    else {
      programLineText[0] = 0;
    }
  }
  else {
    programActiveLine = 0;
    programLineText[0] = 0;
  }

  printf("Units:   \t%s\n", 
         emcStatus->task.programUnits == CANON_UNITS_INCHES ? "inches" :
         emcStatus->task.programUnits == CANON_UNITS_MM ? "mm" :
         emcStatus->task.programUnits == CANON_UNITS_CM ? "cm" : "?");
         
  printf("Line:    \t%d\n", programActiveLine);
  printf("Command: \t%s\n", programLineText);

  printf("Origin:  \t%f\t%f\t%f\n",
         emcStatus->task.origin.tran.x,
         emcStatus->task.origin.tran.y,
         emcStatus->task.origin.tran.z);
}

static void showEmcTaskExec()
{
  if (0 == emcStatus)
    {
      return;
    }

  printf("NML:         \tcmd\tser #\tstatus\n");
  printf("             \t%ld\t%d\t%s\n",
         emcStatus->command_type, emcStatus->echo_serial_number,
         emcStatus->status == RCS_DONE ? "DONE" :
         emcStatus->status == RCS_EXEC ? "EXEC" :
         emcStatus->status == RCS_ERROR ? "ERROR" : "(?)");

  printf("Exec:         \t%s\n",
         emcStatus->task.execState == EMC_TASK_EXEC_ERROR ? "ERROR" :
         emcStatus->task.execState == EMC_TASK_EXEC_DONE ? "DONE" :
         emcStatus->task.execState == EMC_TASK_EXEC_WAITING_FOR_MOTION ? "MOTION WAIT" :
         emcStatus->task.execState == EMC_TASK_EXEC_WAITING_FOR_IO ? "IO WAIT" :
         emcStatus->task.execState == EMC_TASK_EXEC_WAITING_FOR_MOTION_QUEUE ? "QUEUE WAIT" :
         emcStatus->task.execState == EMC_TASK_EXEC_WAITING_FOR_PAUSE ? "PAUSE WAIT" :
         emcStatus->task.execState == EMC_TASK_EXEC_WAITING_FOR_MOTION_AND_IO ? "MOTION AND IO WAIT" :
         "?");

  printf("Interp:       \t%s\n",
         emcStatus->task.interpState == EMC_TASK_INTERP_IDLE ? "IDLE" :
         emcStatus->task.interpState == EMC_TASK_INTERP_READING ? "READING" :
         emcStatus->task.interpState == EMC_TASK_INTERP_PAUSED ? "PAUSED" :
         emcStatus->task.interpState == EMC_TASK_INTERP_WAITING ? "WAITING" :
         "?");

  printf("Motion line:  \t%d\n", emcStatus->task.motionLine);
  printf("Current line: \t%d\n", emcStatus->task.currentLine);
  printf("Read line:    \t%d\n", emcStatus->task.readLine);
}

static void showEmcio()
{
  int t;
  char bits[9];                 // for "11011001\0" bits string

  if (0 == emcIoStatus)
    {
      return;
    }

  printf("emcio status:    %ld %d %s %s %d %d %s\n",
         emcIoStatus->command_type,
         emcIoStatus->echo_serial_number,
         status_to_string(emcIoStatus->status),
         state_to_string(emcIoStatus->state),
         emcIoStatus->line,
         emcIoStatus->source_line,
         emcIoStatus->source_file);

  printf("heartbeat:       %lu\n", emcIoStatus->heartbeat);

  printf("debug level:     %d\n", emcIoStatus->debug);

  printf("tools:           pocket\ttool\tlength\t\tdiameter\n");
  printf("                 ------\t----\t------\t\t--------\n");
  for (t = 0; t < CANON_TOOL_MAX; t++)
    {
      if (emcIoStatus->tool.toolTable[t].id != 0)
        {
          printf("                 %d\t%d\t%10.4f\t%10.4f\n",
                 t,
                 emcIoStatus->tool.toolTable[t].id,
                 emcIoStatus->tool.toolTable[t].length,
                 emcIoStatus->tool.toolTable[t].diameter);
        }
    }

  printf("tool prepped:    %d\n",
         emcIoStatus->tool.toolPrepped);
  printf("tool in spindle: %d\n",
         emcIoStatus->tool.toolInSpindle);

  printf("spindle:         %.0f RPM, %s\n",
         emcIoStatus->spindle.speed,
         emcIoStatus->spindle.brake == 0 ? "free" : "braked");

  printf("mist:            %s\n",
         emcIoStatus->coolant.mist == 0 ? "OFF" : "ON");
  printf("flood:           %s\n",
         emcIoStatus->coolant.flood == 0 ? "OFF" : "ON");

  printf("estop:           %s\n",
         emcIoStatus->aux.estop == 0 ? "OFF" : "ESTOPPED");

  printf("lube:            %s\n",
         emcIoStatus->lube.on == 0 ? "OFF" : "ON");

  printf("lube level:      %s\n",
         emcIoStatus->lube.level == 0 ? "LOW" : "OK");

  printf("digital ins:     ");
  for (t = EMC_AUX_MAX_DIN - 1; t >= 0; t--)
    {
      btostr(bits, emcIoStatus->aux.din[t]);
      printf("%s ", bits);
    }
  printf("\n");

  printf("digital outs:    ");
  for (t = EMC_AUX_MAX_DOUT - 1; t >= 0; t--)
    {
      btostr(bits, emcIoStatus->aux.dout[t]);
      printf("%s ", bits);
    }
  printf("\n");
}

static void showTools()
{
  int t;

  if (0 == emcStatus)
    {
      return;
    }

  printf("pocket\ttool\tlength\tdiameter\n");
  printf("------\t----\t------\t--------\n");
  for (t = 0; t < CANON_TOOL_MAX; t++)
    {
      if (emcStatus->io.tool.toolTable[t].id != 0)
        {
          printf("%d\t%d\t%f\t%f\n",
                 t,
                 emcStatus->io.tool.toolTable[t].id,
                 emcStatus->io.tool.toolTable[t].length,
                 emcStatus->io.tool.toolTable[t].diameter);
        }
    }
}

static void showAxis()
{
  int axis;

  axis = axisSelect;

  printf("axis:\t\t\t%d\n", emcStatus->motion.axis[axis].axis);

  printf("type:\t\t\t%s\n",
         emcStatus->motion.axis[axis].axisType == EMC_AXIS_LINEAR ? "LINEAR" :
         emcStatus->motion.axis[axis].axisType == EMC_AXIS_ANGULAR ? "ANGULAR" :
         "?");
  printf("units:\t\t\t%f\n", emcStatus->motion.axis[axis].units);

  printf("P I D FF0 FF1 FF2:\t%.3f %.3f %.3f %.3f %.3f %.3f\n",
         emcStatus->motion.axis[axis].p,
         emcStatus->motion.axis[axis].i,
         emcStatus->motion.axis[axis].d,
         emcStatus->motion.axis[axis].ff0,
         emcStatus->motion.axis[axis].ff1,
         emcStatus->motion.axis[axis].ff2);
  printf("cycle time:\t\t%f\n", emcStatus->motion.axis[axis].cycleTime);

  printf("input scale:\t\t%f %f\n",
         emcStatus->motion.axis[axis].inputScale,
         emcStatus->motion.axis[axis].inputOffset);

  printf("output scale:\t\t%f %f\n",
         emcStatus->motion.axis[axis].outputScale,
         emcStatus->motion.axis[axis].outputOffset);

  printf("pos limits:\t\t%f %f\n",
         emcStatus->motion.axis[axis].minPositionLimit,
         emcStatus->motion.axis[axis].maxPositionLimit);

  printf("output limits:\t\t%f %f\n",
         emcStatus->motion.axis[axis].minOutputLimit,
         emcStatus->motion.axis[axis].maxOutputLimit);

  printf("max ferror:\t\t%f\n", emcStatus->motion.axis[axis].maxFerror);

  printf("polarity:\t\tEN\tLS-\tLS+\tHS\tH\tF\n");
  printf("\t\t\t%d\t %d\t %d\t%d\t%d\t%d\n",
         (int) emcStatus->motion.axis[axis].enablePolarity,
         (int) emcStatus->motion.axis[axis].minLimitSwitchPolarity,
         (int) emcStatus->motion.axis[axis].maxLimitSwitchPolarity,
         (int) emcStatus->motion.axis[axis].homeSwitchPolarity,
         (int) emcStatus->motion.axis[axis].homingPolarity,
         (int) emcStatus->motion.axis[axis].faultPolarity);

  printf("setpoint:   \t\t%f\n", emcStatus->motion.axis[axis].setpoint);
  printf("ferror:     \t\t%f\n", emcStatus->motion.axis[axis].ferrorCurrent);
  printf("ferrorHighMark:     \t\t%f\n", emcStatus->motion.axis[axis].ferrorHighMark);
  printf("output:     \t\t%f\n", emcStatus->motion.axis[axis].output);
  printf("input:      \t\t%f\n", emcStatus->motion.axis[axis].input);
  printf("homing:     \t\t%s\n",
         emcStatus->motion.axis[axis].homing == 1 ? "homing" : "done");
  printf("homed:      \t\t%s\n",
         emcStatus->motion.axis[axis].homed == 1 ? "home" : "not yet");
  printf("enabled:    \t\t%s\n",
         emcStatus->motion.axis[axis].enabled == 1 ? "ON" : "OFF");
}

static void showCodes()
{
  int t;
  int code;

  if (0 == emcStatus)
    {
      return;
    }

  for (t = 1; t < EMC_TASK_ACTIVE_G_CODES; t++)
    {
      code = emcStatus->task.activeGCodes[t];
      if (code == -1)
        continue;
      if (code % 10)
        printf("G%.1f ", (double) code / 10.0);
      else
        printf("G%d ", code / 10);
    }
  printf("\n");
}

static void emcpanelShow(int toPrint)
{
  switch (toPrint)
    {
    case 0:
      // show default stuff
      showState();
      showMode();
      showPosition();
      showProgram();
      showEmcTaskExec();
      break;

    case 1:
      // show state
      showState();
      break;

    case 2:
      // show mode
      showMode();
      break;

    case 3:
      // show position
      showPosition();
      break;

    case 4:
      // show internal params
      showParams();
      break;

    case 5:
      // show interpreter
      showProgram();
      break;

    case 6:
      // show EMC TASK
      showEmcTaskExec();
      break;

    case 8:
      // show EMC IO
      showEmcio();
      break;

    case 9:
      // show tool table
      showTools();
      break;

    case 10:
      // show axis info
      showAxis();
      break;

    case 11:
      // show active g codes
      showCodes();
      break;

    default:
      // huh?
      printf("invalid request to show: %d\n", toPrint);
      break;
    }
}

static void printErrors()
{
  NMLTYPE type;

  if (0 == emcErrorBuffer ||
      ! emcErrorBuffer->valid())
    {
      return;
    }

  switch (type = emcErrorBuffer->read())
    {
    case 0:
      // nothing new
      break;

    case -1:
      // error reading channel
      break;

    case EMC_OPERATOR_ERROR_TYPE:
      printf("\nerror: [%d] %s\n",
             ((EMC_OPERATOR_ERROR *) (emcErrorBuffer->get_address()))->id,
             ((EMC_OPERATOR_ERROR *) (emcErrorBuffer->get_address()))->error);
      printPrompt = 1;
      break;

    case EMC_OPERATOR_TEXT_TYPE:
      printf("\ntext: [%d] %s\n",
             ((EMC_OPERATOR_TEXT *) (emcErrorBuffer->get_address()))->id,
             ((EMC_OPERATOR_TEXT *) (emcErrorBuffer->get_address()))->text);
      printPrompt = 1;
      break;

    case EMC_OPERATOR_DISPLAY_TYPE:
      printf("\ndisplay: [%d] %s\n",
             ((EMC_OPERATOR_DISPLAY *) (emcErrorBuffer->get_address()))->id,
             ((EMC_OPERATOR_DISPLAY *) (emcErrorBuffer->get_address()))->display);
      printPrompt = 1;
      break;

    case NML_ERROR_TYPE:
      printf("\nerror: %s\n",
             ((NML_ERROR *) (emcErrorBuffer->get_address()))->error);
      printPrompt = 1;
      break;

    case NML_TEXT_TYPE:
      printf("\ntext: %s\n",
             ((NML_TEXT *) (emcErrorBuffer->get_address()))->text);
      printPrompt = 1;
      break;

    case NML_DISPLAY_TYPE:
      printf("\ndisplay: %s\n",
             ((NML_DISPLAY *) (emcErrorBuffer->get_address()))->display);
      printPrompt = 1;
      break;

    default:
      // unrecognized message
      printf("\nunrecognized message in error channel:  %ld\n", type);
      printPrompt = 1;
      break;
    }
}

// fill in the current status
static int updateStatus()
{
  int r1 = 0, r2 = 0;
  NMLTYPE type;

  // update EMC TASK
  if (0 == emcStatus)
    {
      // not connected
      r1 = -1;
    }
  else
    {
      switch (type = emcStatusBuffer->peek())
        {
        case -1:
          // error on CMS channel
          printf("error reading emcStatus channel\n");
          r1 = -1;
          break;

        case 0:                 // no new data
        case EMC_STAT_TYPE:     // new data
          // new data
          // get command serial number
          emcCommandSerialNumber = emcStatus->echo_serial_number;
          break;

        default:
          printf("bad id in emcStatusBuffer: %ld\n", type);
          r1 = -1;
          break;
        }
    }

  // update EMCIO
  if (0 == emcIoStatus)
    {
      // not connected
      r2 = -1;
    }
  else
    {
      switch (type = emcIoStatusBuffer->peek())
        {
        case -1:
          // error on CMS channel
          printf("error reading emcioStatus channel\n");
          r2 = -1;
          break;

        case 0:                 // no new data
        case EMC_IO_STAT_TYPE:  // new data
          // new data
          // get command serial number
          emcIoCommandSerialNumber = emcIoStatus->echo_serial_number;
          break;

        default:
          printf("bad id in emcIoStatusBuffer: %ld\n", type);
          r2 = -1;
          break;
        }
    }

  return (r1 != 0 ||
          r2 != 0) ? -1 : 0;
}

/*
  waits until the EMC reports that it's got the command with the
  indicated serial_number. Sleeps between queries.
*/

#define EMC_COMMAND_TIMEOUT 1.0 // how long to wait until timeout
#define EMC_COMMAND_DELAY   0.1 // how long to sleep between checks

static int emcCommandWait(int serial_number)
{
  double start = etime();

  while (etime() - start < EMC_COMMAND_TIMEOUT)
    {
      updateStatus();

      if (emcStatus->echo_serial_number == serial_number)
        {
          return 0;
        }

      esleep(EMC_COMMAND_DELAY);
    }

  rcs_print_error("timeout sending command\n");

  return -1;
}

static enum {
  SELECT_NONE = 1,
  SELECT_EMC_TASK,
  SELECT_EMC_IO
} which = SELECT_NONE;

static int iniLoad(const char *filename)
{
  INIFILE inifile;
  const char *inistring;

  // open it
  if (-1 == inifile.open(filename)) {
    return -1;
  }

  if (NULL != (inistring = inifile.find("NML_FILE", "EMC"))) {
    // copy to global
    strcpy(EMC_NMLFILE, inistring);
  }
  else {
    // not found, use default
  }

  // close it
  inifile.close();

  return 0;
}

int main(int argc, char *argv[])
{
  char input[INPUTLEN];
  char cmd[INPUTLEN];
  int nchars;                   // how many read from getinput()
  double delay;                 // secs until next read
  int done;
  int lastPrint = 0;            // flag for which status subset to print
  int inhibitPrompt = 0;        // flag for inhibiting prompt printing
  int valid;
  int t;
  int catchErrors = 1;          // flag for reading error buffer

  // messages sent out
  EMC_AXIS_SET_FERROR emc_axis_set_ferror_msg;
  EMC_AXIS_SET_MIN_FERROR emc_axis_set_min_ferror_msg;
  EMC_AXIS_JOG emc_axis_jog_msg;
  EMC_AXIS_INCR_JOG emc_axis_incr_jog_msg;
  EMC_AXIS_ABS_JOG emc_axis_abs_jog_msg;
  EMC_AXIS_HOME emc_axis_home_msg;
  EMC_AXIS_ABORT emc_axis_abort_msg;
  EMC_AXIS_SET_OUTPUT emc_axis_set_output_msg;
  EMC_TRAJ_SET_SCALE emc_traj_set_scale_msg;
  EMC_TRAJ_ABORT emc_traj_abort_msg;
  EMC_TASK_SET_MODE mode_msg;
  EMC_TASK_SET_STATE state_msg;
  EMC_TASK_ABORT task_abort_msg;
  EMC_TASK_PLAN_OPEN task_plan_open_msg;
  EMC_TASK_PLAN_RUN task_plan_run_msg;
  EMC_TASK_PLAN_EXECUTE task_plan_execute_msg;
  EMC_TASK_PLAN_PAUSE task_plan_pause_msg;
  EMC_TASK_PLAN_RESUME task_plan_resume_msg;
  EMC_TOOL_INIT emc_tool_init_msg;
  EMC_TOOL_HALT emc_tool_halt_msg;
  EMC_TOOL_PREPARE emc_tool_prepare_msg;
  EMC_TOOL_LOAD emc_tool_load_msg;
  EMC_TOOL_UNLOAD emc_tool_unload_msg;
  EMC_TOOL_LOAD_TOOL_TABLE emc_tool_load_tool_table_msg;
  EMC_SPINDLE_ON emc_spindle_on_msg;
  EMC_SPINDLE_OFF emc_spindle_off_msg;
  EMC_SPINDLE_INCREASE emc_spindle_increase_msg;
  EMC_SPINDLE_DECREASE emc_spindle_decrease_msg;
  EMC_SPINDLE_CONSTANT emc_spindle_constant_msg;
  EMC_SPINDLE_BRAKE_RELEASE emc_spindle_brake_release_msg;
  EMC_SPINDLE_BRAKE_ENGAGE emc_spindle_brake_engage_msg;
  EMC_COOLANT_MIST_ON emc_coolant_mist_on_msg;
  EMC_COOLANT_MIST_OFF emc_coolant_mist_off_msg;
  EMC_COOLANT_FLOOD_ON emc_coolant_flood_on_msg;
  EMC_COOLANT_FLOOD_OFF emc_coolant_flood_off_msg;
  EMC_AUX_DIO_WRITE emc_aux_dio_write_msg;
  EMC_AUX_AIO_WRITE emc_aux_aio_write_msg;
  EMC_AUX_ESTOP_ON emc_aux_estop_on_msg;
  EMC_AUX_ESTOP_OFF emc_aux_estop_off_msg;
  EMC_LOG_OPEN emc_log_open_msg;
  EMC_LOG_START emc_log_start_msg;
  EMC_LOG_STOP emc_log_stop_msg;
  EMC_LOG_CLOSE emc_log_close_msg;

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

  // process usual command line args
  if (0 != emcGetArgs(argc, argv)) {
    rcs_print_error("error in argument list\n");
    exit(1);
  }

  // process our command line args
  for (t = 1; t < argc; t++)
    {
      // try -noerror
      if (!strcmp(argv[t], "-noerror"))
        {
          catchErrors = 0;
          continue;
        }
    }

  // initialize globals
  emcInitGlobals();

  // get configuration information
  iniLoad(EMC_INIFILE);

  // init NML
  emcErrorNmlGet();
  if (0 == emcIoNmlGet())
    {
      which = SELECT_EMC_IO;
      lastPrint = 8;
    }
  if (0 == emcTaskNmlGet())
    {
      which = SELECT_EMC_TASK;
      lastPrint = 0;
    }

  // loop on input
  done = 0;
  printPrompt = 1;
  while (! feof(stdin) &&
         ! done)
    {
      // print errors
      if (catchErrors)
        {
          printErrors();
        }

      // update status
      updateStatus();

      // check if we need to print a prompt
      if (printPrompt)
        {
          if (! inhibitPrompt)
            {
              if (which == SELECT_EMC_TASK)
                {
                  printf("emctask> ");
                }
              else if (which == SELECT_EMC_IO)
                {
                  printf("emcio> ");
                }
              else
                {
                  printf("none> ");
                }
              fflush(stdout);
            }
          printPrompt = 0;
        }

      // get the next input line
      nchars = getinput(input, INPUTLEN);
      if (nchars > 0)
        {
          // got some input-- flag that we'll need to print prompt again
          printPrompt = 1;
        }
      else if (nchars == -1)
        {
          // no new input-- cycle and try again
          esleep(SLEEP_SECS);
          continue;             // the while(!feof(stdin)) loop
        }
      else
        {
          // nchars == 0, it's EOF
          done = 1;
          break;
        }

      // got input-- process it

      // read first arg in
      cmd[0] = 0;
      sscanf(input, "%s", cmd);

      // match it in the big if loop
      // first handle commands for any selected controller
      // then handle emctask, emcio

      // commands for any controller
      if (! strcmp(cmd, "help") ||
          ! strcmp(cmd, "?"))
        {
          printf("? or help           -- print help\n");
          printf("delay <secs>        -- delay reading next line\n");
          printf("< or >              -- turn prompt off or on\n");
          printf(";                   -- comment follows\n");
          printf("quit                -- quit\n");
          printf("show {params} {state} {mode} {pos} -- show status\n");
          printf("emctask | emcio          -- select emctask or emcio\n");

          switch (which)
            {
            case SELECT_EMC_TASK:
              printf("estop on | off      -- go into/out of estop\n");
              printf("machine on | off    -- enable/disable control\n");
              printf("mode manual | auto | mdi -- set program mode\n");
              printf("axis x | y | z      -- select axis\n");
              printf("speed <pos value>   -- set jog speed\n");
              printf("abs | rel           -- set display to abs or rel\n");
              printf("cont                -- set continuous jog mode\n");
              printf("incr {<pos value>}  -- set incremental jog mode\n");
              printf("jog {<abs> | + | -} -- jog absolute, or +/- in cont/incr\n");
              printf("home                -- home selected axis\n");
              printf("a                   -- abort everything\n");
              printf("/                   -- abort selected axis\n");
              printf("//                  -- abort traj\n");
              printf("feed <0.100>        -- set feed override\n");
              printf("open <prog name>    -- open NC program\n");
              printf("run                 -- run opened NC program\n");
              printf("mdi <NC statement>  -- send manual data input\n");
              printf("pause               -- pause motion\n");
              printf("resume              -- resume motion\n");
              printf("tools {<file>}      -- load tool file\n");
              printf("brake on | off      -- turn spindle brake on or off\n");
              printf("maxfe <axis> <value>  -- set axis following error\n");
              printf("minfe <axis> <value>  -- set axis following error\n");
              printf("out <axis> <value>  -- set axis output\n");
              break;

            case SELECT_EMC_IO:
              printf("init                -- initialize emcio\n");
              printf("halt                -- reset emcio\n");
              printf("dout <bit> 0 | 1    -- set digital out point\n");
              printf("aout <bit> <volts>  -- set analog out point\n");
              printf("estop on | off      -- go into/out of estop\n");
              printf("prep <tool>         -- prepare tool for loading\n");
              printf("load                -- load prepped tool\n");
              printf("unload              -- unload tool\n");
              printf("spindle <rpm> | off -- set spindle speed\n");
              printf("incr                -- increase spindle speed\n");
              printf("decr                -- decrease spindle speed\n");
              printf("brake on | off      -- turn spindle brake on or off\n");
              printf("mist on | off       -- mist coolant\n");
              printf("flood on | off      -- flood coolant\n");
              break;

            default:
              // nothing selected
              break;
            }
        }
      else if (! strcmp(cmd, "quit"))
        {
          done = 1;
        }
      else if (! strcmp(cmd, "<"))
        {
          inhibitPrompt = 1;
        }
      else if (! strcmp(cmd, ">"))
        {
          inhibitPrompt = 0;
        }
      else if (! strcmp(cmd, ";"))
        {
          // comment-- ignore
        }
      else if (! strcmp(cmd, "delay"))
        {
          if (1 == sscanf(input, "%*s %lf", &delay))
            {
              esleep((unsigned int) (delay * 1000000.0));
            }
          else
            {
              printf("syntax: delay <secs>\n");
            }
        }
      else if (! strcmp(cmd, "show"))
        {
          if (1 == sscanf(input, "%*s %s", cmd))
            {
              if (! strcmp(cmd, "state"))
                {
                  lastPrint = 1;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "mode"))
                {
                  lastPrint = 2;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "pos"))
                {
                  lastPrint = 3;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "params"))
                {
                  lastPrint = 4;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "program"))
                {
                  lastPrint = 5;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "exec"))
                {
                  lastPrint = 6;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "emcio"))
                {
                  lastPrint = 8;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "tools"))
                {
                  lastPrint = 9;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "axis"))
                {
                  lastPrint = 10;
                  emcpanelShow(lastPrint);
                }
              else if (! strcmp(cmd, "codes"))
                {
                  lastPrint = 11;
                  emcpanelShow(lastPrint);
                }
              else
                {
                  // invalid parameter
                  printf("syntax: show {state} {mode} {pos} {params} {program} {exec} {emcio} {tools} {axis} {codes}\n");
                }
            }
          else
            {
              // blank "show" typed
              if (which == SELECT_EMC_TASK)
                {
                  lastPrint = 0;
                }
              else if (which == SELECT_EMC_IO)
                {
                  lastPrint = 8;
                }

              emcpanelShow(lastPrint);
            }
        }
      else if (!strcmp(cmd, "emctask"))
        {
          if (0 == emcTaskNmlGet())
            {
              which = SELECT_EMC_TASK;
              lastPrint = 0;
            }
        }
      else if (!strcmp(cmd, "emcio"))
        {
          if (0 == emcIoNmlGet())
            {
              which = SELECT_EMC_IO;
              lastPrint = 8;
            }
        } // end of general matches; now handle controller specific ones
      else if (which == SELECT_EMC_TASK)
        {
          if (!strcmp(cmd, "estop"))
            {
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  valid = 1;
                  if (!strcmp(cmd, "off"))
                    {
                      // come out of estop
                      state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
                      state_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(state_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      // go into estop
                      state_msg.state = EMC_TASK_STATE_ESTOP;
                      state_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(state_msg);
                    }
                }
              if (!valid)
                {
                  printf("syntax: estop off | on\n");
                }
            }
          else if (!strcmp(cmd, "machine"))
            {
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  valid = 1;
                  if (!strcmp(cmd, "off"))
                    {
                      // turn it off
                      state_msg.state = EMC_TASK_STATE_OFF;
                      state_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(state_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      // turn the machine on
                      state_msg.state = EMC_TASK_STATE_ON;
                      state_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(state_msg);
                    }
                }
              if (!valid)
                {
                  printf("syntax: machine on | off\n");
                }
            }
          else if (!strcmp(cmd, "mode"))
            {
              // a request to change mode
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "auto"))
                    {
                      mode_msg.mode = EMC_TASK_MODE_AUTO;
                      mode_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(mode_msg);
                      valid = 1;
                    }
                  else if (!strcmp(cmd, "mdi"))
                    {
                      mode_msg.mode = EMC_TASK_MODE_MDI;
                      mode_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(mode_msg);
                      valid = 1;
                    }
                  else if (!strcmp(cmd, "manual"))
                    {
                      mode_msg.mode = EMC_TASK_MODE_MANUAL;
                      mode_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(mode_msg);
                      valid = 1;
                    }
                  else
                    {
                      valid = 0;
                    }
                }
              if (!valid)
                {
                  printf("syntax: mode auto | mdi | manual\n");
                }
            }
          else if (!strcmp(cmd, "axis"))
            {
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "x"))
                    {
                      valid = 1;
                      axisSelect = AXIS_X;
                    }
                  else if (!strcmp(cmd, "y"))
                    {
                      valid = 1;
                      axisSelect = AXIS_Y;
                    }
                  else if (!strcmp(cmd, "z"))
                    {
                      valid = 1;
                      axisSelect = AXIS_Z;
                    }
                }
              if (!valid)
                {
                  printf("syntax: axis x | y | z\n");
                }
            }
          else if (!strcmp(cmd, "speed"))
            {
              double speed;
              valid = 0;
              if (1 == sscanf(input, "%*s %lf", &speed) &&
                  speed > 0.0)
                {
                  speedSelect = speed;
                  valid = 1;
                }
              if (!valid)
                {
                  printf("syntax: speed <pos value>\n");
                }
            }
          else if (!strcmp(cmd, "abs"))
            {
              displayMode = DISPLAY_ABS;
            }
          else if (!strcmp(cmd, "rel"))
            {
              displayMode = DISPLAY_REL;
            }
          else if (!strcmp(cmd, "cont"))
            {
              jogSelect = JOG_CONT;
            }
          else if (!strcmp(cmd, "incr"))
            {
              double incr;
              valid = 0;
              // check for optional incr arg
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (1 == sscanf(cmd, "%lf", &incr) &&
                      incr > 0.0)
                    {
                      jogIncr = incr;
                      jogSelect = JOG_INCR;
                      valid = 1;
                    }
                  else
                    {
                      // arg there, but invalid
                      valid = 0;
                    }
                }
              else
                {
                  // no arg
                  jogSelect = JOG_INCR;
                  valid = 1;
                }
              if (!valid)
                {
                  printf("syntax: axis x | y | z\n");
                }
            }
          else if (!strcmp(cmd, "jog"))
            {
              valid = 0;
              // we can have "jog <abs> | + | -"
              // check for arg there first
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  // there's an arg there
                  // check for abs value
                  if (1 == sscanf(cmd, "%lf", &emc_axis_abs_jog_msg.pos))
                    {
                      // got an abs jog value
                      emc_axis_abs_jog_msg.serial_number = ++emcCommandSerialNumber;
                      emc_axis_abs_jog_msg.axis = axisSelect;
                      emc_axis_abs_jog_msg.vel = speedSelect;
                      emcCommandBuffer->write(emc_axis_abs_jog_msg);
                      valid = 1;
                    }
                  // else check for +
                  else if (cmd[0] == '+')
                    {
                      // check for cont or incr jog
                      if (JOG_CONT == jogSelect)
                        {
                          emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                          emc_axis_jog_msg.axis = axisSelect;
                          emc_axis_jog_msg.vel = speedSelect;
                          emcCommandBuffer->write(emc_axis_jog_msg);
                          valid = 1;
                        }
                      else if (JOG_INCR == jogSelect)
                        {
                          emc_axis_incr_jog_msg.serial_number =
                            ++emcCommandSerialNumber;
                          emc_axis_incr_jog_msg.axis = axisSelect;
                          emc_axis_incr_jog_msg.vel = speedSelect;
                          emc_axis_incr_jog_msg.incr = jogIncr;
                          emcCommandBuffer->write(emc_axis_incr_jog_msg);
                          valid = 1;
                        }
                      else
                        {
                          // coding error
                          printf("bad value for jog select: %d\n", jogSelect);
                          valid = 1; // suppress syntax error, since it's not
                        }
                    }
                  // else check for -
                  else if (cmd[0] == '-')
                    {
                      // check for cont or incr jog
                      if (JOG_CONT == jogSelect)
                        {
                          emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                          emc_axis_jog_msg.axis = axisSelect;
                          emc_axis_jog_msg.vel = - speedSelect;
                          emcCommandBuffer->write(emc_axis_jog_msg);
                          valid = 1;
                        }
                      else if (JOG_INCR == jogSelect)
                        {
                          emc_axis_incr_jog_msg.serial_number =
                            ++emcCommandSerialNumber;
                          emc_axis_incr_jog_msg.axis = axisSelect;
                          emc_axis_incr_jog_msg.vel = - speedSelect;
                          emc_axis_incr_jog_msg.incr = jogIncr;
                          emcCommandBuffer->write(emc_axis_incr_jog_msg);
                          valid = 1;
                        }
                      else
                        {
                          // coding error
                          printf("bad value for jog select: %d\n", jogSelect);
                          valid = 1; // suppress syntax error, since it's not
                        }
                    }
                  else
                    {
                      // bad arg
                      valid = 0;
                    }
                }
              else
                {
                  // no arg there at all
                  valid = 0;
                }
              if (!valid)
                {
                  printf("syntax: jog <abs> | + | -\n");
                }
            }
          else if (!strcmp(cmd, "home"))
            {
              emc_axis_home_msg.serial_number = ++emcCommandSerialNumber;
              emc_axis_home_msg.axis = axisSelect;
              emcCommandBuffer->write(emc_axis_home_msg);
            }
          else if (!strcmp(cmd, "a"))
            {
              // do a task abort (abort everything)
              task_abort_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(task_abort_msg);
            }
          else if (!strcmp(cmd, "/"))
            {
              // do an axis abort
              emc_axis_abort_msg.serial_number = ++emcCommandSerialNumber;
              emc_axis_abort_msg.axis = axisSelect;
              emcCommandBuffer->write(emc_axis_abort_msg);
            }
          else if (!strcmp(cmd, "//"))
            {
              // do a traj abort
              emc_traj_abort_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(emc_traj_abort_msg);
            }
          else if (!strcmp(cmd, "feed"))
            {
              int valid = 0;
              if (1 == sscanf(input, "%*s %lf", &emc_traj_set_scale_msg.scale))
                {
                  valid = 1;
                  emc_traj_set_scale_msg.scale = emc_traj_set_scale_msg.scale / 100.0; // turn percent into a fraction
                  emc_traj_set_scale_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_traj_set_scale_msg);
                }
              if (! valid)
                {
                  printf("syntax: feed <0..100>\n");
                }
            }
          else if (!strcmp(cmd, "open"))
            {
              int valid = 0;
              if (1 == sscanf(input, "%*s %s", task_plan_open_msg.file))
                {
                  valid = 1;
                  task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(task_plan_open_msg);
                  strcpy(programFile, task_plan_open_msg.file);
                  programOpened = 1;
                  if (programFp != 0)
                    {
                      fclose(programFp);
                    }
                  programFp = fopen(programFile, "r");
                  programLineText[0] = 0;
                  programFpLine = 0;
                }
              if (! valid)
                {
                  printf("syntax: open <part program>\n");
                }
            }
          else if (!strcmp(cmd, "run"))
            {
              if (! programOpened)
                {
                  // send a request to open the last one
                  strcpy(task_plan_open_msg.file, programFile);
                  task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(task_plan_open_msg);
                  emcCommandWait(task_plan_open_msg.serial_number);
                }
              task_plan_run_msg.serial_number = ++emcCommandSerialNumber;
              task_plan_run_msg.line = 0;
              emcCommandBuffer->write(task_plan_run_msg);
              programOpened = 0;
            }
          else if (!strcmp(cmd, "mdi"))
            {
              int valid = 0;
              // check for at least one thing on the line
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  valid = 1;
                  // copy rest of line after "mdi "
                  strcpy(task_plan_execute_msg.command, &input[4]);
                  task_plan_execute_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(task_plan_execute_msg);
                }
              if (! valid)
                {
                  printf("syntax: mdi <NC statement>\n");
                }
            }
          else if (!strcmp(cmd, "pause"))
            {
              task_plan_pause_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(task_plan_pause_msg);
            }
          else if (!strcmp(cmd, "resume"))
            {
              task_plan_resume_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(task_plan_resume_msg);
            }
          else if (!strcmp(cmd, "tools"))
            {
              // get tool file, if provided
              if (1 != sscanf(input, "%*s %s", emc_tool_load_tool_table_msg.file))
                {
                  emc_tool_load_tool_table_msg.file[0] = 0;
                }
              emc_tool_load_tool_table_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(emc_tool_load_tool_table_msg);
            }
          else if (!strcmp(cmd, "brake"))
            {
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  valid = 1;
                  if (!strcmp(cmd, "off"))
                    {
                      // take brake off
                      emc_spindle_brake_release_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(emc_spindle_brake_release_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      // go into estop
                      emc_spindle_brake_engage_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(emc_spindle_brake_engage_msg);
                    }
                }
              if (!valid)
                {
                  printf("syntax: brake off | on\n");
                }
            }
          else if (!strcmp(cmd, "maxfe"))
            {
              int valid = 0;
              if (2 == sscanf(input, "%*s %d %lf",
                              &emc_axis_set_ferror_msg.axis,
                              &emc_axis_set_ferror_msg.ferror))
                {
                  valid = 1;
                  emc_axis_set_ferror_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_axis_set_ferror_msg);
                }
              if (! valid)
                {
                  printf("syntax: maxfe <axis> <ferror>\n");
                }
            }
          else if (!strcmp(cmd, "minfe"))
            {
              int valid = 0;
              if (2 == sscanf(input, "%*s %d %lf",
                              &emc_axis_set_min_ferror_msg.axis,
                              &emc_axis_set_min_ferror_msg.ferror))
                {
                  valid = 1;
                  emc_axis_set_min_ferror_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_axis_set_min_ferror_msg);
                }
              if (! valid)
                {
                  printf("syntax: minfe <axis> <ferror>\n");
                }
            }
          else if (!strcmp(cmd, "out"))
            {
              int valid = 0;
              if (2 == sscanf(input, "%*s %d %lf",
                              &emc_axis_set_output_msg.axis,
                              &emc_axis_set_output_msg.output))
                {
                  valid = 1;
                  emc_axis_set_output_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_axis_set_output_msg);
                }
              if (! valid)
                {
                  printf("syntax: minfe <axis> <ferror>\n");
                }
            }
          else if (!strcmp(cmd, "log"))
            {
              valid = 0;
              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "open"))
                    {
                      valid = 1;
                      if (1 == sscanf(input, "%*s %*s %s", saveLogFile))
                        {
                          strcpy(emc_log_open_msg.file, saveLogFile);
                          emc_log_open_msg.type = saveLogType;
                          emc_log_open_msg.size = saveLogSize;
                          emc_log_open_msg.skip = saveLogSkip;
                          emc_log_open_msg.which = saveLogAxis;
                          emc_log_open_msg.serial_number = ++emcCommandSerialNumber;
                          emcCommandBuffer->write(emc_log_open_msg);
                          emcCommandWait(emcCommandSerialNumber);
                        }
                    }
                  else if (!strcmp(cmd, "start"))
                    {
                      valid = 1;
                      // check for open log file first; if not, and old one saved,
                      // open old one
                      if (! emcStatus->logOpen)
                        {
                          if (saveLogFile[0] != 0)
                            {
                              strcpy(emc_log_open_msg.file, saveLogFile);
                              emc_log_open_msg.type = saveLogType;
                              emc_log_open_msg.size = saveLogSize;
                              emc_log_open_msg.skip = saveLogSkip;
                              emc_log_open_msg.which = saveLogAxis;
                              emc_log_open_msg.serial_number = ++emcCommandSerialNumber;
                              emcCommandBuffer->write(emc_log_open_msg);
                              emcCommandWait(emcCommandSerialNumber);
                            }
                          else
                            {
                              // log is not opened, and no name saved, so ignore
                              break;
                            }
                        }

                      emc_log_start_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(emc_log_start_msg);
                      emcCommandWait(emcCommandSerialNumber);
                    }
                  else if (!strcmp(cmd, "stop"))
                    {
                      valid = 1;
                      emc_log_stop_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(emc_log_stop_msg);
                      emcCommandWait(emcCommandSerialNumber);
                    }
                  else if (!strcmp(cmd, "save"))
                    {
                      valid = 1;
                      emc_log_close_msg.serial_number = ++emcCommandSerialNumber;
                      emcCommandBuffer->write(emc_log_close_msg);
                      emcCommandWait(emcCommandSerialNumber);
                    }
                  else if (!strcmp(cmd, "plot"))
                    {
                      valid = 1;
                      if (0 != plotLog(saveLogFile, saveLogType, saveLogAxis))
                        {
                          printf("can't print log-- check log file manually");
                        }
                    }
                }
              if (!valid)
                {
                  printf("syntax: log open <file> | start | stop | save | plot\n");
                }
            }
          else if (anyprintable(input))
            {
              printf("?\n");
            }
          else
            {
              // blank line was typed
              emcpanelShow(lastPrint);
            }
        } // if (which == SELECT_EMC_TASK)
      else                      // default matches SELECT_EMC_IO
        {
          if (!strcmp(cmd, "init"))
            {
              emc_tool_init_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_tool_init_msg);
            }
          else if (!strcmp(cmd, "halt"))
            {
              emc_tool_halt_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_tool_halt_msg);
            }
          else if (!strcmp(cmd, "dout"))
            {
              valid = 0;

              if (2 == sscanf(input, "%*s %d %d",
                              &emc_aux_dio_write_msg.index,
                              &emc_aux_dio_write_msg.value))
                {
                  valid = 1;
                  emc_aux_dio_write_msg.serial_number = ++emcIoCommandSerialNumber;
                  emcIoCommandBuffer->write(emc_aux_dio_write_msg);
                }

              if (!valid)
                {
                  printf("syntax: set <bit> 0 | 1\n");
                }
            }
          else if (!strcmp(cmd, "aout"))
            {
              valid = 0;

              if (2 == sscanf(input, "%*s %d %lf",
                              &emc_aux_aio_write_msg.index,
                              &emc_aux_aio_write_msg.value))
                {
                  valid = 1;
                  emc_aux_aio_write_msg.serial_number = ++emcIoCommandSerialNumber;
                  emcIoCommandBuffer->write(emc_aux_aio_write_msg);
                }

              if (!valid)
                {
                  printf("syntax: set <bit> 0 | 1\n");
                }
            }
          else if (!strcmp(cmd, "prep"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %d",
                              &emc_tool_prepare_msg.tool))
                {
                  valid = 1;
                  emc_tool_prepare_msg.serial_number = ++emcIoCommandSerialNumber;
                  emcIoCommandBuffer->write(emc_tool_prepare_msg);
                }

              if (!valid)
                {
                  printf("syntax: prep <tool>\n");
                }
            }
          else if (!strcmp(cmd, "load"))
            {
              emc_tool_load_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_tool_load_msg);
            }
          else if (!strcmp(cmd, "unload"))
            {
              emc_tool_unload_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_tool_unload_msg);
            }
          else if (!strcmp(cmd, "spindle"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "off"))
                    {
                      valid = 1;
                      emc_spindle_off_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_spindle_off_msg);
                    }
                  else if (1 == sscanf(cmd, "%lf", &emc_spindle_on_msg.speed))
                    {
                      valid = 1;
                      emc_spindle_on_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_spindle_on_msg);
                    }
                }

              if (!valid)
                {
                  printf("syntax: spindle <rpm> | off\n");
                }
            }
          else if (!strcmp(cmd, "incr"))
            {
              emc_spindle_increase_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_spindle_increase_msg);
            }
          else if (!strcmp(cmd, "decr"))
            {
              emc_spindle_decrease_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_spindle_decrease_msg);
            }
          else if (!strcmp(cmd, "c"))
            {
              // make spindle constant
              emc_spindle_constant_msg.serial_number = ++emcIoCommandSerialNumber;
              emcIoCommandBuffer->write(emc_spindle_constant_msg);
            }
          else if (!strcmp(cmd, "brake"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "off"))
                    {
                      valid = 1;
                      emc_spindle_brake_release_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_spindle_brake_release_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      valid = 1;
                      emc_spindle_brake_engage_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_spindle_brake_engage_msg);
                    }
                }
              if (!valid)
                {
                  printf("syntax: brake on | off\n");
                }
            }
          else if (!strcmp(cmd, "estop"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "off"))
                    {
                      valid = 1;
                      emc_aux_estop_off_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_aux_estop_off_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      valid = 1;
                      emc_aux_estop_on_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_aux_estop_on_msg);
                    }
                }

              if (!valid)
                {
                  printf("syntax: estop off | on\n");
                }
            }
          else if (!strcmp(cmd, "mist"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "off"))
                    {
                      valid = 1;
                      emc_coolant_mist_off_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_coolant_mist_off_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      valid = 1;
                      emc_coolant_mist_on_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_coolant_mist_on_msg);
                    }
                }

              if (!valid)
                {
                  printf("syntax: mist on | off");
                }
            }
          else if (!strcmp(cmd, "flood"))
            {
              valid = 0;

              if (1 == sscanf(input, "%*s %s", cmd))
                {
                  if (!strcmp(cmd, "off"))
                    {
                      valid = 1;
                      emc_coolant_flood_off_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_coolant_flood_off_msg);
                    }
                  else if (!strcmp(cmd, "on"))
                    {
                      valid = 1;
                      emc_coolant_flood_on_msg.serial_number = ++emcIoCommandSerialNumber;
                      emcIoCommandBuffer->write(emc_coolant_flood_on_msg);
                    }
                }

              if (!valid)
                {
                  printf("syntax: flood on | off\n");
                }
            }
          else if (anyprintable(input))
            {
              printf("?\n");
            }
          else
            {
              // blank line was typed
              emcpanelShow(lastPrint);
            }
        } // end else which == SELECT_EMC_IO
    } // end of while stdin

  emcpanelQuit();

  exit(0);
}

---