emcrsh.cc

CNC 的开放码,EMC2 V2.2.8版

  switch (checkNoneAuto(s)) {
    case 0: emcUpdateType = EMC_UPDATE_NONE; break;
    case 1: emcUpdateType = EMC_UPDATE_AUTO; break;
    default: return rtStandardError;
    }
  return rtNoError;
}

static cmdResponseType setMode(char *s, connectionRecType *context)
{
  switch (checkManualAutoMDI(s)) {
    case 0: sendManual(); break;
    case 1: sendAuto(); break;
    case 2: sendMdi(); break;
    default: return rtStandardError;
    }
  return rtNoError;
}

static cmdResponseType setMist(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: sendMistOn(); break;
     case 1: sendMistOff();
     }
   return rtNoError;
}

static cmdResponseType setFlood(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: sendFloodOn(); break;
     case 1: sendFloodOff();
     }
   return rtNoError;
}

static cmdResponseType setLube(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: sendLubeOn(); break;
     case 1: sendLubeOff();
     }
   return rtNoError;
}

static cmdResponseType setSpindle(char *s, connectionRecType *context)
{
   switch (checkSpindleStr(s)) {
     case -1: return rtStandardError;
     case 0: sendSpindleForward(); break;
     case 1: sendSpindleReverse(); break;
     case 2: sendSpindleIncrease(); break;
     case 3: sendSpindleDecrease(); break;
     case 4: sendSpindleConstant(); break;
     case 5: sendSpindleOff();
     }
   return rtNoError;
}

static cmdResponseType setBrake(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: sendBrakeEngage(); break;
     case 1: sendBrakeRelease();
     }
   return rtNoError;
}

static cmdResponseType setLoadToolTable(char *s, connectionRecType *context)
{
  if (s == NULL) return rtStandardError;
  if (sendLoadToolTable(s) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setToolOffset(char *s, connectionRecType *context)
{
  int tool;
  float length, diameter;
  char *pch;
  
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%d", &tool) <=0) return rtStandardError;
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &length) <= 0) return rtStandardError;
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &diameter) <= 0) return rtStandardError;
  
  if (sendToolSetOffset(tool, length, diameter) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setOverrideLimits(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: if (sendOverrideLimits(0) != 0) return rtStandardError; break;
     case 1: if (sendOverrideLimits(-1) != 0) return rtStandardError;
     }
   return rtNoError;
}

static cmdResponseType setMDI(char *s, connectionRecType *context)
{
  char *pch;
  
  pch = strtok(NULL, "\n\r\0");
  if (sendMdiCmd(pch) !=0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setHome(char *s, connectionRecType *context)
{
  int axis;
  
  if (s == NULL) return rtStandardError;
  if (sscanf(s, "%d", &axis) <= 0) return rtStandardError;
  if ((axis < 0) || (axis > 5)) return rtStandardError;
  sendHome(axis);
  return rtNoError;
}

static cmdResponseType setJogStop(char *s, connectionRecType *context)
{
  int axis;
  
  if (s == NULL) return rtStandardError;
  if (sscanf(s, "%d", &axis) <= 0) return rtStandardError;
  if ((axis < 0) || (axis > 5)) return rtStandardError;
  if (sendJogStop(axis) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setJog(char *s, connectionRecType *context)
{
  int axis;
  float speed;
  char *pch;
  
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%d", &axis) <= 0) return rtStandardError;
  if ((axis < 0) || (axis > 5)) return rtStandardError;
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &speed) <= 0) return rtStandardError; 
  if (sendJogCont(axis, speed) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setFeedOverride(char *s, connectionRecType *context)
{
  int percent;
  
  if (s == NULL) return rtStandardError;
  if (sscanf(s, "%d", &percent) <= 0) return rtStandardError;
  sendFeedOverride(((double) percent) / 100.0);
  return rtNoError;
}

static cmdResponseType setJogIncr(char *s, connectionRecType *context)
{
  int axis;
  float speed, incr;
  char *pch;
  
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%d", &axis) <= 0) return rtStandardError;
  if ((axis < 0) || (axis > 5)) return rtStandardError;
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &speed) <= 0) return rtStandardError; 
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &incr) <= 0) return rtStandardError; 
  if (sendJogIncr(axis, speed, incr) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setTaskPlanInit(char *s, connectionRecType *context)
{
  if (sendTaskPlanInit() != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setOpen(char *s, connectionRecType *context)
{
  char *pch;
  char fileStr[80];
  
  pch = strtok(NULL, "\n\r\0");
  strcpy(context->progName, pch);
  if (pch == NULL) return rtStandardError;
  strcpy(fileStr, "../../nc_files/");
  strcat(fileStr, pch);
  if (sendProgramOpen(fileStr) != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setRun(char *s, connectionRecType *context)
{
  int lineNo;
  
  if (s == NULL) // run from beginning
    if (sendProgramRun(0) != 0) return rtStandardError;
    else ;
  else
    { // run from line number
      if (sscanf(s, "%d", &lineNo) <= 0) return rtStandardError;
      if (sendProgramRun(lineNo) != 0) return rtStandardError;
    }
  return rtNoError;
}

static cmdResponseType setPause(char *s, connectionRecType *context)
{
  if (sendProgramPause() != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setResume(char *s, connectionRecType *context)
{
  if (sendProgramResume() != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setStep(char *s, connectionRecType *context)
{
  if (sendProgramStep() != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setAbort(char *s, connectionRecType *context)
{
  if (sendAbort() != 0) return rtStandardError;
  return rtNoError;
}

static cmdResponseType setLinearUnitConversion(char *s, connectionRecType *context)
{
   switch (checkConversionStr(s)) {
     case -1: return rtStandardError;
     case 0: linearUnitConversion = LINEAR_UNITS_INCH; break;
     case 1: linearUnitConversion = LINEAR_UNITS_MM; break;
     case 2: linearUnitConversion = LINEAR_UNITS_CM; break;
     case 3: linearUnitConversion = LINEAR_UNITS_AUTO; break;
     case 4: linearUnitConversion = LINEAR_UNITS_CUSTOM; break;
     }
   return rtNoError;
}

static cmdResponseType setAngularUnitConversion(char *s, connectionRecType *context)
{
   switch (checkAngularConversionStr(s)) {
     case -1: return rtStandardError;
     case 0: angularUnitConversion = ANGULAR_UNITS_DEG; break;
     case 1: angularUnitConversion = ANGULAR_UNITS_RAD; break;
     case 2: angularUnitConversion = ANGULAR_UNITS_GRAD; break;
     case 3: angularUnitConversion = ANGULAR_UNITS_AUTO; break;
     case 4: angularUnitConversion = ANGULAR_UNITS_CUSTOM; break;
     }
   return rtNoError;
}

static cmdResponseType setTeleopEnable(char *s, connectionRecType *context)
{
   switch (checkOnOff(s)) {
     case -1: return rtStandardError;
     case 0: sendSetTeleopEnable(1); break;
     case 1: sendSetTeleopEnable(0);
     }
   return rtNoError;
}

static cmdResponseType setProbe(char *s, connectionRecType *context)
{
  float x, y, z;
  char *pch;
  
  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &x) <= 0) return rtStandardError;

  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &y) <= 0) return rtStandardError;

  pch = strtok(NULL, delims);
  if (pch == NULL) return rtStandardError;
  if (sscanf(pch, "%f", &z) <= 0) return rtStandardError;
  
  sendProbe(x, y, z);
  return rtNoError;
}

static cmdResponseType setProbeClear(char *s, connectionRecType *context)
{
  sendClearProbeTrippedFlag();
  return rtNoError;
}

static cmdResponseType setSpindleOverride(char *s, connectionRecType *context)
{
  int percent;

  sscanf(s, "%d", &percent);
  sendSpindleOverride(((double) percent) / 100.0);
  return rtNoError;
}

static cmdResponseType setOptionalStop(char *s, connectionRecType *context)
{
  int value;

  sscanf(s, "%d", &value);
  if (sendSetOptionalStop(value) != 0) return rtStandardError;
  return rtNoError;
}

int commandSet(connectionRecType *context)
{
  static char *setNakStr = "SET NAK\n\r";
  static char *setCmdNakStr = "SET %s NAK\n\r";
  static char *ackStr = "SET %s ACK\n\r";
  setCommandType cmd;
  char *pch;
  cmdResponseType ret = rtNoError;
  
  pch = strtok(NULL, delims);
  if (pch == NULL) {
    write(context->cliSock, setNakStr, strlen(setNakStr));
    return 0;
    }
  strupr(pch);
  cmd = lookupSetCommand(pch);
  if ((cmd >= scIniFile) && (context->cliSock != enabledConn)) {
    sprintf(context->outBuf, setCmdNakStr, pch);
    write(context->cliSock, context->outBuf, strlen(context->outBuf));
    return 0;
    }
  switch (cmd) {
    case scEcho: ret = setEcho(strtok(NULL, delims), context); break;
    case scVerbose: ret = setVerbose(strtok(NULL, delims), context); break;
    case scEnable: ret = setEnable(strtok(NULL, delims), context); break;
    case scConfig: ret = setConfig(strtok(NULL, delims), context); break;
    case scCommMode: ret = setCommMode(strtok(NULL, delims), context); break;
    case scCommProt: ret = setCommProt(strtok(NULL, delims), context); break;
    case scIniFile: break;
    case scPlat: break;
    case scIni: break;
    case scDebug: ret = setDebug(strtok(NULL, delims), context); break;
    case scSetWait: ret = setSetWait(strtok(NULL, delims), context); break;
    case scWait: ret = setWait(strtok(NULL, delims), context); break;
    case scSetTimeout: ret = setTimeout(strtok(NULL, delims), context); break;
    case scUpdate: ret = setUpdate(strtok(NULL, delims), context); break;
    case scError: ret = rtStandardError; break;
    case scOperatorDisplay: ret = rtStandardError; break;
    case scOperatorText: ret = rtStandardError; break;
    case scTime: ret = rtStandardError; break;
    case scEStop: ret = setEStop(strtok(NULL, delims), context); break;
    case scMachine: ret = setMachine(strtok(NULL, delims), context); break;
    case scMode: ret = setMode(strtok(NULL, delims), context); break;
    case scMist: ret = setMist(strtok(NULL, delims), context); break;
    case scFlood: ret = setFlood(strtok(NULL, delims), context); break;
    case scLube: ret = setLube(strtok(NULL, delims), context); break;
    case scLubeLevel: ret = rtStandardError; break;
    case scSpindle: ret = setSpindle(strtok(NULL, delims), context); break;
    case scBrake: ret = setBrake(strtok(NULL, delims), context); break;
    case scTool: ret = rtStandardError; break;
    case scToolOffset: ret = setToolOffset(pch, context); break;
    case scLoadToolTable: ret = setLoadToolTable(strtok(NULL, delims), context); break;
    case scHome: ret = setHome(strtok(NULL, delims), context); break;
    case scJogStop: ret = setJogStop(strtok(NULL, delims), context); break;
    case scJog: ret = setJog(pch, context); break;
    case scJogIncr: ret = setJogIncr(pch, context); break;
    case scFeedOverride: ret = setFeedOverride(strtok(NULL, delims), context); break;
    case scAbsCmdPos: ret = rtStandardError; break;
    case scAbsActPos: ret = rtStandardError; break;
    case scRelCmdPos: ret = rtStandardError; break;
    case scRelActPos: ret = rtStandardError; break;
    case scJointPos: ret = rtStandardError; break;
    case scPosOffset: ret = rtStandardError; break;
    case scJointLimit: ret = rtStandardError; break;
    case scJointFault: ret = rtStandardError; break;
    case scJointHomed: ret = rtStandardError; break;
    case scMDI: ret = setMDI(pch, context); break;
    case scTskPlanInit: ret = setTaskPlanInit(pch, context); break;
    case scOpen: ret = setOpen(pch, context); break;
    case scRun: ret = setRun(strtok(NULL, delims), context); break;
    case scPause: ret = setPause(pch, context); break;
    case scResume: ret = setResume(pch, context); break;
    case scAbort: ret = setAbort(pch, context); break;
    case scStep: ret = setStep(pch, context); break;    
    case scProgram:ret = rtStandardError; break;
    case scProgramLine: ret = rtStandardError; break;
    case scProgramStatus: ret = rtStandardError; break;
    case scProgramCodes: ret = rtStandardError; break;
    case scJointType: ret = rtStandardError; break;
    case scJointUnits: ret = rtStandardError; break;
    case scProgramUnits: 
    case scProgramLinearUnits: ret = rtStandardError; break;
    case scProgramAngularUnits: ret = rtStandardError; break;
    case scUserLinearUnits: ret = rtStandardError; break;
    case scUserAngularUnits: ret = rtStandardError; break;
    case scDisplayLinearUnits: ret = rtStandardError; break;
    case scDisplayAngularUnits: ret = rtStandardError; break;
    case scLinearUnitConversion: ret = setLinearUnitConversion(strtok(NULL, delims), context); break;
    case scAngularUnitConversion: ret = setAngularUnitConversion(strtok(NULL, delims), context); break;
    case scProbeClear: ret = setProbeClear(pch, context); break;
    case scProbeTripped: ret = rtStandardError; break;
    case scProbeValue: ret = rtStandardError; break;