emcrsh.cc

CNC 的开放码,EMC2 V2.2.8版

    case scProbe: ret = setProbe(pch, context); break;
    case scTeleopEnable: ret = setTeleopEnable(strtok(NULL, delims), context); break;
    case scKinematicsType: ret = rtStandardError; break;
    case scOverrideLimits: ret = setOverrideLimits(strtok(NULL, delims), context); break;
    case scSpindleOverride: ret = setSpindleOverride(strtok(NULL, delims), context); break;
    case scOptionalStop: ret = setOptionalStop(strtok(NULL, delims), context); break;
    case scUnknown: ret = rtStandardError;
    }
  switch (ret) {
    case rtNoError:  
      if (context->verbose) {
        sprintf(context->outBuf, ackStr, pch);
        write(context->cliSock, context->outBuf, strlen(context->outBuf));
        }
      break;
    case rtHandledNoError: // Custom ok response already handled, take no action
      break; 
    case rtStandardError:
      sprintf(context->outBuf, setCmdNakStr, pch);
      write(context->cliSock, context->outBuf, strlen(context->outBuf));
      break;
    case rtCustomError: // Custom error response entered in buffer
      write(context->cliSock, context->outBuf, strlen(context->outBuf));
      break;
    case rtCustomHandledError: ;// Custom error respose handled, take no action
    }
  return 0;
}

static cmdResponseType getEcho(char *s, connectionRecType *context)
{
  char *pEchoStr = "ECHO %s";
  
  if (context->echo) sprintf(context->outBuf, pEchoStr, "ON");
  else sprintf(context->outBuf, pEchoStr, "OFF");
  return rtNoError;
}

static cmdResponseType getVerbose(char *s, connectionRecType *context)
{
  char *pVerboseStr = "VERBOSE %s";
  
  if (context->verbose) sprintf(context->outBuf, pVerboseStr, "ON");
  else sprintf(context->outBuf, pVerboseStr, "OFF");
  return rtNoError;
}

static cmdResponseType getEnable(char *s, connectionRecType *context)
{
  char *pEnableStr = "ENABLE %s";
  
  if (context->cliSock == enabledConn) 
//  if (context->enabled == true)
    sprintf(context->outBuf, pEnableStr, "ON");
  else sprintf(context->outBuf, pEnableStr, "OFF");
  return rtNoError;
}

static cmdResponseType getConfig(char *s, connectionRecType *context)
{
  char *pConfigStr = "CONFIG";

  strcpy(context->outBuf, pConfigStr);
  return rtNoError;
}

static cmdResponseType getCommMode(char *s, connectionRecType *context)
{
  char *pCommModeStr = "COMM_MODE %s";
  
  switch (context->commMode) {
    case 0: sprintf(context->outBuf, pCommModeStr, "ASCII"); break;
    case 1: sprintf(context->outBuf, pCommModeStr, "BINARY"); break;
    }
  return rtNoError;
}

static cmdResponseType getCommProt(char *s, connectionRecType *context)
{
  char *pCommProtStr = "COMM_PROT %s";
  
  sprintf(context->outBuf, pCommProtStr, context->version);
  return rtNoError;
}

static cmdResponseType getDebug(char *s, connectionRecType *context)
{
  char *pUpdateStr = "DEBUG %d";
  
  sprintf(context->outBuf, pUpdateStr, emcStatus->debug);
  return rtNoError;
}

static cmdResponseType getSetWait(char *s, connectionRecType *context)
{
  char *pSetWaitStr = "SET_WAIT %s";
  
  switch (emcWaitType) {
    case EMC_WAIT_NONE: sprintf(context->outBuf, pSetWaitStr, "NONE"); break;
    case EMC_WAIT_RECEIVED: sprintf(context->outBuf, pSetWaitStr, "RECEIVED"); break;
    case EMC_WAIT_DONE: sprintf(context->outBuf, pSetWaitStr, "DONE"); break;
    default: return rtStandardError;
    }
  return rtNoError;
}

static cmdResponseType getPlat(char *s, connectionRecType *context)
{
  char *pPlatStr = "PLAT %s";
  
  sprintf(context->outBuf, pPlatStr, "Linux");
  return rtNoError;  
}

static cmdResponseType getEStop(char *s, connectionRecType *context)
{
  char *pEStopStr = "ESTOP %s";
  
  if (emcStatus->task.state == EMC_TASK_STATE_ESTOP)
    sprintf(context->outBuf, pEStopStr, "ON");
  else sprintf(context->outBuf, pEStopStr, "OFF");
  return rtNoError;
}

static cmdResponseType getTimeout(char *s, connectionRecType *context)
{
  char *pTimeoutStr = "SET_TIMEOUT %f";
  
  sprintf(context->outBuf, pTimeoutStr, emcTimeout);
  return rtNoError;
}

static cmdResponseType getTime(char *s, connectionRecType *context)
{
  char *pTimeStr = "TIME %f";
  
#if defined(LINUX_KERNEL_2_2)
  sprintf(context->outBuf, pTimeStr, 0.0);
#else  
  sprintf(context->outBuf, pTimeStr, etime());
#endif
  return rtNoError;
}

static cmdResponseType getError(char *s, connectionRecType *context)
{
  char *pErrorStr = "ERROR %s";
  
  if (updateError() != 0)
    sprintf(context->outBuf, pErrorStr, "emc_error: bad status from EMC");
  else
    if (error_string[0] == 0)
      sprintf(context->outBuf, pErrorStr, "OK");
    else {
      sprintf(context->outBuf, pErrorStr, error_string);
      error_string[0] = 0;
      }
  return rtNoError;
}

static cmdResponseType getOperatorDisplay(char *s, connectionRecType *context)
{
  char *pOperatorDisplayStr = "OPERATOR_DISPLAY %s";
  
  if (updateError() != 0)
    sprintf(context->outBuf, pOperatorDisplayStr, "emc_operator_display: bad status from EMC");
  else
    if (operator_display_string[0] == 0)
      sprintf(context->outBuf, pOperatorDisplayStr, "OK");
    else {
      sprintf(context->outBuf, pOperatorDisplayStr, operator_display_string);
      operator_display_string[0] = 0;
      }
  return rtNoError; 
}

static cmdResponseType getOperatorText(char *s, connectionRecType *context)
{
  char *pOperatorTextStr = "OPERATOR_TEXT %s";
  
  if (updateError() != 0)
    sprintf(context->outBuf, pOperatorTextStr, "emc_operator_text: bad status from EMC");
  else
    if (operator_text_string[0] == 0)
      sprintf(context->outBuf, pOperatorTextStr, "OK");
    else {
      sprintf(context->outBuf, pOperatorTextStr, operator_text_string);
      operator_text_string[0] = 0;
      }
  return rtNoError; 
}

static cmdResponseType getMachine(char *s, connectionRecType *context)
{
  char *pMachineStr = "MACHINE %s";
  
  if (emcStatus->task.state == EMC_TASK_STATE_ON)
    sprintf(context->outBuf, pMachineStr, "ON");
  else sprintf(context->outBuf, pMachineStr, "OFF");
  return rtNoError; 
}

static cmdResponseType getMode(char *s, connectionRecType *context)
{
  char *pModeStr = "MODE %s";
  
  switch (emcStatus->task.mode) {
    case EMC_TASK_MODE_MANUAL: sprintf(context->outBuf, pModeStr, "MANUAL"); break;
    case EMC_TASK_MODE_AUTO: sprintf(context->outBuf, pModeStr, "AUTO"); break;
    case EMC_TASK_MODE_MDI: sprintf(context->outBuf, pModeStr, "MDI"); break;
    default: sprintf(context->outBuf, pModeStr, "?");
    }
  return rtNoError; 
}

static cmdResponseType getMist(char *s, connectionRecType *context)
{
  char *pMistStr = "MIST %s";
  
  if (emcStatus->io.coolant.mist == 1)
    sprintf(context->outBuf, pMistStr, "ON");
  else sprintf(context->outBuf, pMistStr, "OFF");
  return rtNoError; 
}

static cmdResponseType getFlood(char *s, connectionRecType *context)
{
  char *pFloodStr = "FLOOD %s";
  
  if (emcStatus->io.coolant.flood == 1)
    sprintf(context->outBuf, pFloodStr, "ON");
  else sprintf(context->outBuf, pFloodStr, "OFF");
  return rtNoError; 
}

static cmdResponseType getLube(char *s, connectionRecType *context)
{
  char *pLubeStr = "LUBE %s";
  
  if (emcStatus->io.lube.on == 0)
    sprintf(context->outBuf, pLubeStr, "OFF");
  else sprintf(context->outBuf, pLubeStr, "ON");
  return rtNoError; 
}

static cmdResponseType getLubeLevel(char *s, connectionRecType *context)
{
  char *pLubeLevelStr = "LUBE_LEVEL %s";
  
  if (emcStatus->io.lube.level == 0)
    sprintf(context->outBuf, pLubeLevelStr, "LOW");
  else sprintf(context->outBuf, pLubeLevelStr, "OK");
  return rtNoError; 
}

static cmdResponseType getSpindle(char *s, connectionRecType *context)
{
  char *pSpindleStr = "SPINDLE %s";
  
  if (emcStatus->motion.spindle.increasing > 0)
    sprintf(context->outBuf, pSpindleStr, "INCREASE");
  else    
    if (emcStatus->motion.spindle.increasing < 0)
      sprintf(context->outBuf, pSpindleStr, "DECREASE");
    else 
      if (emcStatus->motion.spindle.direction > 0)
        sprintf(context->outBuf, pSpindleStr, "FORWARD");
      else
        if (emcStatus->motion.spindle.direction < 0)
          sprintf(context->outBuf, pSpindleStr, "REVERSE");
	else sprintf(context->outBuf, pSpindleStr, "OFF");
  return rtNoError; 
}

static cmdResponseType getBrake(char *s, connectionRecType *context)
{
  char *pBrakeStr = "BRAKE %s";
  
  if (emcStatus->motion.spindle.brake == 1)
    sprintf(context->outBuf, pBrakeStr, "ON");
  else sprintf(context->outBuf, pBrakeStr, "OFF");
  return rtNoError; 
}

static cmdResponseType getTool(char *s, connectionRecType *context)
{
  char *pToolStr = "TOOL %d";
  
  sprintf(context->outBuf, pToolStr, emcStatus->io.tool.toolInSpindle);
  return rtNoError; 
}

static cmdResponseType getToolOffset(char *s, connectionRecType *context)
{
  char *pToolOffsetStr = "TOOL_OFFSET %d";
  
  sprintf(context->outBuf, pToolOffsetStr, emcStatus->task.toolOffset.tran.z);
  return rtNoError; 
}

static cmdResponseType getAbsCmdPos(char *s, connectionRecType *context)
{
  char *pAbsCmdPosStr = "ABS_CMD_POS";
  char buf[16];
  int axis;
  
  if (s == NULL) axis = -1; // Return all axes
  else axis = atoi(s);
  strcpy(context->outBuf, pAbsCmdPosStr);
  if (axis != -1) {
    sprintf(buf, " %d", axis);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 0)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.x);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 1)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.y);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 2)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.z);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 3)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.a);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 4)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.b);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 5)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.c);
    strcat(context->outBuf, buf);
    }
  return rtNoError;
}

static cmdResponseType getAbsActPos(char *s, connectionRecType *context)
{
  char *pAbsActPosStr = "ABS_ACT_POS";
  char buf[16];
  int axis;
  
  if (s == NULL) axis = -1; // Return all axes
  else axis = atoi(s);
  strcpy(context->outBuf, pAbsActPosStr);
  if (axis != -1) {
    sprintf(buf, " %d", axis);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 0)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.tran.x);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 1)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.tran.y);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 2)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.tran.z);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 3)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.a);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 4)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.b);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 5)) {
    sprintf(buf, " %f", emcStatus->motion.traj.actualPosition.c);
    strcat(context->outBuf, buf);
    }
  return rtNoError;
}

static cmdResponseType getRelCmdPos(char *s, connectionRecType *context)
{
  char *pRelCmdPosStr = "REL_CMD_POS";
  char buf[16];
  int axis;
  
  if (s == NULL) axis = -1; // Return all axes
  else axis = atoi(s);
  strcpy(context->outBuf, pRelCmdPosStr);
  if (axis != -1) {
    sprintf(buf, " %d", axis);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 0)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.x - 
      emcStatus->task.origin.tran.x);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 1)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.y - 
      emcStatus->task.origin.tran.y);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 2)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.tran.z - 
      emcStatus->task.origin.tran.z);
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 3)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.a - 
      emcStatus->task.origin.a); // No rotational offsets
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 4)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.a - 
      emcStatus->task.origin.b); // No rotational offsets
    strcat(context->outBuf, buf);
    }
  if ((axis == -1) || (axis == 5)) {
    sprintf(buf, " %f", emcStatus->motion.traj.position.a -