keystick.cc

CNC 的开放码,EMC2 V2.2.8版

      startTimer(usecs);
    }

  while (! done)
    {
      oldch = ch;
      ch = (chtype) getch();
      // check for ^C that may happen during blocking read
      if (done)
        {
          break;
        }

      if (dump)
        {
          mvwaddstr(window, wmaxy, wbegx, line_blank);
          sprintf(scratch_string, "%12o", (int) ch);
          mvwaddstr(window, wmaxy, wbegx, scratch_string);
          wmove(window, wmaxy, wbegx);
          wrefresh(window);

          if (ch == 'q')
            break;
          else
            continue;
        }

      if (ch != oldch)
        {
          keyup_count = FIRST_KEYUP_DELAY;
        }
      else
        {
          keyup_count = NEXT_KEYUP_DELAY;
        }

      // set up a first switch on ch, for those characters that
      // are to be looked at before the interactive typing string.
      // set flag signifying the char has been handled, which will
      // be reset in the default (not handled) case
      charHandled = 1;
      switch (ch)
        {
          /*
            To implement a "repeated key," whose actions are done
            during the first and every repeated key, do this:

            case MY_REPEATED_KEY:
            // do action
            // you need do nothing else
            break;

            To implement a "single key," whose actions are done
            once and not repeated if the key repeats, do this:

            case MY_SINGLE_KEY:
            if (oldch != ch)
            {
            // do action
            // you need do nothing else
            }
            break;

            The simulated key-up event and setting of oldch is done
            automatically elsewhere.
          */

        case ESC:               // task abort (abort everything)
          task_abort_msg.serial_number = ++emcCommandSerialNumber;
          emcCommandBuffer->write(task_abort_msg);
          emcCommandWait(emcCommandSerialNumber);
          break;

        case TAB:               // toggle highlight
	  if (window == diagwin)
            {
              // toggle dianostics highlight
              if (diagtab == DIAG_USECS)
                diagtab = DIAG_FIRST_KEYUP_DELAY;
              else if (diagtab == DIAG_FIRST_KEYUP_DELAY)
                diagtab = DIAG_NEXT_KEYUP_DELAY;
              else
                diagtab = DIAG_USECS;
            }
          break;

        case ALT('o'):          // open log
        case ALT('O'):
          if (oldch != ch)
            {
              typing = 1;
              typeindex = 0;
              interactive = IACT_OPEN_LOG;

              critFlag = 1;
              mvwaddstr(window, wmaxy, wbegx, line_blank);
              mvwaddstr(window, wmaxy, wbegx, "log file to open: ");
              wrefresh(window);
              critFlag = 0;
            }
          break;


        case CTL('L'):          // redraw current window
          clearWindow();
          printStatus();
          break;

        case KEY_F(1):          // toggle estop
          if (oldch != ch)
            {
              if (emcStatus->task.state == EMC_TASK_STATE_ESTOP)
                {
                  state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
                }
              else
                {
                  state_msg.state = EMC_TASK_STATE_ESTOP;
                }
              state_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(state_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(2):          // toggle servos
          if (oldch != ch)
            {
              if (emcStatus->task.state == EMC_TASK_STATE_ESTOP_RESET)
                {
                  state_msg.state = EMC_TASK_STATE_ON;
                }
              else
                {
                  state_msg.state = EMC_TASK_STATE_OFF;
                }
              state_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(state_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(3):          // to into manual mode
          if (oldch != ch)
            {
              mode_msg.mode = EMC_TASK_MODE_MANUAL;
              mode_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(mode_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(4):          // go into auto mode
          if (oldch != ch)
            {
              mode_msg.mode = EMC_TASK_MODE_AUTO;
              mode_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(mode_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(5):          // go into mdi mode
          if (oldch != ch)
            {
              mode_msg.mode = EMC_TASK_MODE_MDI;
              mode_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(mode_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(6):          // reset interpreter
          if (oldch != ch)
            {
              task_plan_init_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(task_plan_init_msg);
              emcCommandWait(emcCommandSerialNumber);
            }
          break;

        case KEY_F(7):          // toggle mist
          if (oldch != ch)
            {
              if (emcStatus->io.coolant.mist)
                {
                  emc_coolant_mist_off_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_coolant_mist_off_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
              else
                {
                  emc_coolant_mist_on_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_coolant_mist_on_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
            }
          break;

        case KEY_F(8):          // toggle flood
          if (oldch != ch)
            {
              if (emcStatus->io.coolant.flood)
                {
                  emc_coolant_flood_off_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_coolant_flood_off_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
              else
                {
                  emc_coolant_flood_on_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_coolant_flood_on_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
            }
          break;

        case KEY_F(9):          // toggle spindle forward/off
          if (oldch != ch)
            {
              if (emcStatus->motion.spindle.direction == 0)
                {
                  // it's off, so turn forward
                  emc_spindle_on_msg.speed = 1;
                  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_spindle_on_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
              else
                {
                  // it's not off, so turn off
                  emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_spindle_off_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
            }
          break;

        case KEY_F(10):         // toggle spindle reverse/off
          if (oldch != ch)
            {
              if (emcStatus->motion.spindle.direction == 0)
                {
                  // it's off, so turn reverse
                  emc_spindle_on_msg.speed = -1;
                  emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_spindle_on_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
              else
                {
                  // it's not off, so turn off
                  emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
                  emcCommandBuffer->write(emc_spindle_off_msg);
                  emcCommandWait(emcCommandSerialNumber);
                }
            }
          break;

        case KEY_F(11):         // spindle speed decrease
          if (oldch != ch)
            {
              // check for running first
              if (emcStatus->motion.spindle.direction == 0)
                break;

              emc_spindle_decrease_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(emc_spindle_decrease_msg);
              emcCommandWait(emcCommandSerialNumber);
              spindleChanging = 1;
            }
          break;

        case KEY_F(12):         // spindle speed increase
          if (oldch != ch)
            {
              // check for running first
              if (emcStatus->motion.spindle.direction == 0)
                break;

              emc_spindle_increase_msg.serial_number = ++emcCommandSerialNumber;
              emcCommandBuffer->write(emc_spindle_increase_msg);
              emcCommandWait(emcCommandSerialNumber);
              spindleChanging = 1;
            }
          break;

        case KEY_RIGHT:
          if (oldch != ch &&
              axisJogging == AXIS_NONE)
            {
              if (jogMode == JOG_INCREMENTAL)
                {
                  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_incr_jog_msg.axis = axisIndex(AXIS_X);
                  if (xJogPol)
                    emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
                  else
                    emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
                  emc_axis_incr_jog_msg.incr = jogIncrement;
                  emcCommandBuffer->write(emc_axis_incr_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  // don't set axisJogging, since key up will abort
                }
              else
                {
                  jogMode = JOG_CONTINUOUS;
                  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_jog_msg.axis = axisIndex(AXIS_X);
                  if (xJogPol)
                    emc_axis_jog_msg.vel = jogSpeed / 60.0;
                  else
                    emc_axis_jog_msg.vel = - jogSpeed / 60.0;
                  emcCommandBuffer->write(emc_axis_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  axisJogging = AXIS_X;
                }
              axisSelected = AXIS_X;
            }
          break;

        case KEY_LEFT:
          if (oldch != ch &&
              axisJogging == AXIS_NONE)
            {
              if (jogMode == JOG_INCREMENTAL)
                {
                  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_incr_jog_msg.axis = axisIndex(AXIS_X);
                  if (xJogPol)
                    emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
                  else
                    emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
                  emc_axis_incr_jog_msg.incr = jogIncrement;
                  emcCommandBuffer->write(emc_axis_incr_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  // don't set axisJogging, since key up will abort
                }
              else
                {
                  jogMode = JOG_CONTINUOUS;
                  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_jog_msg.axis = axisIndex(AXIS_X);
                  if (xJogPol)
                    emc_axis_jog_msg.vel = - jogSpeed / 60.0;
                  else
                    emc_axis_jog_msg.vel = jogSpeed / 60.0;
                  emcCommandBuffer->write(emc_axis_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  axisJogging = AXIS_X;
                }
              axisSelected = AXIS_X;
            }
          break;

        case KEY_UP:
          if (oldch != ch &&
              axisJogging == AXIS_NONE)
            {
              if (jogMode == JOG_INCREMENTAL)
                {
                  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Y);
                  if (yJogPol)
                    emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
                  else
                    emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
                  emc_axis_incr_jog_msg.incr = jogIncrement;
                  emcCommandBuffer->write(emc_axis_incr_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  // don't set axisJogging, since key up will abort
                }
              else
                {
                  jogMode = JOG_CONTINUOUS;
                  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_jog_msg.axis = axisIndex(AXIS_Y);
                  if (yJogPol)
                    emc_axis_jog_msg.vel = jogSpeed / 60.0;
                  else
                    emc_axis_jog_msg.vel = - jogSpeed / 60.0;
                  emcCommandBuffer->write(emc_axis_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  axisJogging = AXIS_Y;
                }
              axisSelected = AXIS_Y;
            }
          break;

        case KEY_DOWN:
          if (oldch != ch &&
              axisJogging == AXIS_NONE)
            {
              if (jogMode == JOG_INCREMENTAL)
                {
                  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Y);
                  if (yJogPol)
                    emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
                  else
                    emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
                  emc_axis_incr_jog_msg.incr = jogIncrement;
                  emcCommandBuffer->write(emc_axis_incr_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  // don't set axisJogging, since key up will abort
                }
              else
                {
                  jogMode = JOG_CONTINUOUS;
                  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_jog_msg.axis = axisIndex(AXIS_Y);
                  if (yJogPol)
                    emc_axis_jog_msg.vel = - jogSpeed / 60.0;
                  else
                    emc_axis_jog_msg.vel = jogSpeed / 60.0;
                  emcCommandBuffer->write(emc_axis_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  axisJogging = AXIS_Y;
                }
              axisSelected = AXIS_Y;
            }
          break;

        case KEY_PPAGE:
          if (oldch != ch &&
              axisJogging == AXIS_NONE)
            {
              if (jogMode == JOG_INCREMENTAL)
                {
                  emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Z);
                  if (zJogPol)
                    emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
                  else
                    emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
                  emc_axis_incr_jog_msg.incr = jogIncrement;
                  emcCommandBuffer->write(emc_axis_incr_jog_msg);
                  emcCommandWait(emcCommandSerialNumber);
                  // don't set axisJogging, since key up will abort
                }
              else
                {
                  jogMode = JOG_CONTINUOUS;
                  emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
                  emc