xemc.cc

CNC 的开放码,EMC2 V2.2.8版

      break;
    }

    sawEol = 0;
    len = strlen(line);
    while (--len >= 0) {
      if (CR == line[len] ||
          LF == line[len]) {
        line[len] = 0;
        sawEol = 1;
      }
      else {
        break;
      }
    }

    if (fw->keepNextLine) {
      fwAddLine(fw, line);
      ++fw->fileFpLine;
    }

    fw->keepNextLine = sawEol;
  }

  return 0;
}

static int fwString(FILE_WINDOW *fw, char *string)
{
  int start;

  if (NULL == fw) {
    return -1;
  }

  start = fw->windowStart;
  string[0] = 0;

  if (0 == fw->windowCount) {
    return 0;
  }

  do {
    strncat(string, &(fw->fileWindow[start * fw->maxLineLen]),
            fw->maxLineLen - 2);
    strcat(string, "\n");
    if (++start >= fw->maxWindowLines) {
      start = 0;
    }
  } while (start != fw->windowEnd);

  return 0;
}

// the file window structure for the program window and related stuff

#define PROGRAM_FW_NUM_LINES 10
#define PROGRAM_FW_LEN_LINES 80

static char *programFwString = NULL;
static FILE_WINDOW programFw;

// number of axes supported
#define XEMC_NUM_AXES 3

// string for ini file version num
static char version_string[LINELEN] = "";

// interpreter parameter file name, from ini file
static char PARAMETER_FILE[LINELEN] = "";

// help file name, from ini file
static char HELP_FILE[LINELEN] = "";

// the program path prefix
static char programPrefix[LINELEN] = "";
// the program name currently displayed
static char programFile[LINELEN] = "*";
// the program last loaded by the controller
static char lastProgramFile[LINELEN] = "*";

// integer version of ini file max scale factor
static int maxFeedOverride = 100;

#define MDI_LINELEN 80
static char active_g_codes_string[MDI_LINELEN] = "";
static char active_m_codes_string[MDI_LINELEN] = "";

// how position is to be displayed-- relative or machine
typedef enum {
  COORD_RELATIVE = 1,
  COORD_MACHINE
} COORD_TYPE;

static COORD_TYPE coords = COORD_RELATIVE;

// how position is to be displayed-- actual or commanded
typedef enum {
  POS_DISPLAY_ACT = 1,
  POS_DISPLAY_CMD
} POS_DISPLAY_TYPE;

static POS_DISPLAY_TYPE posDisplay = POS_DISPLAY_ACT;

// marker for the active axis
static int activeAxis = 0;      // default is 0, X
static int oldActiveAxis = -1;  // force an update at startup

/*
  Note: the X key press/release events with multiple keys behave such that
  if key a is pressed, then b, then a released, its key-release event
  won't go through. So, multi-axis jogging has been disallowed in xemc,
  although it's supported in the motion system.
*/
// flag that an axis is jogging, so other jogs won't go out
static int axisJogging = -1;

// current jog speed setting
static int jogSpeed = 1;        // overridden in iniLoad()
static int maxJogSpeed = 1;     // overridden in iniLoad()
static int jogSpeedChange = 0;  // 0 means no change, +/- means inc/dec

// current jog increment setting, non-positive means continuous
static double jogIncrement = 0.0;

// the size of the smallest increment to jog, = 1/INPUT_SCALE
static double stepIncrement = 0.0001;

// polarities for axis jogging, from ini file
static int jogPol[XEMC_NUM_AXES];

static int oldFeedOverride = -1; // forces an update at startup
static int feedOverride;        // 100% integer copy of EMC status
static int feedOverrideChange = 0; // same as jogSpeedChange
#define FEED_OVERRIDE_DELAY_COUNT 1
// timer delays until dec/inc appears
static int feedOverrideDelayCount = FEED_OVERRIDE_DELAY_COUNT;

// command sending functions

static int sendEstop()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ESTOP;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendEstopReset()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendMachineOn()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_ON;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendMachineOff()
{
  EMC_TASK_SET_STATE state_msg;

  state_msg.state = EMC_TASK_STATE_OFF;
  state_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(state_msg);

  return 0;
}

static int sendManual()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_MANUAL;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendAuto()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_AUTO;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendMdi()
{
  EMC_TASK_SET_MODE mode_msg;

  mode_msg.mode = EMC_TASK_MODE_MDI;
  mode_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(mode_msg);

  return 0;
}

static int sendToolSetOffset(int tool, double length, double diameter)
{
  EMC_TOOL_SET_OFFSET emc_tool_set_offset_msg;

  emc_tool_set_offset_msg.tool = tool;
  emc_tool_set_offset_msg.length = length;
  emc_tool_set_offset_msg.diameter = diameter;
  emc_tool_set_offset_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_tool_set_offset_msg);

  return 0;
}

static int sendMistOn()
{
  EMC_COOLANT_MIST_ON emc_coolant_mist_on_msg;

  emc_coolant_mist_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_mist_on_msg);

  return 0;
}

static int sendMistOff()
{
  EMC_COOLANT_MIST_OFF emc_coolant_mist_off_msg;

  emc_coolant_mist_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_mist_off_msg);

  return 0;
}

static int sendFloodOn()
{
  EMC_COOLANT_FLOOD_ON emc_coolant_flood_on_msg;

  emc_coolant_flood_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_flood_on_msg);

  return 0;
}

static int sendFloodOff()
{
  EMC_COOLANT_FLOOD_OFF emc_coolant_flood_off_msg;

  emc_coolant_flood_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_coolant_flood_off_msg);

  return 0;
}

static int sendSpindleForward()
{
  EMC_SPINDLE_ON emc_spindle_on_msg;

  emc_spindle_on_msg.speed = +1;
  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_on_msg);

  return 0;
}

static int sendSpindleReverse()
{
  EMC_SPINDLE_ON emc_spindle_on_msg;

  emc_spindle_on_msg.speed = -1;
  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_on_msg);

  return 0;
}

static int sendSpindleOff()
{
  EMC_SPINDLE_OFF emc_spindle_off_msg;

  emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_off_msg);

  return 0;
}

static int sendSpindleIncrease()
{
  EMC_SPINDLE_INCREASE emc_spindle_increase_msg;

  emc_spindle_increase_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_increase_msg);

  return 0;
}

static int sendSpindleDecrease()
{
  EMC_SPINDLE_DECREASE emc_spindle_decrease_msg;

  emc_spindle_decrease_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_decrease_msg);

  return 0;
}

static int sendSpindleConstant()
{
  EMC_SPINDLE_CONSTANT emc_spindle_constant_msg;

  emc_spindle_constant_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_constant_msg);

  return 0;
}

static int sendBrakeEngage()
{
  EMC_SPINDLE_BRAKE_ENGAGE emc_spindle_brake_engage_msg;

  emc_spindle_brake_engage_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_brake_engage_msg);

  return 0;
}

static int sendBrakeRelease()
{
  EMC_SPINDLE_BRAKE_RELEASE emc_spindle_brake_release_msg;

  emc_spindle_brake_release_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(emc_spindle_brake_release_msg);

  return 0;
}

static int sendAbort()
{
  EMC_TASK_ABORT task_abort_msg;

  task_abort_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(task_abort_msg);

  return 0;
}

static int sendOverrideLimits()
{
  EMC_AXIS_OVERRIDE_LIMITS lim_msg;

  lim_msg.axis = 0;             // same number for all
  lim_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(lim_msg);

  return 0;
}

static int sendJogStop(int axis)
{
  EMC_AXIS_ABORT emc_axis_abort_msg;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  // don't send request to jog if none are jogging
  if (axisJogging == -1) {
    return 0;
  }

  emc_axis_abort_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_abort_msg.axis = axisJogging;
  emcCommandBuffer->write(emc_axis_abort_msg);

  axisJogging = -1;

  return 0;
}

static int sendJogCont(int axis, double speed)
{
  EMC_AXIS_JOG emc_axis_jog_msg;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  if (axisJogging != -1) {
    // ignore request to jog, if an axis is already jogging
    return 0;
  }

  if (0 == jogPol[axis]) {
    speed = -speed;
  }

  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_jog_msg.axis = axis;
  emc_axis_jog_msg.vel = speed / 60.0;
  emcCommandBuffer->write(emc_axis_jog_msg);

  axisJogging = axis;

  return 0;
}

static int sendJogIncr(int axis, double speed, double incr)
{
  EMC_AXIS_INCR_JOG emc_axis_incr_jog_msg;

  if (axis < 0 || axis >= XEMC_NUM_AXES) {
    return -1;
  }

  if (axisJogging != -1) {
    // ignore request to jog, if an axis is already jogging
    return 0;
  }

  if (0 == jogPol[axis]) {
    speed = -speed;
  }

  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_incr_jog_msg.axis = axis;
  emc_axis_incr_jog_msg.vel = speed / 60.0;
  emc_axis_incr_jog_msg.incr = jogIncrement;
  emcCommandBuffer->write(emc_axis_incr_jog_msg);

  // don't flag incremental jogs as jogging an axis-- we can
  // allow multiple incremental jogs since we don't need a key release

  return 0;
}

static int sendHome(int axis)
{
  EMC_AXIS_HOME emc_axis_home_msg;

  emc_axis_home_msg.serial_number = ++emcCommandSerialNumber;
  emc_axis_home_msg.axis = axis;
  emcCommandBuffer->write(emc_axis_home_msg);

  return 0;
}

static int sendFeedOverride(double override)
{
  EMC_TRAJ_SET_SCALE emc_traj_set_scale_msg;

  if (override < 0.0) {
    override = 0.0;
  }
  else if (override > (double) maxFeedOverride / 100.0) {
    override = (double) maxFeedOverride / 100.0;
  }
  emc_traj_set_scale_msg.serial_number = ++emcCommandSerialNumber;
  emc_traj_set_scale_msg.scale = override;
  emcCommandBuffer->write(emc_traj_set_scale_msg);

  return 0;
}

static int sendTaskPlanInit()
{
  EMC_TASK_PLAN_INIT task_plan_init_msg;

  task_plan_init_msg.serial_number = ++emcCommandSerialNumber;
  emcCommandBuffer->write(task_plan_init_msg);

  return 0;
}

static int sendProgramOpen(char *program)
{
  EMC_TASK_PLAN_OPEN emc_task_plan_open_msg;

  // first put in auto mode if it's not
  if (0 == emcStatus->task.mode != EMC_TASK_MODE_AUTO) {
    // send a request to go to auto mode
    sendAuto();
  }

  // wait for any previous one to go out
  if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
    printError("error executing command\n");
    return -1;
  }

  emc_task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
  strcpy(emc_task_plan_open_msg.file, program);
  emcCommandBuffer->write(emc_task_plan_open_msg);

  // now clear out our stored version of the program, in case
  // the file contents have changed but the name is the same
  programFile[0] = 0;

  return 0;
}

// line in program to run from; set it in GUI when user clicks on a line,
// and pass it in calls to sendProgramRun(). sendProgramRun() won't use
// this directly.
static int programStartLine = 0;
static int programStartLineLast = 0;

static int sendProgramRun(int line)
{
  EMC_TASK_PLAN_RUN emc_task_plan_run_msg;

  // first reopen program if it's not open
  if (0 == emcStatus->task.file[0]) {
    // send a request to open last one
    sendProgramOpen(lastProgramFile);

    // wait for command to go out
    if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
      printError("error executing command\n");
      return -1;
    }
  }

  emc_task_plan_run_msg.serial_number = ++emcCommandSerialNumber;
  emc_task_plan_run_msg.line = line;