#include <stdio.h>#include <string.h>#include <stdlib.h>#include <ctype.h>#include <signal.h>#include <errno.h>#include <sys/time.h>#include <sys/ioctl.h>#include <unistd.h>#include "rcs.hh"#include "emc.hh"#include "emcglb.h"#include "emccfg.h"#include "inifile.h"#include <curses.h>Include dependency graph for keystick.cc:
Go to the source code of this file.
|
|
Definition at line 80 of file keystick.cc. Referenced by main().
|
|
|
Definition at line 85 of file keystick.cc. |
|
|
Definition at line 81 of file keystick.cc. Referenced by main().
|
|
|
Definition at line 300 of file keystick.cc. |
|
|
Definition at line 302 of file keystick.cc. |
|
|
Definition at line 1418 of file keystick.cc. |
|
|
Definition at line 1417 of file keystick.cc. |
|
|
Definition at line 199 of file keystick.cc. |
|
|
Definition at line 364 of file keystick.cc. |
|
|
Definition at line 363 of file keystick.cc. |
|
|
Definition at line 77 of file keystick.cc. |
|
|
Definition at line 268 of file keystick.cc. |
|
|
Definition at line 273 of file keystick.cc. |
|
|
Definition at line 79 of file keystick.cc. |
|
|
Definition at line 87 of file keystick.cc. |
|
|
Definition at line 78 of file keystick.cc. |
|
|
|
|
|
Definition at line 86 of file keystick.cc. |
|
|
Definition at line 307 of file keystick.cc. 00307 {DIAG_USECS = 1, DIAG_FIRST_KEYUP_DELAY, DIAG_NEXT_KEYUP_DELAY} diagtab = DIAG_USECS;
|
|
|
Definition at line 309 of file keystick.cc. |
|
|
Definition at line 215 of file keystick.cc. |
|
|
Definition at line 252 of file keystick.cc. 00252 {
00253 COORD_RELATIVE = 1,
00254 COORD_ABSOLUTE
00255 } COORD_TYPE;
|
|
|
Definition at line 201 of file keystick.cc. 00201 {
00202 JOG_CONTINUOUS = 1,
00203 JOG_INCREMENTAL
00204 } JOG_MODE;
|
|
|
Definition at line 259 of file keystick.cc. 00259 {
00260 POS_DISPLAY_ACT = 1,
00261 POS_DISPLAY_CMD
00262 } POS_DISPLAY_TYPE;
|
|
|
Definition at line 1462 of file keystick.cc. 01463 {
01464 // mask out this signal for now
01465 signal(SIGALRM, SIG_IGN);
01466
01467 // read NML status
01468 updateStatus();
01469
01470 // only print if main is not printing, so we don't clobber in the middle
01471 if (! critFlag)
01472 {
01473 printStatus();
01474 }
01475
01476 // simulate key-up event, as per comment below
01477 keyup_count -= usecs;
01478 if (keyup_count < 0)
01479 {
01480 keyup_count = 0;
01481 oldch = 0;
01482 }
01483
01484 /*
01485 Key-up events are simulated as follows: each time a key is received,
01486 keyup_count is loaded. If it's a new key, FIRST_KEYUP_DELAY is
01487 loaded. If it's the same as the last key, NEXT_KEYUP_DELAY is loaded.
01488 This is to handle the different delay between the first and subsequent
01489 repeats.
01490
01491 Each time through this handler, keyup_count is decremented. If it
01492 reaches 0, it means no key has been pressed before the delay expires,
01493 and we see this as a key-up event.
01494
01495 If you have code that needs to respond to a key-up event, set a flag
01496 when you do your key-down stuff, and put the key-up code in here,
01497 like this:
01498
01499 if (myFlag && keyup_count == 0)
01500 {
01501 // do stuff for key up here
01502
01503 // and clear your flag
01504 myFlag = 0;
01505 }
01506 */
01507
01508 // key up for jogs
01509 if (axisJogging != AXIS_NONE && keyup_count == 0)
01510 {
01511 emc_axis_abort_msg.axis = axisIndex(axisJogging);
01512 emc_axis_abort_msg.serial_number = ++emcCommandSerialNumber;
01513 emcCommandBuffer->write(emc_axis_abort_msg);
01514 emcCommandWait(emcCommandSerialNumber);
01515 axisJogging = AXIS_NONE;
01516 }
01517
01518 // key up for spindle speed changes
01519 if (spindleChanging && keyup_count == 0)
01520 {
01521 emc_spindle_constant_msg.serial_number = ++emcCommandSerialNumber;
01522 emcCommandBuffer->write(emc_spindle_constant_msg);
01523 emcCommandWait(emcCommandSerialNumber);
01524 spindleChanging = 0;
01525 }
01526
01527 // reenable this signal
01528 signal(SIGALRM, alarmHandler);
01529
01530 return;
01531 }
|
|
|
Definition at line 240 of file keystick.cc. Referenced by alarmHandler(), and main().
|
|
|
Definition at line 225 of file keystick.cc. Referenced by printStatus().
00226 {
00227 switch (a)
00228 {
00229 case AXIS_X:
00230 return " X SELECTED ";
00231 case AXIS_Y:
00232 return " Y SELECTED ";
00233 case AXIS_Z:
00234 return " Z SELECTED ";
00235 default:
00236 return " ? SELECTED ";
00237 }
00238 }
|
|
|
Definition at line 366 of file keystick.cc. Referenced by main().
00367 {
00368 int t;
00369
00370 critFlag = 1;
00371
00372 wattrset(window, A_BOLD);
00373 for (t = wbegy; t <= wmaxy; t++)
00374 {
00375 mvwaddstr(window, t, 0, line_blank);
00376 }
00377 wrefresh(window);
00378
00379 wattrset(window, 0);
00380 for (t = wbegy; t <= wmaxy; t++)
00381 {
00382 mvwaddstr(window, t, 0, line_blank);
00383 }
00384 wmove(window, wmaxy, wbegx);
00385 wrefresh(window);
00386
00387 critFlag = 0;
00388 }
|
|
|
Definition at line 1420 of file keystick.cc. Referenced by alarmHandler(), and main().
01421 {
01422 double start = etime();
01423
01424 while (etime() - start < EMC_COMMAND_TIMEOUT)
01425 {
01426 updateStatus();
01427
01428 if (emcStatus->echo_serial_number == serial_number)
01429 {
01430 return 0;
01431 }
01432
01433 esleep(EMC_COMMAND_DELAY);
01434 }
01435
01436 printError("timeout sending command");
01437
01438 return -1;
01439 }
|
|
|
Definition at line 1633 of file keystick.cc. 01634 {
01635 int retval = 0;
01636
01637 if (emcErrorBuffer == 0)
01638 {
01639 emcErrorBuffer = new NML(nmlErrorFormat, "emcError", "keystick", EMC_NMLFILE);
01640 if (! emcErrorBuffer->valid())
01641 {
01642 rcs_print_error("emcError buffer not available\n");
01643 delete emcErrorBuffer;
01644 emcErrorBuffer = 0;
01645 retval = -1;
01646 }
01647 }
01648
01649 return retval;
01650 }
|
|
|
Definition at line 1594 of file keystick.cc. 01595 {
01596 int retval = 0;
01597
01598 // try to connect to EMC cmd
01599 if (emcCommandBuffer == 0)
01600 {
01601 emcCommandBuffer = new RCS_CMD_CHANNEL(emcFormat, "emcCommand", "keystick", EMC_NMLFILE);
01602 if (! emcCommandBuffer->valid())
01603 {
01604 rcs_print_error("emcCommand buffer not available\n");
01605 delete emcCommandBuffer;
01606 emcCommandBuffer = 0;
01607 retval = -1;
01608 }
01609 }
01610
01611 // try to connect to EMC status
01612 if (emcStatusBuffer == 0)
01613 {
01614 emcStatusBuffer = new RCS_STAT_CHANNEL(emcFormat, "emcStatus", "keystick", EMC_NMLFILE);
01615 if (! emcStatusBuffer->valid() ||
01616 EMC_STAT_TYPE != emcStatusBuffer->peek())
01617 {
01618 rcs_print_error("emcStatus buffer not available\n");
01619 delete emcStatusBuffer;
01620 emcStatusBuffer = 0;
01621 emcStatus = 0;
01622 retval = -1;
01623 }
01624 else
01625 {
01626 emcStatus = (EMC_STAT *) emcStatusBuffer->get_address();
01627 }
01628 }
01629
01630 return retval;
01631 }
|
|
|
Definition at line 1670 of file keystick.cc. 01671 {
01672 INIFILE inifile;
01673 const char *inistring;
01674 char machine[INIFILE_MAX_LINELEN] = "";
01675 char version[INIFILE_MAX_LINELEN] = "";
01676 char displayString[INIFILE_MAX_LINELEN] = "";
01677 int jogPol;
01678
01679 // open it
01680 if (-1 == inifile.open(filename))
01681 {
01682 return -1;
01683 }
01684
01685 if (NULL != (inistring = inifile.find("MACHINE", "EMC")))
01686 {
01687 strcpy(machine, inistring);
01688
01689 if (NULL != (inistring = inifile.find("VERSION", "EMC")))
01690 {
01691 sscanf(inistring, "$Revision: %s", version);
01692
01693 sprintf(version_string, "%s EMC Version %s", machine, version);
01694 }
01695 }
01696
01697 if (NULL != (inistring = inifile.find("MAX_VELOCITY", "TRAJ")))
01698 {
01699 if (1 != sscanf(inistring, "%lf", &TRAJ_MAX_VELOCITY))
01700 {
01701 TRAJ_MAX_VELOCITY = DEFAULT_TRAJ_MAX_VELOCITY;
01702 }
01703 }
01704 else
01705 {
01706 TRAJ_MAX_VELOCITY = DEFAULT_TRAJ_MAX_VELOCITY;
01707 }
01708
01709 if (NULL != (inistring = inifile.find("PROGRAM_PREFIX", "TASK")))
01710 {
01711 if (1 != sscanf(inistring, "%s", programPrefix))
01712 {
01713 programPrefix[0] = 0;
01714 }
01715 }
01716 else
01717 {
01718 programPrefix[0] = 0;
01719 }
01720
01721 if (NULL != (inistring = inifile.find("POSITION_OFFSET", "DISPLAY")))
01722 {
01723 if (1 == sscanf(inistring, "%s", displayString))
01724 {
01725 upcase(displayString);
01726 if (! strcmp(displayString, "ABSOLUTE"))
01727 {
01728 coords = COORD_ABSOLUTE;
01729 }
01730 else if (! strcmp(displayString, "RELATIVE"))
01731 {
01732 coords = COORD_RELATIVE;
01733 }
01734 else
01735 {
01736 // error-- invalid value
01737 // ignore
01738 }
01739 }
01740 else
01741 {
01742 // error-- no value provided
01743 // ignore
01744 }
01745 }
01746 else
01747 {
01748 // no line at all
01749 // ignore
01750 }
01751
01752 if (NULL != (inistring = inifile.find("POSITION_FEEDBACK", "DISPLAY")))
01753 {
01754 if (1 == sscanf(inistring, "%s", displayString))
01755 {
01756 upcase(displayString);
01757 if (! strcmp(displayString, "ACTUAL"))
01758 {
01759 posDisplay = POS_DISPLAY_ACT;
01760 }
01761 else if (! strcmp(displayString, "COMMANDED"))
01762 {
01763 posDisplay = POS_DISPLAY_CMD;
01764 }
01765 else
01766 {
01767 // error-- invalid value
01768 // ignore
01769 }
01770 }
01771 else
01772 {
01773 // error-- no value provided
01774 // ignore
01775 }
01776 }
01777 else
01778 {
01779 // no line at all
01780 // ignore
01781 }
01782
01783 xJogPol = 1; // set to default
01784 if (NULL != (inistring = inifile.find("JOGGING_POLARITY", "AXIS_0")) &&
01785 1 == sscanf(inistring, "%d", &jogPol) &&
01786 jogPol == 0)
01787 {
01788 // it read as 0, so override default
01789 xJogPol = 0;
01790 }
01791
01792 yJogPol = 1; // set to default
01793 if (NULL != (inistring = inifile.find("JOGGING_POLARITY", "AXIS_1")) &&
01794 1 == sscanf(inistring, "%d", &jogPol) &&
01795 jogPol == 0)
01796 {
01797 // it read as 0, so override default
01798 yJogPol = 0;
01799 }
01800
01801 zJogPol = 1; // set to default
01802 if (NULL != (inistring = inifile.find("JOGGING_POLARITY", "AXIS_2")) &&
01803 1 == sscanf(inistring, "%d", &jogPol) &&
01804 jogPol == 0)
01805 {
01806 // it read as 0, so override default
01807 zJogPol = 0;
01808 }
01809
01810 // close it
01811 inifile.close();
01812
01813 return 0;;
01814 }
|
|
||||||||||||
|
Definition at line 1816 of file keystick.cc. 01817 {
01818 int dump = 0;
01819 struct winsize size;
01820 int curx, cury;
01821 int t;
01822 int typing = 0;
01823 #define TYPEBUFFERSIZE LINELEN
01824 char typebuffer[TYPEBUFFERSIZE];
01825 char lastmdi[TYPEBUFFERSIZE] = "";
01826 int typeindex = 0;
01827 enum {IACT_NONE = 1, IACT_OPEN, IACT_MDI, IACT_LOAD_TOOL, IACT_OPEN_LOG,
01828 IACT_END} interactive = IACT_NONE;
01829 char keystick[] = "keystick";
01830 int charHandled;
01831
01832 // process command line args, indexing argv[] from [1]
01833 for (t = 1; t < argc; t++)
01834 {
01835 // try -dump
01836 if (!strcmp(argv[t], "-dump"))
01837 {
01838 dump = 1;
01839 t++; // step over nmlfile
01840 continue;
01841 }
01842
01843 // try -nml
01844 if (!strcmp(argv[t], "-nml"))
01845 {
01846 if (t == argc - 1) // if last, can't read past it
01847 {
01848 printf("syntax: -nml <nmlfile>\n");
01849 exit(1);
01850 }
01851 else
01852 {
01853 strcpy(EMC_NMLFILE, argv[t+1]);
01854 t++; // step over nmlfile
01855 continue;
01856 }
01857 }
01858
01859 // try -ini
01860 if (!strcmp(argv[t], "-ini"))
01861 {
01862 if (t == argc - 1)
01863 {
01864 printf("syntax: -ini <inifile\n");
01865 exit(1);
01866 }
01867 else
01868 {
01869 strcpy(EMC_INIFILE, argv[t+1]);
01870 t++; // step over inifile
01871 continue;
01872 }
01873 }
01874
01875 // try -noerror
01876 if (!strcmp(argv[t], "-noerror"))
01877 {
01878 catchErrors = 0;
01879 continue;
01880 }
01881
01882 // try -usecs for cycle time in microseconds
01883 if (!strcmp(argv[t], "-usecs"))
01884 {
01885 if (t == argc - 1 ||
01886 1 != sscanf(argv[t + 1], "%d", &usecs) ||
01887 usecs <= 0 ||
01888 usecs >= 1000000)
01889 {
01890 printf("syntax: -usecs <1..999999 microsecond polling period>\n");
01891 exit(1);
01892 }
01893 else
01894 {
01895 t++;
01896 continue;
01897 }
01898 }
01899
01900 // try -dur for delay until repeat
01901 if (!strcmp(argv[t], "-dur"))
01902 {
01903 if (t == argc - 1 ||
01904 1 != sscanf(argv[t + 1], "%d", &FIRST_KEYUP_DELAY) ||
01905 FIRST_KEYUP_DELAY < 0)
01906 {
01907 printf("syntax: -dur <usecs delay until first repeat>\n");
01908 exit(1);
01909 }
01910 else
01911 {
01912 t++;
01913 continue;
01914 }
01915 }
01916
01917 // try -dbr for delay between repeats
01918 if (!strcmp(argv[t], "-dbr"))
01919 {
01920 if (t == argc - 1 ||
01921 1 != sscanf(argv[t + 1], "%d", &NEXT_KEYUP_DELAY) ||
01922 NEXT_KEYUP_DELAY < 0)
01923 {
01924 printf("syntax: -dbr <usecs delay between repeats>\n");
01925 exit(1);
01926 }
01927 else
01928 {
01929 t++;
01930 continue;
01931 }
01932 }
01933
01934 }
01935
01936 // read INI file
01937 iniLoad(EMC_INIFILE);
01938
01939 // trap SIGINT
01940 signal(SIGINT, quit);
01941
01942 // set up handler for SIGALRM to handle periodic timer events
01943 signal(SIGALRM, alarmHandler);
01944
01945 // open error file for logging
01946 if (NULL == (errorFp = fopen(ERROR_FILE, "w")))
01947 {
01948 // ignore; null errorFp will prevent attempts to log
01949 }
01950
01951 // blank out the annoying RCS version message
01952 rcs_version_printed = 1;
01953
01954 // init NML
01955 if (! dump)
01956 {
01957 if (0 != emcTaskNmlGet())
01958 {
01959 exit(1);
01960 }
01961 if (0 != emcErrorNmlGet())
01962 {
01963 exit(1);
01964 }
01965 }
01966
01967 // set up curses
01968 initscr();
01969 cbreak();
01970 noecho();
01971 nonl();
01972 intrflush(stdscr, FALSE);
01973 keypad(stdscr, TRUE);
01974 helpwin = newwin(0, 0, 0, 0);
01975 diagwin = newwin(0, 0, 0, 0);
01976 toolwin = newwin(0, 0, 0, 0);
01977 logwin = newwin(0, 0, 0, 0);
01978 progwin = newwin(0, 0, 0, 0);
01979 window = stdscr;
01980
01981 // fill in strings
01982
01983 for (t = 0; t < LINELEN; t++)
01984 {
01985 line_blank[t] = ' ';
01986 }
01987 line_blank[LINELEN] = 0;
01988
01989 for (t = 0; t < LINELEN; t++)
01990 {
01991 bottom_string[t] = '-';
01992 }
01993 bottom_string[LINELEN] = 0;
01994 t = (LINELEN - strlen(version_string)) / 2;
01995 if (t >= 0)
01996 {
01997 memcpy(&bottom_string[t], version_string, strlen(version_string));
01998 }
01999
02000 // get screen width and height
02001 wbegy = 0;
02002 wbegx = 0;
02003 if (ioctl(STDIN_FILENO, TIOCGWINSZ, &size) < 0)
02004 {
02005 // use 80x24 as default
02006 wmaxy = 23;
02007 wmaxx = 79;
02008 }
02009 else
02010 {
02011 wmaxy = size.ws_row - 1;
02012 wmaxx = size.ws_col - 1;
02013 }
02014
02015 // and set them here
02016 cury = wmaxy;
02017 curx = wbegx;
02018 wmove(window, cury, curx);
02019 wrefresh(window);
02020
02021 // set up interval timer
02022 if (!dump)
02023 {
02024 startTimer(usecs);
02025 }
02026
02027 while (! done)
02028 {
02029 oldch = ch;
02030 ch = (chtype) getch();
02031 // check for ^C that may happen during blocking read
02032 if (done)
02033 {
02034 break;
02035 }
02036
02037 if (dump)
02038 {
02039 mvwaddstr(window, wmaxy, wbegx, line_blank);
02040 sprintf(scratch_string, "%12o", (int) ch);
02041 mvwaddstr(window, wmaxy, wbegx, scratch_string);
02042 wmove(window, wmaxy, wbegx);
02043 wrefresh(window);
02044
02045 if (ch == 'q')
02046 break;
02047 else
02048 continue;
02049 }
02050
02051 if (ch != oldch)
02052 {
02053 keyup_count = FIRST_KEYUP_DELAY;
02054 }
02055 else
02056 {
02057 keyup_count = NEXT_KEYUP_DELAY;
02058 }
02059
02060 // set up a first switch on ch, for those characters that
02061 // are to be looked at before the interactive typing string.
02062 // set flag signifying the char has been handled, which will
02063 // be reset in the default (not handled) case
02064 charHandled = 1;
02065 switch (ch)
02066 {
02067 /*
02068 To implement a "repeated key," whose actions are done
02069 during the first and every repeated key, do this:
02070
02071 case MY_REPEATED_KEY:
02072 // do action
02073 // you need do nothing else
02074 break;
02075
02076 To implement a "single key," whose actions are done
02077 once and not repeated if the key repeats, do this:
02078
02079 case MY_SINGLE_KEY:
02080 if (oldch != ch)
02081 {
02082 // do action
02083 // you need do nothing else
02084 }
02085 break;
02086
02087 The simulated key-up event and setting of oldch is done
02088 automatically elsewhere.
02089 */
02090
02091 case ESC: // task abort (abort everything)
02092 task_abort_msg.serial_number = ++emcCommandSerialNumber;
02093 emcCommandBuffer->write(task_abort_msg);
02094 emcCommandWait(emcCommandSerialNumber);
02095 break;
02096
02097 case TAB: // toggle highlight
02098 if (window == logwin)
02099 {
02100 // toggle log highlight
02101 if (logtab == LOG_TYPE)
02102 logtab = LOG_SIZE;
02103 else if (logtab == LOG_SIZE)
02104 logtab = LOG_SKIP;
02105 else if (logtab == LOG_SKIP &&
02106 saveLogType == EMC_LOG_TYPE_AXIS_POS)
02107 logtab = LOG_AXIS;
02108 else
02109 logtab = LOG_TYPE;
02110 }
02111 else if (window == diagwin)
02112 {
02113 // toggle dianostics highlight
02114 if (diagtab == DIAG_USECS)
02115 diagtab = DIAG_FIRST_KEYUP_DELAY;
02116 else if (diagtab == DIAG_FIRST_KEYUP_DELAY)
02117 diagtab = DIAG_NEXT_KEYUP_DELAY;
02118 else
02119 diagtab = DIAG_USECS;
02120 }
02121 break;
02122
02123 case ALT('o'): // open log
02124 case ALT('O'):
02125 if (oldch != ch)
02126 {
02127 typing = 1;
02128 typeindex = 0;
02129 interactive = IACT_OPEN_LOG;
02130
02131 critFlag = 1;
02132 mvwaddstr(window, wmaxy, wbegx, line_blank);
02133 mvwaddstr(window, wmaxy, wbegx, "log file to open: ");
02134 wrefresh(window);
02135 critFlag = 0;
02136 }
02137 break;
02138
02139 case ALT('p'): // pause (or stop) log
02140 case ALT('P'):
02141 if (oldch != ch)
02142 {
02143 emc_log_stop_msg.serial_number = ++emcCommandSerialNumber;
02144 emcCommandBuffer->write(emc_log_stop_msg);
02145 emcCommandWait(emcCommandSerialNumber);
02146 }
02147 break;
02148
02149 case ALT('s'): // resume (or start) log
02150 case ALT('S'):
02151 if (oldch != ch)
02152 {
02153 // check for open log file first; if not, and old one saved,
02154 // open old one
02155 if (! emcStatus->logOpen)
02156 {
02157 if (saveLogFile[0] != 0)
02158 {
02159 strcpy(emc_log_open_msg.file, saveLogFile);
02160 emc_log_open_msg.type = saveLogType;
02161 emc_log_open_msg.size = saveLogSize;
02162 emc_log_open_msg.skip = saveLogSkip;
02163 emc_log_open_msg.which = saveLogAxis;
02164 emc_log_open_msg.serial_number = ++emcCommandSerialNumber;
02165 emcCommandBuffer->write(emc_log_open_msg);
02166 emcCommandWait(emcCommandSerialNumber);
02167 }
02168 else
02169 {
02170 // log is not opened, and no name saved, so ignore
02171 break;
02172 }
02173 }
02174
02175 emc_log_start_msg.serial_number = ++emcCommandSerialNumber;
02176 emcCommandBuffer->write(emc_log_start_msg);
02177 emcCommandWait(emcCommandSerialNumber);
02178 }
02179 break;
02180
02181 case ALT('f'): // close (and save) log to file
02182 case ALT('F'):
02183 if (oldch != ch)
02184 {
02185 emc_log_close_msg.serial_number = ++emcCommandSerialNumber;
02186 emcCommandBuffer->write(emc_log_close_msg);
02187 emcCommandWait(emcCommandSerialNumber);
02188 }
02189 break;
02190
02191 case CTL('P'): // plot log file
02192 if (oldch != ch)
02193 {
02194 if (0 != plotLog(saveLogFile, saveLogType, saveLogAxis))
02195 {
02196 sprintf(scratch_string, "can't print log %s-- check log file manually", saveLogFile);
02197 printError(scratch_string);
02198 }
02199 }
02200 break;
02201
02202 case CTL('L'): // redraw current window
02203 clearWindow();
02204 printStatus();
02205 break;
02206
02207 case KEY_F(1): // toggle estop
02208 if (oldch != ch)
02209 {
02210 if (emcStatus->task.state == EMC_TASK_STATE_ESTOP)
02211 {
02212 state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
02213 }
02214 else
02215 {
02216 state_msg.state = EMC_TASK_STATE_ESTOP;
02217 }
02218 state_msg.serial_number = ++emcCommandSerialNumber;
02219 emcCommandBuffer->write(state_msg);
02220 emcCommandWait(emcCommandSerialNumber);
02221 }
02222 break;
02223
02224 case KEY_F(2): // toggle servos
02225 if (oldch != ch)
02226 {
02227 if (emcStatus->task.state == EMC_TASK_STATE_ESTOP_RESET)
02228 {
02229 state_msg.state = EMC_TASK_STATE_ON;
02230 }
02231 else
02232 {
02233 state_msg.state = EMC_TASK_STATE_OFF;
02234 }
02235 state_msg.serial_number = ++emcCommandSerialNumber;
02236 emcCommandBuffer->write(state_msg);
02237 emcCommandWait(emcCommandSerialNumber);
02238 }
02239 break;
02240
02241 case KEY_F(3): // to into manual mode
02242 if (oldch != ch)
02243 {
02244 mode_msg.mode = EMC_TASK_MODE_MANUAL;
02245 mode_msg.serial_number = ++emcCommandSerialNumber;
02246 emcCommandBuffer->write(mode_msg);
02247 emcCommandWait(emcCommandSerialNumber);
02248 }
02249 break;
02250
02251 case KEY_F(4): // go into auto mode
02252 if (oldch != ch)
02253 {
02254 mode_msg.mode = EMC_TASK_MODE_AUTO;
02255 mode_msg.serial_number = ++emcCommandSerialNumber;
02256 emcCommandBuffer->write(mode_msg);
02257 emcCommandWait(emcCommandSerialNumber);
02258 }
02259 break;
02260
02261 case KEY_F(5): // go into mdi mode
02262 if (oldch != ch)
02263 {
02264 mode_msg.mode = EMC_TASK_MODE_MDI;
02265 mode_msg.serial_number = ++emcCommandSerialNumber;
02266 emcCommandBuffer->write(mode_msg);
02267 emcCommandWait(emcCommandSerialNumber);
02268 }
02269 break;
02270
02271 case KEY_F(6): // reset interpreter
02272 if (oldch != ch)
02273 {
02274 task_plan_init_msg.serial_number = ++emcCommandSerialNumber;
02275 emcCommandBuffer->write(task_plan_init_msg);
02276 emcCommandWait(emcCommandSerialNumber);
02277 }
02278 break;
02279
02280 case KEY_F(7): // toggle mist
02281 if (oldch != ch)
02282 {
02283 if (emcStatus->io.coolant.mist)
02284 {
02285 emc_coolant_mist_off_msg.serial_number = ++emcCommandSerialNumber;
02286 emcCommandBuffer->write(emc_coolant_mist_off_msg);
02287 emcCommandWait(emcCommandSerialNumber);
02288 }
02289 else
02290 {
02291 emc_coolant_mist_on_msg.serial_number = ++emcCommandSerialNumber;
02292 emcCommandBuffer->write(emc_coolant_mist_on_msg);
02293 emcCommandWait(emcCommandSerialNumber);
02294 }
02295 }
02296 break;
02297
02298 case KEY_F(8): // toggle flood
02299 if (oldch != ch)
02300 {
02301 if (emcStatus->io.coolant.flood)
02302 {
02303 emc_coolant_flood_off_msg.serial_number = ++emcCommandSerialNumber;
02304 emcCommandBuffer->write(emc_coolant_flood_off_msg);
02305 emcCommandWait(emcCommandSerialNumber);
02306 }
02307 else
02308 {
02309 emc_coolant_flood_on_msg.serial_number = ++emcCommandSerialNumber;
02310 emcCommandBuffer->write(emc_coolant_flood_on_msg);
02311 emcCommandWait(emcCommandSerialNumber);
02312 }
02313 }
02314 break;
02315
02316 case KEY_F(9): // toggle spindle forward/off
02317 if (oldch != ch)
02318 {
02319 if (emcStatus->io.spindle.direction == 0)
02320 {
02321 // it's off, so turn forward
02322 emc_spindle_on_msg.speed = 1;
02323 emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
02324 emcCommandBuffer->write(emc_spindle_on_msg);
02325 emcCommandWait(emcCommandSerialNumber);
02326 }
02327 else
02328 {
02329 // it's not off, so turn off
02330 emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
02331 emcCommandBuffer->write(emc_spindle_off_msg);
02332 emcCommandWait(emcCommandSerialNumber);
02333 }
02334 }
02335 break;
02336
02337 case KEY_F(10): // toggle spindle reverse/off
02338 if (oldch != ch)
02339 {
02340 if (emcStatus->io.spindle.direction == 0)
02341 {
02342 // it's off, so turn reverse
02343 emc_spindle_on_msg.speed = -1;
02344 emc_spindle_on_msg.serial_number = ++emcCommandSerialNumber;
02345 emcCommandBuffer->write(emc_spindle_on_msg);
02346 emcCommandWait(emcCommandSerialNumber);
02347 }
02348 else
02349 {
02350 // it's not off, so turn off
02351 emc_spindle_off_msg.serial_number = ++emcCommandSerialNumber;
02352 emcCommandBuffer->write(emc_spindle_off_msg);
02353 emcCommandWait(emcCommandSerialNumber);
02354 }
02355 }
02356 break;
02357
02358 case KEY_F(11): // spindle speed decrease
02359 if (oldch != ch)
02360 {
02361 // check for running first
02362 if (emcStatus->io.spindle.direction == 0)
02363 break;
02364
02365 emc_spindle_decrease_msg.serial_number = ++emcCommandSerialNumber;
02366 emcCommandBuffer->write(emc_spindle_decrease_msg);
02367 emcCommandWait(emcCommandSerialNumber);
02368 spindleChanging = 1;
02369 }
02370 break;
02371
02372 case KEY_F(12): // spindle speed increase
02373 if (oldch != ch)
02374 {
02375 // check for running first
02376 if (emcStatus->io.spindle.direction == 0)
02377 break;
02378
02379 emc_spindle_increase_msg.serial_number = ++emcCommandSerialNumber;
02380 emcCommandBuffer->write(emc_spindle_increase_msg);
02381 emcCommandWait(emcCommandSerialNumber);
02382 spindleChanging = 1;
02383 }
02384 break;
02385
02386 case KEY_RIGHT:
02387 if (oldch != ch &&
02388 axisJogging == AXIS_NONE)
02389 {
02390 if (jogMode == JOG_INCREMENTAL)
02391 {
02392 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02393 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_X);
02394 if (xJogPol)
02395 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02396 else
02397 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02398 emc_axis_incr_jog_msg.incr = jogIncrement;
02399 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02400 emcCommandWait(emcCommandSerialNumber);
02401 // don't set axisJogging, since key up will abort
02402 }
02403 else
02404 {
02405 jogMode = JOG_CONTINUOUS;
02406 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02407 emc_axis_jog_msg.axis = axisIndex(AXIS_X);
02408 if (xJogPol)
02409 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02410 else
02411 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02412 emcCommandBuffer->write(emc_axis_jog_msg);
02413 emcCommandWait(emcCommandSerialNumber);
02414 axisJogging = AXIS_X;
02415 }
02416 axisSelected = AXIS_X;
02417 }
02418 break;
02419
02420 case KEY_LEFT:
02421 if (oldch != ch &&
02422 axisJogging == AXIS_NONE)
02423 {
02424 if (jogMode == JOG_INCREMENTAL)
02425 {
02426 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02427 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_X);
02428 if (xJogPol)
02429 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02430 else
02431 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02432 emc_axis_incr_jog_msg.incr = jogIncrement;
02433 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02434 emcCommandWait(emcCommandSerialNumber);
02435 // don't set axisJogging, since key up will abort
02436 }
02437 else
02438 {
02439 jogMode = JOG_CONTINUOUS;
02440 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02441 emc_axis_jog_msg.axis = axisIndex(AXIS_X);
02442 if (xJogPol)
02443 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02444 else
02445 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02446 emcCommandBuffer->write(emc_axis_jog_msg);
02447 emcCommandWait(emcCommandSerialNumber);
02448 axisJogging = AXIS_X;
02449 }
02450 axisSelected = AXIS_X;
02451 }
02452 break;
02453
02454 case KEY_UP:
02455 if (oldch != ch &&
02456 axisJogging == AXIS_NONE)
02457 {
02458 if (jogMode == JOG_INCREMENTAL)
02459 {
02460 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02461 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Y);
02462 if (yJogPol)
02463 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02464 else
02465 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02466 emc_axis_incr_jog_msg.incr = jogIncrement;
02467 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02468 emcCommandWait(emcCommandSerialNumber);
02469 // don't set axisJogging, since key up will abort
02470 }
02471 else
02472 {
02473 jogMode = JOG_CONTINUOUS;
02474 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02475 emc_axis_jog_msg.axis = axisIndex(AXIS_Y);
02476 if (yJogPol)
02477 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02478 else
02479 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02480 emcCommandBuffer->write(emc_axis_jog_msg);
02481 emcCommandWait(emcCommandSerialNumber);
02482 axisJogging = AXIS_Y;
02483 }
02484 axisSelected = AXIS_Y;
02485 }
02486 break;
02487
02488 case KEY_DOWN:
02489 if (oldch != ch &&
02490 axisJogging == AXIS_NONE)
02491 {
02492 if (jogMode == JOG_INCREMENTAL)
02493 {
02494 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02495 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Y);
02496 if (yJogPol)
02497 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02498 else
02499 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02500 emc_axis_incr_jog_msg.incr = jogIncrement;
02501 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02502 emcCommandWait(emcCommandSerialNumber);
02503 // don't set axisJogging, since key up will abort
02504 }
02505 else
02506 {
02507 jogMode = JOG_CONTINUOUS;
02508 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02509 emc_axis_jog_msg.axis = axisIndex(AXIS_Y);
02510 if (yJogPol)
02511 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02512 else
02513 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02514 emcCommandBuffer->write(emc_axis_jog_msg);
02515 emcCommandWait(emcCommandSerialNumber);
02516 axisJogging = AXIS_Y;
02517 }
02518 axisSelected = AXIS_Y;
02519 }
02520 break;
02521
02522 case KEY_PPAGE:
02523 if (oldch != ch &&
02524 axisJogging == AXIS_NONE)
02525 {
02526 if (jogMode == JOG_INCREMENTAL)
02527 {
02528 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02529 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Z);
02530 if (zJogPol)
02531 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02532 else
02533 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02534 emc_axis_incr_jog_msg.incr = jogIncrement;
02535 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02536 emcCommandWait(emcCommandSerialNumber);
02537 // don't set axisJogging, since key up will abort
02538 }
02539 else
02540 {
02541 jogMode = JOG_CONTINUOUS;
02542 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02543 emc_axis_jog_msg.axis = axisIndex(AXIS_Z);
02544 if (zJogPol)
02545 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02546 else
02547 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02548 emcCommandBuffer->write(emc_axis_jog_msg);
02549 emcCommandWait(emcCommandSerialNumber);
02550 axisJogging = AXIS_Z;
02551 }
02552 axisSelected = AXIS_Z;
02553 }
02554 break;
02555
02556 case KEY_NPAGE:
02557 if (oldch != ch &&
02558 axisJogging == AXIS_NONE)
02559 {
02560 if (jogMode == JOG_INCREMENTAL)
02561 {
02562 emc_axis_incr_jog_msg.serial_number = ++emcCommandSerialNumber;
02563 emc_axis_incr_jog_msg.axis = axisIndex(AXIS_Z);
02564 if (zJogPol)
02565 emc_axis_incr_jog_msg.vel = - jogSpeed / 60.0;
02566 else
02567 emc_axis_incr_jog_msg.vel = jogSpeed / 60.0;
02568 emc_axis_incr_jog_msg.incr = jogIncrement;
02569 emcCommandBuffer->write(emc_axis_incr_jog_msg);
02570 emcCommandWait(emcCommandSerialNumber);
02571 // don't set axisJogging, since key up will abort
02572 }
02573 else
02574 {
02575 jogMode = JOG_CONTINUOUS;
02576 emc_axis_jog_msg.serial_number = ++emcCommandSerialNumber;
02577 emc_axis_jog_msg.axis = axisIndex(AXIS_Z);
02578 if (zJogPol)
02579 emc_axis_jog_msg.vel = - jogSpeed / 60.0;
02580 else
02581 emc_axis_jog_msg.vel = jogSpeed / 60.0;
02582 emcCommandBuffer->write(emc_axis_jog_msg);
02583 emcCommandWait(emcCommandSerialNumber);
02584 axisJogging = AXIS_Z;
02585 }
02586 axisSelected = AXIS_Z;
02587 }
02588 break;
02589
02590 case KEY_HOME: // home selected axis
02591 if (oldch != ch)
02592 {
02593 emc_axis_home_msg.axis = axisIndex(axisSelected);
02594 emc_axis_home_msg.serial_number = ++emcCommandSerialNumber;
02595 emcCommandBuffer->write(emc_axis_home_msg);
02596 emcCommandWait(emcCommandSerialNumber);
02597 }
02598 break;
02599
02600 case KEY_END: // end this program
02601 if (oldch != ch)
02602 {
02603 typing = 1;
02604 typeindex = 0;
02605 interactive = IACT_END;
02606
02607 critFlag = 1;
02608 mvwaddstr(window, wmaxy, wbegx, line_blank);
02609 mvwaddstr(window, wmaxy, wbegx, "really quit? (y/n): ");
02610 wrefresh(window);
02611 critFlag = 0;
02612 }
02613 break;
02614
02615 default:
02616 charHandled = 0;
02617 break;
02618 } // end of first switch (ch)
02619
02620 // now handle interactive typing, since immediate chars have
02621 // just been handled
02622
02623 if (typing &&
02624 ! charHandled)
02625 {
02626 if (ch == RETURN)
02627 {
02628 typing = 0;
02629 typebuffer[typeindex] = 0;
02630 typeindex = 0;
02631
02632 critFlag = 1;
02633 mvwaddstr(window, wmaxy, wbegx, line_blank);
02634 wmove(window, wmaxy, wbegx);
02635 wrefresh(window);
02636 critFlag = 0;
02637
02638 // now handle typed string
02639 switch (interactive)
02640 {
02641 case IACT_OPEN:
02642 strcpy(task_plan_open_msg.file, typebuffer);
02643 task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
02644 emcCommandBuffer->write(task_plan_open_msg);
02645 emcCommandWait(emcCommandSerialNumber);
02646 strcpy(programFile, task_plan_open_msg.file);
02647 programOpened = 1;
02648 if (programFp != 0)
02649 {
02650 fclose(programFp);
02651 }
02652 programFp = fopen(programFile, "r");
02653 programLineText[0] = 0;
02654 programFpLine = 0;
02655 interactive = IACT_NONE;
02656 break;
02657
02658 case IACT_MDI:
02659 if (typebuffer[0] == 0)
02660 break; // ignore blank lines
02661 strcpy(lastmdi, typebuffer); // save it
02662 strcpy(task_plan_execute_msg.command, typebuffer);
02663 task_plan_execute_msg.serial_number = ++emcCommandSerialNumber;
02664 emcCommandBuffer->write(task_plan_execute_msg);
02665 emcCommandWait(emcCommandSerialNumber);
02666 interactive = IACT_NONE;
02667 break;
02668
02669 case IACT_LOAD_TOOL:
02670 strcpy(emc_tool_load_tool_table_msg.file, typebuffer);
02671 emc_tool_load_tool_table_msg.serial_number = ++emcCommandSerialNumber;
02672 emcCommandBuffer->write(emc_tool_load_tool_table_msg);
02673 emcCommandWait(emcCommandSerialNumber);
02674 interactive = IACT_NONE;
02675 break;
02676
02677 case IACT_OPEN_LOG:
02678 if (1 != sscanf(typebuffer, "%s", saveLogFile))
02679 {
02680 printError("bad log file");
02681 break;
02682 }
02683 strcpy(emc_log_open_msg.file, saveLogFile);
02684 emc_log_open_msg.type = saveLogType;
02685 emc_log_open_msg.size = saveLogSize;
02686 emc_log_open_msg.skip = saveLogSkip;
02687 emc_log_open_msg.which = saveLogAxis;
02688 emc_log_open_msg.serial_number = ++emcCommandSerialNumber;
02689 emcCommandBuffer->write(emc_log_open_msg);
02690 emcCommandWait(emcCommandSerialNumber);
02691
02692 interactive = IACT_NONE;
02693 break;
02694
02695 case IACT_END:
02696 if (typebuffer[0] == 'y' ||
02697 typebuffer[0] == 'Y')
02698 {
02699 done = 1;
02700 }
02701
02702 interactive = IACT_NONE;
02703 break;
02704
02705 default: // ignore
02706 break;
02707 }
02708 }
02709 else if (ch == KEY_BACKSPACE || // try all the backspace chars
02710 ch == 8 ||
02711 ch == 127)
02712 {
02713 if (typeindex == 0)
02714 {
02715 // we're at first spot-- ignore
02716 continue;
02717 }
02718 --typeindex;
02719 critFlag = 1;
02720 getyx(window, cury, curx);
02721 --curx;
02722 mvwaddch(window, cury, curx, ' ');
02723 wmove(window, cury, curx);
02724 wrefresh(window);
02725 critFlag = 0;
02726 }
02727 else
02728 {
02729 if (typeindex >= TYPEBUFFERSIZE - 1)
02730 {
02731 // we're at last spot, which we need for null-- ignore
02732 continue;
02733 }
02734 typebuffer[typeindex++] = ch;
02735 critFlag = 1;
02736 waddch(window, ch);
02737 wrefresh(window);
02738 critFlag = 0;
02739 }
02740
02741 // continue with while (! done), so we skip over the normal
02742 // handling of alphanumeric chars
02743 continue;
02744
02745 } // end of if (typing)
02746
02747 // set up a second switch on ch, for those alphanumeric chars that
02748 // can be part of an interactive string
02749 switch (ch)
02750 {
02751 case RETURN:
02752 if (oldch != ch)
02753 {
02754 // clear all error buffers
02755 critFlag = 1;
02756 mvwaddstr(stdscr, ERR_Y, ERR_X, line_blank);
02757 mvwaddstr(helpwin, ERR_Y, ERR_X, line_blank);
02758 mvwaddstr(diagwin, ERR_Y, ERR_X, line_blank);
02759 mvwaddstr(toolwin, ERR_Y, ERR_X, line_blank);
02760 mvwaddstr(logwin, ERR_Y, ERR_X, line_blank);
02761 mvwaddstr(progwin, ERR_Y, ERR_X, line_blank);
02762 wmove(window, wmaxy, wbegx);
02763 wrefresh(window);
02764 critFlag = 0;
02765 }
02766 break;
02767
02768 case '?': // toggle help screen
02769 critFlag = 1;
02770 if (window == stdscr)
02771 {
02772 window = helpwin;
02773 }
02774 else if (window == helpwin)
02775 {
02776 window = toolwin;
02777 }
02778 else if (window == toolwin)
02779 {
02780 window = logwin;
02781 }
02782 else if (window == logwin)
02783 {
02784 window = diagwin;
02785 }
02786 else if (window == diagwin)
02787 {
02788 window = progwin;
02789 }
02790 else if (window == progwin)
02791 {
02792 window = stdscr;
02793 }
02794 else
02795 {
02796 window = stdscr;
02797 }
02798 critFlag = 0;
02799 clearWindow();
02800 printStatus();
02801 break;
02802
02803 case '#': // toggle abs/rel mode
02804 if (oldch != ch)
02805 {
02806 switch (coords)
02807 {
02808 case COORD_RELATIVE:
02809 coords = COORD_ABSOLUTE;
02810 break;
02811 case COORD_ABSOLUTE:
02812 coords = COORD_RELATIVE;
02813 break;
02814 default:
02815 coords = COORD_RELATIVE;
02816 break;
02817 }
02818 }
02819 break;
02820
02821 case '@': // toggle cmd/act mode
02822 if (oldch != ch)
02823 {
02824 switch (posDisplay)
02825 {
02826 case POS_DISPLAY_ACT:
02827 posDisplay = POS_DISPLAY_CMD;
02828 break;
02829 case POS_DISPLAY_CMD:
02830 posDisplay = POS_DISPLAY_ACT;
02831 break;
02832 default:
02833 posDisplay = POS_DISPLAY_ACT;
02834 break;
02835 }
02836 }
02837 break;
02838
02839 case 'x':
02840 case 'X':
02841 if (oldch != ch)
02842 {
02843 if (emcStatus->task.mode == EMC_TASK_MODE_MDI)
02844 {
02845 typing = 1;
02846 typeindex = 1;
02847 typebuffer[0] = ch;
02848 typebuffer[1] = 0;
02849 interactive = IACT_MDI;
02850
02851 critFlag = 1;
02852 mvwaddstr(window, wmaxy, wbegx, line_blank);
02853 mvwaddstr(window, wmaxy, wbegx, "mdi command: ");
02854 waddch(window, ch);
02855 wrefresh(window);
02856 critFlag = 0;
02857 }
02858 else
02859 {
02860 axisSelected = AXIS_X;
02861 }
02862 }
02863 break;
02864
02865 case 'y':
02866 case 'Y':
02867 if (oldch != ch)
02868 {
02869 if (emcStatus->task.mode == EMC_TASK_MODE_MDI)
02870 {
02871 typing = 1;
02872 typeindex = 1;
02873 typebuffer[0] = ch;
02874 typebuffer[1] = 0;
02875 interactive = IACT_MDI;
02876
02877 critFlag = 1;
02878 mvwaddstr(window, wmaxy, wbegx, line_blank);
02879 mvwaddstr(window, wmaxy, wbegx, "mdi command: ");
02880 waddch(window, ch);
02881 wrefresh(window);
02882 critFlag = 0;
02883 }
02884 else
02885 {
02886 axisSelected = AXIS_Y;
02887 }
02888 }
02889 break;
02890
02891 case 'z':
02892 case 'Z':
02893 if (oldch != ch)
02894 {
02895 if (emcStatus->task.mode == EMC_TASK_MODE_MDI)
02896 {
02897 typing = 1;
02898 typeindex = 1;
02899 typebuffer[0] = ch;
02900 typebuffer[1] = 0;
02901 interactive = IACT_MDI;
02902
02903 critFlag = 1;
02904 mvwaddstr(window, wmaxy, wbegx, line_blank);
02905 mvwaddstr(window, wmaxy, wbegx, "mdi command: ");
02906 waddch(window, ch);
02907 wrefresh(window);
02908 critFlag = 0;
02909 }
02910 else
02911 {
02912 axisSelected = AXIS_Z;
02913 }
02914 }
02915 break;
02916
02917 case 'i': // incremental jog toggle
02918 case 'I':
02919 if (jogMode == JOG_INCREMENTAL)
02920 {
02921 jogIncrement *= 10.0;
02922 if (jogIncrement >= 0.9)
02923 {
02924 jogIncrement = 0.0001;
02925 }
02926 }
02927 jogMode = JOG_INCREMENTAL;
02928 break;
02929
02930 case 'c': // continuous jog
02931 case 'C':
02932 if (oldch != ch)
02933 {
02934 jogMode = JOG_CONTINUOUS;
02935 }
02936 break;
02937
02938 case '<':
02939 case ',':
02940 if (window == logwin)
02941 {
02942 if (logtab == LOG_TYPE)
02943 {
02944 if (saveLogType == EMC_LOG_TYPE_AXIS_POS)
02945 {
02946 saveLogType = EMC_LOG_TYPE_AXIS_VEL;
02947 }
02948 else if (saveLogType == EMC_LOG_TYPE_AXIS_VEL)
02949 {
02950 saveLogType = EMC_LOG_TYPE_AXES_OUTPOS;
02951 }
02952 else if (saveLogType == EMC_LOG_TYPE_AXES_OUTPOS)
02953 {
02954 saveLogType = EMC_LOG_TYPE_AXES_INPOS;
02955 }
02956 else if (saveLogType == EMC_LOG_TYPE_AXES_INPOS)
02957 {
02958 saveLogType = EMC_LOG_TYPE_AXES_FERROR;
02959 }
02960 else
02961 {
02962 saveLogType = EMC_LOG_TYPE_AXIS_POS;
02963 }
02964 }
02965 else if (logtab == LOG_SIZE)
02966 {
02967 if (saveLogSize <= 10)
02968 {
02969 saveLogSize -= 1;
02970 if (saveLogSize <= 0)
02971 saveLogSize = 1;
02972 }
02973 else if (saveLogSize <= 100)
02974 {
02975 saveLogSize = saveLogSize - saveLogSize % 10;
02976 saveLogSize -= 10;
02977 }
02978 else if (saveLogSize <= 1000)
02979 {
02980 saveLogSize = saveLogSize - saveLogSize % 100;
02981 saveLogSize -= 100;
02982 }
02983 else
02984 {
02985 saveLogSize = saveLogSize - saveLogSize % 1000;
02986 saveLogSize -= 1000;
02987 }
02988 }
02989 else if (logtab == LOG_SKIP)
02990 {
02991 if (--saveLogSkip < 0)
02992 {
02993 saveLogSkip = 0;
02994 }
02995 }
02996 else if (logtab == LOG_AXIS)
02997 {
02998 if (--saveLogAxis < 0)
02999 {
03000 saveLogAxis = 2; // X rolls back to Z
03001 }
03002 }
03003 }
03004 else if (window == diagwin)
03005 {
03006 if (diagtab == DIAG_USECS)
03007 {
03008 usecs -= 10000;
03009 if (usecs < 10000)
03010 usecs = 10000;
03011
03012 startTimer(usecs);
03013 }
03014 else if (diagtab == DIAG_FIRST_KEYUP_DELAY)
03015 {
03016 FIRST_KEYUP_DELAY -= 10000;
03017 if (FIRST_KEYUP_DELAY <= 0)
03018 FIRST_KEYUP_DELAY = 0;
03019 }
03020 else
03021 {
03022 NEXT_KEYUP_DELAY -= 10000;
03023 if (NEXT_KEYUP_DELAY <= 0)
03024 NEXT_KEYUP_DELAY = 0;
03025 }
03026 }
03027 else
03028 {
03029 jogSpeed -= 1;
03030 if (jogSpeed < 1)
03031 jogSpeed = 1;
03032 }
03033 break;
03034
03035 case '>':
03036 case '.':
03037 if (window == logwin)
03038 {
03039 if (logtab == LOG_TYPE)
03040 {
03041 if (saveLogType == EMC_LOG_TYPE_AXIS_POS)
03042 {
03043 saveLogType = EMC_LOG_TYPE_AXES_FERROR;
03044 }
03045 else if (saveLogType == EMC_LOG_TYPE_AXES_FERROR)
03046 {
03047 saveLogType = EMC_LOG_TYPE_AXES_INPOS;
03048 }
03049 else if (saveLogType == EMC_LOG_TYPE_AXES_INPOS)
03050 {
03051 saveLogType = EMC_LOG_TYPE_AXES_OUTPOS;
03052 }
03053 else if (saveLogType == EMC_LOG_TYPE_AXES_OUTPOS)
03054 {
03055 saveLogType = EMC_LOG_TYPE_AXIS_VEL;
03056 }
03057 else
03058 {
03059 saveLogType = EMC_LOG_TYPE_AXIS_POS;
03060 }
03061 }
03062 else if (logtab == LOG_SIZE)
03063 {
03064 if (saveLogSize < 10)
03065 {
03066 saveLogSize += 1;
03067 }
03068 else if (saveLogSize < 100)
03069 {
03070 saveLogSize += 10;
03071 saveLogSize = saveLogSize - saveLogSize % 10;
03072 }
03073 else if (saveLogSize < 1000)
03074 {
03075 saveLogSize += 100;
03076 saveLogSize = saveLogSize - saveLogSize % 100;
03077 }
03078 else
03079 {
03080 saveLogSize += 1000;
03081 saveLogSize = saveLogSize - saveLogSize % 1000;
03082 }
03083 }
03084 else if (logtab == LOG_SKIP)
03085 {
03086 saveLogSkip++;
03087 }
03088 else if (logtab == LOG_AXIS)
03089 {
03090 if (++saveLogAxis > 2)
03091 {
03092 saveLogAxis = 0; // Z rolls back to X
03093 }
03094 }
03095 }
03096 else if (window == diagwin)
03097 {
03098 if (diagtab == DIAG_USECS)
03099 {
03100 usecs += 10000;
03101 if (usecs > 900000)
03102 usecs = 900000;
03103
03104 startTimer(usecs);
03105 }
03106 else if (diagtab == DIAG_FIRST_KEYUP_DELAY)
03107 {
03108 FIRST_KEYUP_DELAY += 10000;
03109 }
03110 else
03111 {
03112 NEXT_KEYUP_DELAY += 10000;
03113 }
03114 }
03115 else
03116 {
03117 jogSpeed += 1;
03118 if (jogSpeed > TRAJ_MAX_VELOCITY * 60.0)
03119 {
03120 jogSpeed = TRAJ_MAX_VELOCITY * 60.0;
03121 }
03122 }
03123 break;
03124
03125 case '0':
03126 case '1':
03127 case '2':
03128 case '3':
03129 case '4':
03130 case '5':
03131 case '6':
03132 case '7':
03133 case '8':
03134 case '9':
03135 // feed override
03136 if (oldch != ch)
03137 {
03138 if (ch == '0')
03139 {
03140 emc_traj_set_scale_msg.scale = 1.0;
03141 }
03142 else
03143 {
03144 emc_traj_set_scale_msg.scale = double (ch - '1' + 1) / 10.0;
03145 }
03146 emc_traj_set_scale_msg.serial_number = ++emcCommandSerialNumber;
03147 emcCommandBuffer->write(emc_traj_set_scale_msg);
03148 emcCommandWait(emcCommandSerialNumber);
03149 }
03150 break;
03151
03152 case 'b': // spindle brake off
03153 if (oldch != ch)
03154 {
03155 emc_spindle_brake_release_msg.serial_number = ++emcCommandSerialNumber;
03156 emcCommandBuffer->write(emc_spindle_brake_release_msg);
03157 emcCommandWait(emcCommandSerialNumber);
03158 }
03159 break;
03160
03161 case 'B': // spindle brake on
03162 if (oldch != ch)
03163 {
03164 emc_spindle_brake_engage_msg.serial_number = ++emcCommandSerialNumber;
03165 emcCommandBuffer->write(emc_spindle_brake_engage_msg);
03166 emcCommandWait(emcCommandSerialNumber);
03167 }
03168 break;
03169
03170 case 'o':
03171 case 'O':
03172 if (oldch != ch)
03173 {
03174 if (emcStatus->task.mode != EMC_TASK_MODE_AUTO)
03175 break;
03176
03177 typing = 1;
03178 strcpy(typebuffer, programPrefix);
03179 typeindex = strlen(programPrefix);
03180 interactive = IACT_OPEN;
03181
03182 critFlag = 1;
03183 mvwaddstr(window, wmaxy, wbegx, line_blank);
03184 mvwaddstr(window, wmaxy, wbegx, "program to open: ");
03185 waddstr(window, typebuffer);
03186 wrefresh(window);
03187 critFlag = 0;
03188 }
03189 break;
03190
03191 case 'r':
03192 case 'R':
03193 if (oldch != ch)
03194 {
03195 if (emcStatus->task.mode != EMC_TASK_MODE_AUTO)
03196 break;
03197
03198 if (! programOpened)
03199 {
03200 // send a request to open the last one
03201 strcpy(task_plan_open_msg.file, programFile);
03202 task_plan_open_msg.serial_number = ++emcCommandSerialNumber;
03203 emcCommandBuffer->write(task_plan_open_msg);
03204 emcCommandWait(emcCommandSerialNumber);
03205 }
03206 task_plan_run_msg.serial_number = ++emcCommandSerialNumber;
03207 task_plan_run_msg.line = 0;
03208 emcCommandBuffer->write(task_plan_run_msg);
03209 emcCommandWait(emcCommandSerialNumber);
03210 programOpened = 0;
03211 }
03212 break;
03213
03214 case 'p':
03215 case 'P':
03216 if (oldch != ch)
03217 {
03218 task_plan_pause_msg.serial_number = ++emcCommandSerialNumber;
03219 emcCommandBuffer->write(task_plan_pause_msg);
03220 emcCommandWait(emcCommandSerialNumber);
03221 }
03222 break;
03223
03224 case 's':
03225 case 'S':
03226 if (oldch != ch)
03227 {
03228 task_plan_resume_msg.serial_number = ++emcCommandSerialNumber;
03229 emcCommandBuffer->write(task_plan_resume_msg);
03230 emcCommandWait(emcCommandSerialNumber);
03231 }
03232 break;
03233
03234 case 'a':
03235 case 'A':
03236 if (oldch != ch)
03237 {
03238 task_plan_step_msg.serial_number = ++emcCommandSerialNumber;
03239 emcCommandBuffer->write(task_plan_step_msg);
03240 emcCommandWait(emcCommandSerialNumber);
03241 }
03242 break;
03243
03244 case 'u':
03245 if (oldch != ch)
03246 {
03247 emc_lube_off_msg.serial_number = ++emcCommandSerialNumber;
03248 emcCommandBuffer->write(emc_lube_off_msg);
03249 emcCommandWait(emcCommandSerialNumber);
03250 }
03251 break;
03252
03253 case 'U':
03254 if (oldch != ch)
03255 {
03256 emc_lube_on_msg.serial_number = ++emcCommandSerialNumber;
03257 emcCommandBuffer->write(emc_lube_on_msg);
03258 emcCommandWait(emcCommandSerialNumber);
03259 }
03260 break;
03261
03262 case '\'':
03263 case '\"':
03264 if (oldch != ch)
03265 {
03266 if (emcStatus->task.mode != EMC_TASK_MODE_MDI)
03267 break;
03268
03269 typing = 1;
03270 interactive = IACT_MDI;
03271
03272 // stuff last command
03273 strcpy(typebuffer, lastmdi);
03274 typeindex = strlen(typebuffer);
03275
03276 critFlag = 1;
03277 mvwaddstr(window, wmaxy, wbegx, line_blank);
03278 mvwaddstr(window, wmaxy, wbegx, "mdi command: ");
03279 waddstr(window, typebuffer);
03280 wrefresh(window);
03281 critFlag = 0;
03282 }
03283 break;
03284
03285 case 'm':
03286 case 'M':
03287 case 'g':
03288 case 'G':
03289 if (oldch != ch)
03290 {
03291 if (emcStatus->task.mode != EMC_TASK_MODE_MDI)
03292 break;
03293
03294 typing = 1;
03295 typeindex = 1;
03296 typebuffer[0] = ch;
03297 typebuffer[1] = 0;
03298 interactive = IACT_MDI;
03299
03300 critFlag = 1;
03301 mvwaddstr(window, wmaxy, wbegx, line_blank);
03302 mvwaddstr(window, wmaxy, wbegx, "mdi command: ");
03303 waddch(window, ch);
03304 wrefresh(window);
03305 critFlag = 0;
03306 }
03307 break;
03308
03309 case 'l':
03310 case 'L':
03311 if (oldch != ch)
03312 {
03313 typing = 1;
03314 typeindex = 0;
03315 interactive = IACT_LOAD_TOOL;
03316
03317 critFlag = 1;
03318 mvwaddstr(window, wmaxy, wbegx, line_blank);
03319 mvwaddstr(window, wmaxy, wbegx, "tool file to load: ");
03320 wrefresh(window);
03321 critFlag = 0;
03322 }
03323 break;
03324
03325 default:
03326 break;
03327 } // end of second switch (ch)
03328
03329 } // end of while (! done)
03330
03331 // call ^C signal handler directly to terminate cleanly
03332 quit(0);
03333
03334 return 0;
03335 }
|
|
||||||||||||||||
|
Definition at line 89 of file keystick.cc. 00090 {
00091 char string[SYSTEM_STRING_LEN];
00092 int retval;
00093
00094 if (logfile == 0)
00095 {
00096 return -1;
00097 }
00098
00099 switch (logtype)
00100 {
00101 case EMC_LOG_TYPE_AXIS_POS:
00102 case EMC_LOG_TYPE_AXIS_VEL:
00103 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);
00104 break;
00105
00106 case EMC_LOG_TYPE_AXES_INPOS:
00107 case EMC_LOG_TYPE_AXES_OUTPOS:
00108 sprintf(string, "%s '{print $2 \" \" $3}' < %s 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, XGRAPH_PATH);
00109 break;
00110
00111 case EMC_LOG_TYPE_AXES_FERROR:
00112 /* we want to compose:
00113 ( awk '{print $1 " " $2}' < emc.log ; echo "" ; awk '{print $1 " " $3}' < emc.log ; echo "" ; awk '{print $1 " " $4}' < emc.log ) 2> /dev/null | xgraph -m 1> /dev/null 2> /dev/null"
00114 */
00115 sprintf(string, "( %s '{print $1 \" \" $2}' < %s ; echo \"\" ; %s '{print $1 \" \" $3}' < %s ; echo \"\" ; %s '{print $1 \" \" $4}' < %s ) 2> /dev/null | %s -m 1> /dev/null 2> /dev/null", AWK_PATH, logfile, AWK_PATH, logfile, AWK_PATH, logfile, XGRAPH_PATH);
00116 break;
00117
00118 default:
00119 return -1;
00120 break;
00121 }
00122
00123 retval = system(string);
00124
00125 return retval;
00126 }
|
|
|
Definition at line 390 of file keystick.cc. 00391 {
00392 int savey, savex;
00393 chtype saveattr;
00394
00395 // log to error file
00396 if (NULL != errorFp)
00397 {
00398 fprintf(errorFp, "%f\t%s\n", etime(), errstring);
00399 }
00400
00401 if (0 == window)
00402 {
00403 // no window yet
00404 return;
00405 }
00406
00407 critFlag = 1;
00408
00409 getyx(window, savey, savex);
00410 saveattr = getattrs(window);
00411
00412 mvwaddstr(window, ERR_Y, ERR_X, line_blank);
00413 wattrset(window, A_BOLD);
00414 mvwaddstr(window, ERR_Y, ERR_X, errstring);
00415 wattrset(window, (int) saveattr);
00416 wmove(window, savey, savex);
00417 wrefresh(window);
00418
00419 critFlag = 0;
00420 }
|
|
|
Definition at line 321 of file keystick.cc. Referenced by printStatus().
00322 {
00323 wattrset(window, A_BOLD);
00324 mvwaddstr(window, 0, 1, "F1 ");
00325 mvwaddstr(window, 1, 1, "F2 ");
00326 mvwaddstr(window, 2, 1, "F3 ");
00327 mvwaddstr(window, 3, 1, "F4 ");
00328 mvwaddstr(window, 0, 21, "F5 ");
00329 mvwaddstr(window, 1, 21, "F6 ");
00330 mvwaddstr(window, 2, 21, "F7 ");
00331 mvwaddstr(window, 3, 21, "F8 ");
00332 mvwaddstr(window, 0, 41, "F9 ");
00333 mvwaddstr(window, 1, 41, "F10");
00334 mvwaddstr(window, 2, 41, "F11");
00335 mvwaddstr(window, 3, 41, "F12");
00336 mvwaddstr(window, 0, 61, "ESC");
00337 mvwaddstr(window, 1, 61, "TAB");
00338 mvwaddstr(window, 2, 61, "END");
00339 mvwaddstr(window, 3, 61, " ? ");
00340
00341 wattrset(window, 0);
00342 mvwaddstr(window, 0, 5, "Estop On/Off ");
00343 mvwaddstr(window, 1, 5, "Machine On/Off");
00344 mvwaddstr(window, 2, 5, "Manual Mode ");
00345 mvwaddstr(window, 3, 5, "Auto Mode ");
00346
00347 mvwaddstr(window, 0, 25, "MDI Mode ");
00348 mvwaddstr(window, 1, 25, "Reset Interp ");
00349 mvwaddstr(window, 2, 25, "Mist On/Off ");
00350 mvwaddstr(window, 3, 25, "Flood On/Off ");
00351
00352 mvwaddstr(window, 0, 45, "Spndl Fwd/Off ");
00353 mvwaddstr(window, 1, 45, "Spndl Rev/Off ");
00354 mvwaddstr(window, 2, 45, "Spndl Decrease");
00355 mvwaddstr(window, 3, 45, "Spndl Increase");
00356
00357 mvwaddstr(window, 0, 65, "Aborts Actions");
00358 mvwaddstr(window, 1, 65, "Selects Params");
00359 mvwaddstr(window, 2, 65, "Quits Display ");
00360 mvwaddstr(window, 3, 65, "Toggles Help ");
00361 }
|
|
|
Definition at line 422 of file keystick.cc. Referenced by alarmHandler(), and main().
00423 {
00424 int savey, savex;
00425 int t;
00426 int line;
00427 int override;
00428 int len;
00429 int code;
00430
00431 getyx(window, savey, savex);
00432
00433 if (window == helpwin)
00434 {
00435 printFkeys();
00436
00437 wattrset(window, 0);
00438 mvwaddstr(window, 5, 1, "x/X y/Y z/Z");
00439 mvwaddstr(window, 6, 1, "HOME");
00440 mvwaddstr(window, 7, 1, "< > or , .");
00441 mvwaddstr(window, 8, 1, "1-9, 0");
00442 mvwaddstr(window, 9, 1, "<- arrow keys ->");
00443 mvwaddstr(window, 10, 1, "^ arrow keys V");
00444 mvwaddstr(window, 11, 1, "PageUp/PageDown");
00445 mvwaddstr(window, 12, 1, "c/C");
00446 mvwaddstr(window, 13, 1, "i/I");
00447 mvwaddstr(window, 14, 1, "#");
00448 mvwaddstr(window, 15, 1, "@");
00449
00450 wattrset(window, A_UNDERLINE);
00451 mvwaddstr(window, 5, 19, "selects axis");
00452 mvwaddstr(window, 6, 19, "homes selected axis");
00453 mvwaddstr(window, 7, 19, "change jog speed");
00454 mvwaddstr(window, 8, 19, "10%-90%, 100% feed");
00455 mvwaddstr(window, 9, 19, "jog X");
00456 mvwaddstr(window, 10, 19, "jog Y");
00457 mvwaddstr(window, 11, 19, "jog Z");
00458 mvwaddstr(window, 12, 19, "sets continuous jog");
00459 mvwaddstr(window, 13, 19, "toggles incr jog");
00460 mvwaddstr(window, 14, 19, "toggles abs/rel");
00461 mvwaddstr(window, 15, 19, "toggles cmd/act");
00462
00463 wattrset(window, 0);
00464 mvwaddstr(window, 5, 41, "B");
00465 mvwaddstr(window, 6, 41, "b");
00466 mvwaddstr(window, 7, 41, "o/O");
00467 mvwaddstr(window, 8, 41, "r/R");
00468 mvwaddstr(window, 9, 41, "p/P");
00469 mvwaddstr(window, 10, 41, "s/S");
00470 mvwaddstr(window, 11, 41, "quote/XYZGM");
00471 mvwaddstr(window, 12, 41, "l/L");
00472 mvwaddstr(window, 13, 41, "u/U");
00473
00474 wattrset(window, A_UNDERLINE);
00475 mvwaddstr(window, 5, 54, "turns spindle brake on");
00476 mvwaddstr(window, 6, 54, "turns spindle brake off");
00477 mvwaddstr(window, 7, 54, "prompts for program");
00478 mvwaddstr(window, 8, 54, "runs selected program");
00479 mvwaddstr(window, 9, 54, "pauses motion");
00480 mvwaddstr(window, 10, 54, "starts motion again");
00481 mvwaddstr(window, 11, 54, "prompts for MDI command");
00482 mvwaddstr(window, 12, 54, "prompts for tool table");
00483 mvwaddstr(window, 13, 54, "turns lube off/on");
00484
00485 if (error_string[0] != 0)
00486 {
00487 printError(error_string);
00488 }
00489
00490 wattrset(window, A_REVERSE);
00491 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
00492 wattrset(window, 0);
00493
00494 // restore cursor position
00495 wmove(window, savey, savex);
00496 wrefresh(window);
00497 }
00498 else if (window == diagwin)
00499 {
00500 wattrset(window, A_BOLD);
00501 mvwaddstr(window, 0, 34, "Diagnostics");
00502
00503 wattrset(window, 0);
00504 mvwaddstr(window, 2, 1, "Task Heartbeat/Cmd:");
00505 mvwaddstr(window, 3, 1, "IO Heartbeat/Cmd:");
00506 mvwaddstr(window, 4, 1, "Motion Heartbeat/Cmd:");
00507
00508 if (diagtab == DIAG_USECS)
00509 wattrset(window, A_BOLD);
00510 mvwaddstr(window, 6, 1, "Polling Period (usecs):");
00511 wattrset(window, 0);
00512 if (diagtab == DIAG_FIRST_KEYUP_DELAY)
00513 wattrset(window, A_BOLD);
00514 mvwaddstr(window, 7, 1, "Kbd Delay Until Repeat:");
00515 wattrset(window, 0);
00516 if (diagtab == DIAG_NEXT_KEYUP_DELAY)
00517 wattrset(window, A_BOLD);
00518 mvwaddstr(window, 8, 1, "Kbd Delay Between Repeats:");
00519 wattrset(window, 0);
00520
00521 mvwaddstr(window, 10, 1, "Task Execution State:");
00522
00523 mvwaddstr(window, 12, 1, "Traj Scale:");
00524 mvwaddstr(window, 13, 1, "X Scale:");
00525 mvwaddstr(window, 14, 1, "Y Scale:");
00526 mvwaddstr(window, 15, 1, "Z Scale:");
00527
00528 mvwaddstr(window, 17, 1, "V/Max V:");
00529 mvwaddstr(window, 18, 1, "A/Max A:");
00530
00531 wattrset(window, A_UNDERLINE);
00532
00533 sprintf(scratch_string, "%10d %10d %10d", emcStatus->task.heartbeat,
00534 emcStatus->echo_serial_number,
00535 emcStatus->status);
00536 mvwaddstr(window, 2, 28, scratch_string);
00537 sprintf(scratch_string, "%10d %10d", emcStatus->io.heartbeat,
00538 emcStatus->io.echo_serial_number);
00539 mvwaddstr(window, 3, 28, scratch_string);
00540 sprintf(scratch_string, "%10d %10d", emcStatus->motion.heartbeat,
00541 emcStatus->motion.echo_serial_number);
00542 mvwaddstr(window, 4, 28, scratch_string);
00543
00544 sprintf(scratch_string, "%10d", usecs);
00545 mvwaddstr(window, 6, 28, scratch_string);
00546 sprintf(scratch_string, "%10d", FIRST_KEYUP_DELAY);
00547 mvwaddstr(window, 7, 28, scratch_string);
00548 sprintf(scratch_string, "%10d", NEXT_KEYUP_DELAY);
00549 mvwaddstr(window, 8, 28, scratch_string);
00550
00551 sprintf(scratch_string, "%10d", emcStatus->task.execState);
00552 mvwaddstr(window, 10, 28, scratch_string);
00553
00554 sprintf(scratch_string, "%10.3f", emcStatus->motion.traj.scale);
00555 mvwaddstr(window, 12, 28, scratch_string);
00556 sprintf(scratch_string, "%10.3f", emcStatus->motion.axis[0].scale);
00557 mvwaddstr(window, 13, 28, scratch_string);
00558 sprintf(scratch_string, "%10.3f", emcStatus->motion.axis[1].scale);
00559 mvwaddstr(window, 14, 28, scratch_string);
00560 sprintf(scratch_string, "%10.3f", emcStatus->motion.axis[2].scale);
00561 mvwaddstr(window, 15, 28, scratch_string);
00562
00563 sprintf(scratch_string, "%10.3f%10.3f",
00564 emcStatus->motion.traj.velocity, emcStatus->motion.traj.maxVelocity);
00565 mvwaddstr(window, 17, 28, scratch_string);
00566 sprintf(scratch_string, "%10.3f%10.3f",
00567 emcStatus->motion.traj.acceleration, emcStatus->motion.traj.maxAcceleration);
00568 mvwaddstr(window, 18, 28, scratch_string);
00569
00570 wattrset(window, 0);
00571 if (error_string[0] != 0)
00572 {
00573 printError(error_string);
00574 }
00575
00576 wattrset(window, A_REVERSE);
00577 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
00578 wattrset(window, 0);
00579
00580 // restore cursor position
00581 wmove(window, savey, savex);
00582 wrefresh(window);
00583 }
00584 else if (window == toolwin)
00585 {
00586 wattrset(window, A_BOLD);
00587 mvwaddstr(window, 0, 34, "Tool Table");
00588
00589 wattrset(window, 0);
00590 mvwaddstr(window, 2, 1, "Pocket ID Length Diameter");
00591
00592 wattrset(window, A_UNDERLINE);
00593 line = 4;
00594 for (t = 0; t < CANON_TOOL_MAX; t++)
00595 {
00596 if (emcStatus->io.tool.toolTable[t].id != 0)
00597 {
00598 sprintf(scratch_string, "%4d%10d%10.4f%10.4f",
00599 t,
00600 emcStatus->io.tool.toolTable[t].id,
00601 emcStatus->io.tool.toolTable[t].length,
00602 emcStatus->io.tool.toolTable[t].diameter);
00603 mvwaddstr(window, line++, 3, scratch_string);
00604 }
00605 }
00606
00607 wattrset(window, 0);
00608 if (error_string[0] != 0)
00609 {
00610 printError(error_string);
00611 }
00612
00613 wattrset(window, A_REVERSE);
00614 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
00615 wattrset(window, 0);
00616
00617 // restore cursor position
00618 wmove(window, savey, savex);
00619 wrefresh(window);
00620 }
00621 else if (window == logwin)
00622 {
00623 wattrset(window, A_BOLD);
00624 mvwaddstr(window, 0, 34, "Data Logging");
00625
00626 wattrset(window, 0);
00627 mvwaddstr(window, 4, 0, line_blank);
00628 mvwaddstr(window, 4, 1, "File:");
00629
00630 mvwaddstr(window, 5, 1, "Points:");
00631
00632 if (logtab == LOG_TYPE)
00633 wattrset(window, A_BOLD);
00634 mvwaddstr(window, 6, 1, "Type:");
00635 wattrset(window, 0);
00636
00637 if (logtab == LOG_SIZE)
00638 wattrset(window, A_BOLD);
00639 mvwaddstr(window, 7, 1, "Size:");
00640 wattrset(window, 0);
00641
00642 if (logtab == LOG_SKIP)
00643 wattrset(window, A_BOLD);
00644 mvwaddstr(window, 8, 1, "Skip:");
00645 wattrset(window, 0);
00646
00647 if (saveLogType == EMC_LOG_TYPE_AXIS_POS)
00648 {
00649 if (logtab == LOG_AXIS)
00650 wattrset(window, A_BOLD);
00651 mvwaddstr(window, 9, 1, "Axis:");
00652 wattrset(window, 0);
00653 }
00654 else
00655 {
00656 mvwaddstr(window, 9, 0, line_blank);
00657 }
00658
00659 wattrset(window, A_UNDERLINE);
00660
00661 // print open/closed/logging
00662 if (emcStatus->logOpen)
00663 {
00664 wattrset(window, A_REVERSE);
00665 strcpy(scratch_string, " OPEN ");
00666 }
00667 else
00668 {
00669 wattrset(window, A_UNDERLINE);
00670 strcpy(scratch_string, "CLOSED");
00671 }
00672 mvwaddstr(window, 2, 28, scratch_string);
00673
00674 if (emcStatus->logStarted)
00675 {
00676 wattrset(window, A_REVERSE);
00677 strcpy(scratch_string, " LOGGING ");
00678 }
00679 else
00680 {
00681 wattrset(window, A_UNDERLINE);
00682 strcpy(scratch_string, "NOT LOGGING");
00683 }
00684 mvwaddstr(window, 2, 46, scratch_string);
00685
00686 wattrset(window, A_UNDERLINE);
00687
00688 // print file string
00689 mvwaddstr(window, 4, 28, saveLogFile);
00690
00691 // compose and print log point number
00692 sprintf(scratch_string, "%-10d", emcStatus->logPoints);
00693 mvwaddstr(window, 5, 28, scratch_string);
00694
00695 // compose and print log type
00696 switch (saveLogType)
00697 {
00698 case 0:
00699 strcpy(scratch_string, " ");
00700 break;
00701
00702 case EMC_LOG_TYPE_AXIS_POS:
00703 strcpy(scratch_string, "AXIS INPUT/OUTPUT");
00704 break;
00705
00706 case EMC_LOG_TYPE_AXES_INPOS:
00707 strcpy(scratch_string, "INPUT POSITION ");
00708 break;
00709
00710 case EMC_LOG_TYPE_AXES_OUTPOS:
00711 strcpy(scratch_string, "OUTPUT POSITION ");
00712 break;
00713
00714 case EMC_LOG_TYPE_AXIS_VEL:
00715 strcpy(scratch_string, "AXIS CMD/ACT VEL ");
00716 break;
00717
00718 case EMC_LOG_TYPE_AXES_FERROR:
00719 strcpy(scratch_string, "FOLLOWING ERROR ");
00720 break;
00721
00722 default:
00723 sprintf(scratch_string, "%-17d", saveLogType);
00724 break;
00725 }
00726 mvwaddstr(window, 6, 28, scratch_string);
00727
00728 // compose and print log size
00729 sprintf(scratch_string, "%-10d", saveLogSize);
00730 mvwaddstr(window, 7, 28, scratch_string);
00731
00732 // compose and print log skip
00733 sprintf(scratch_string, "%-10d", saveLogSkip);
00734 mvwaddstr(window, 8, 28, scratch_string);
00735
00736 // compose and print log axis
00737 if (saveLogType == EMC_LOG_TYPE_AXIS_POS)
00738 {
00739 sprintf(scratch_string, "%s",
00740 saveLogAxis == 0 ? "X" :
00741 saveLogAxis == 1 ? "Y" :
00742 saveLogAxis == 2 ? "Z" : "?");
00743 mvwaddstr(window, 9, 28, scratch_string);
00744 }
00745
00746 wattrset(window, 0);
00747 if (error_string[0] != 0)
00748 {
00749 printError(error_string);
00750 }
00751
00752 wattrset(window, A_REVERSE);
00753 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
00754 wattrset(window, 0);
00755
00756 // restore cursor position
00757 wmove(window, savey, savex);
00758 wrefresh(window);
00759 }
00760 else if (window == progwin)
00761 {
00762 mvwaddstr(window, 0, 0, line_blank);
00763 wattrset(window, A_BOLD);
00764 if (emcStatus->task.file[0] == 0)
00765 {
00766 mvwaddstr(window, 0, 36, "(no program)");
00767 }
00768 else
00769 {
00770 mvwaddstr(window, 0, 36, emcStatus->task.file);
00771 }
00772 wattrset(window, 0);
00773
00774 if (emcStatus->task.currentLine > 0)
00775 {
00776 if (emcStatus->task.motionLine > 0 &&
00777 emcStatus->task.motionLine < emcStatus->task.currentLine)
00778 {
00779 programActiveLine = emcStatus->task.motionLine;
00780 }
00781 else
00782 {
00783 programActiveLine = emcStatus->task.currentLine;
00784 }
00785
00786 if (programFp != 0)
00787 {
00788 if (programFpLine > programActiveLine)
00789 {
00790 rewind(programFp);
00791 programFpLine = 0;
00792 programLineText[0] = 0;
00793 }
00794
00795 // fast forward over past lines
00796 while (programFpLine < programActiveLine)
00797 {
00798 fgets(programLineText, EMC_TASK_COMMAND_LEN, programFp);
00799 programFpLine++;
00800 }
00801
00802 // now we have the current line
00803 wattrset(window, A_BOLD);
00804 for (t = 0; t < 20; t++)
00805 {
00806 // knock off CR, LF
00807 len = strlen(programLineText) - 1;
00808 while (len >= 0)
00809 {
00810 if (isspace(programLineText[len]))
00811 {
00812 programLineText[len] = 0;
00813 len--;
00814 }
00815 else
00816 {
00817 break;
00818 }
00819 }
00820
00821 // print this line
00822 mvwaddstr(window, t+2, wbegx, line_blank);
00823 mvwaddstr(window, t+2, wbegx, programLineText);
00824 wattrset(window, 0);
00825
00826 // get the next line
00827 if (NULL != fgets(programLineText, EMC_TASK_COMMAND_LEN, programFp))
00828 {
00829 programFpLine++;
00830 }
00831 else
00832 {
00833 // make it a blank line to clear any old stuff
00834 strcpy(programLineText, line_blank);
00835 }
00836 }
00837 }
00838 else
00839 {
00840 programLineText[0] = 0;
00841 }
00842 }
00843 else
00844 {
00845 programActiveLine = 0;
00846 programLineText[0] = 0;
00847 line_string[0] = 0;
00848 }
00849
00850 wattrset(window, 0);
00851 if (error_string[0] != 0)
00852 {
00853 printError(error_string);
00854 }
00855
00856 wattrset(window, A_REVERSE);
00857 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
00858 wattrset(window, 0);
00859
00860 // restore cursor position
00861 wmove(window, savey, savex);
00862 wrefresh(window);
00863 }
00864 else // if (window == stdscr)
00865 {
00866 // print the function key labels
00867 printFkeys();
00868
00869 // print the status labels
00870
00871 wattrset(window, 0);
00872
00873 mvwaddstr(window, 6, 1, "Override:");
00874 mvwaddstr(window, 7, 1, "Tool:");
00875 mvwaddstr(window, 8, 1, "Offset:");
00876
00877 mvwaddstr(window, 7, 61, "Speed:");
00878 mvwaddstr(window, 8, 61, "Incr: ");
00879
00880 strcpy(scratch_string, "--X--");
00881 if (emcStatus->motion.axis[0].minHardLimit)
00882 scratch_string[0] = '*';
00883 if (emcStatus->motion.axis[0].minSoftLimit)
00884 scratch_string[1] = '*';
00885 if (emcStatus->motion.axis[0].maxSoftLimit)
00886 scratch_string[3] = '*';
00887 if (emcStatus->motion.axis[0].maxHardLimit)
00888 scratch_string[4] = '*';
00889 mvwaddstr(window, 10, 27, scratch_string);
00890
00891 strcpy(scratch_string, "--Y--");
00892 if (emcStatus->motion.axis[1].minHardLimit)
00893 scratch_string[0] = '*';
00894 if (emcStatus->motion.axis[1].minSoftLimit)
00895 scratch_string[1] = '*';
00896 if (emcStatus->motion.axis[1].maxSoftLimit)
00897 scratch_string[3] = '*';
00898 if (emcStatus->motion.axis[1].maxHardLimit)
00899 scratch_string[4] = '*';
00900 mvwaddstr(window, 10, 47, scratch_string);
00901
00902 strcpy(scratch_string, "--Z--");
00903 if (emcStatus->motion.axis[2].minHardLimit)
00904 scratch_string[0] = '*';
00905 if (emcStatus->motion.axis[2].minSoftLimit)
00906 scratch_string[1] = '*';
00907 if (emcStatus->motion.axis[2].maxSoftLimit)
00908 scratch_string[3] = '*';
00909 if (emcStatus->motion.axis[2].maxHardLimit)
00910 scratch_string[4] = '*';
00911 mvwaddstr(window, 10, 67, scratch_string);
00912
00913 if (coords == COORD_ABSOLUTE)
00914 {
00915 if (posDisplay == POS_DISPLAY_CMD)
00916 {
00917 mvwaddstr(window, 11, 1, "Absolute Cmd Pos:");
00918 }
00919 else
00920 {
00921 mvwaddstr(window, 11, 1, "Absolute Act Pos:");
00922 }
00923 mvwaddstr(window, 12, 0, line_blank);
00924 }
00925 else
00926 {
00927 coords = COORD_RELATIVE;
00928 if (posDisplay == POS_DISPLAY_CMD)
00929 {
00930 mvwaddstr(window, 11, 1, "Relative Cmd Pos:");
00931 }
00932 else
00933 {
00934 mvwaddstr(window, 11, 1, "Relative Act Pos:");
00935 }
00936 }
00937
00938 mvwaddstr(window, 14, 0, line_blank);
00939 mvwaddstr(window, 15, 0, line_blank);
00940 mvwaddstr(window, 16, 0, line_blank);
00941 mvwaddstr(window, 17, 0, line_blank);
00942 mvwaddstr(window, 18, 0, line_blank);
00943 mvwaddstr(window, 19, 0, line_blank);
00944 if (emcStatus->task.mode == EMC_TASK_MODE_AUTO)
00945 {
00946 mvwaddstr(window, 14, 1, "Program:");
00947 mvwaddstr(window, 15, 1, "Line:");
00948 mvwaddstr(window, 16, 1, "Command:");
00949 mvwaddstr(window, 17, 1, "Interpreter:");
00950 mvwaddstr(window, 18, 1, "Modal G Codes:");
00951 mvwaddstr(window, 19, 1, "Modal M Codes:");
00952 }
00953 else if (emcStatus->task.mode == EMC_TASK_MODE_MDI)
00954 {
00955 mvwaddstr(window, 16, 1, "Command:");
00956 mvwaddstr(window, 17, 1, "Interpreter:");
00957 mvwaddstr(window, 18, 1, "Modal G Codes:");
00958 mvwaddstr(window, 19, 1, "Modal M Codes:");
00959 }
00960
00961 // end of labels
00962
00963 // fill the status strings in
00964
00965 switch(emcStatus->task.state)
00966 {
00967 case EMC_TASK_STATE_OFF:
00968 sprintf(state_string, " OFF ");
00969 break;
00970 case EMC_TASK_STATE_ON:
00971 sprintf(state_string, " ON ");
00972 break;
00973 case EMC_TASK_STATE_ESTOP:
00974 sprintf(state_string, " ESTOP ");
00975 break;
00976 case EMC_TASK_STATE_ESTOP_RESET:
00977 sprintf(state_string, " ESTOP RESET ");
00978 break;
00979 default:
00980 sprintf(state_string, " ? ");
00981 break;
00982 }
00983
00984 switch(emcStatus->task.mode)
00985 {
00986 case EMC_TASK_MODE_MANUAL:
00987 sprintf(mode_string, " MANUAL ");
00988 break;
00989 case EMC_TASK_MODE_AUTO:
00990 sprintf(mode_string, " AUTO ");
00991 break;
00992 case EMC_TASK_MODE_MDI:
00993 sprintf(mode_string, " MDI ");
00994 break;
00995 default:
00996 sprintf(mode_string, " ? ");
00997 break;
00998 }
00999
01000 if (emcStatus->io.spindle.increasing > 0)
01001 sprintf(spindle_string, " SPINDLE INCREASE ");
01002 else if (emcStatus->io.spindle.increasing < 0)
01003 sprintf(spindle_string, " SPINDLE DECREASE ");
01004 else if (emcStatus->io.spindle.direction > 0)
01005 sprintf(spindle_string, " SPINDLE FORWARD ");
01006 else if (emcStatus->io.spindle.direction < 0)
01007 sprintf(spindle_string, " SPINDLE REVERSE ");
01008 else
01009 sprintf(spindle_string, " SPINDLE STOPPED ");
01010
01011 if (emcStatus->io.spindle.brake)
01012 sprintf(brake_string, " BRAKE ON ");
01013 else
01014 sprintf(brake_string, " BRAKE OFF ");
01015
01016 if (emcStatus->io.coolant.mist)
01017 sprintf(mist_string, " MIST ON ");
01018 else
01019 sprintf(mist_string, " MIST OFF ");
01020
01021 if (emcStatus->io.coolant.flood)
01022 sprintf(flood_string, " FLOOD ON ");
01023 else
01024 sprintf(flood_string, " FLOOD OFF ");
01025
01026 if (emcStatus->io.lube.on)
01027 sprintf(lube_on_string, " LUBE ON ");
01028 else
01029 sprintf(lube_on_string, " LUBE OFF ");
01030
01031 if (! emcStatus->io.lube.level)
01032 sprintf(lube_level_string, " LUBE OK ");
01033 else
01034 sprintf(lube_level_string, " LUBE LOW ");
01035
01036 sprintf(home_string, " --- HOMED ");
01037 if (emcStatus->motion.axis[0].homed)
01038 {
01039 home_string[4] = 'X';
01040 }
01041 if (emcStatus->motion.axis[1].homed)
01042 {
01043 home_string[5] = 'Y';
01044 }
01045 if (emcStatus->motion.axis[2].homed)
01046 {
01047 home_string[6] = 'Z';
01048 }
01049
01050 if (coords == COORD_ABSOLUTE)
01051 {
01052 if (posDisplay == POS_DISPLAY_ACT)
01053 {
01054 sprintf(pos_string, "%13.4f %18.4f %18.4f",
01055 emcStatus->motion.traj.actualPosition.tran.x,
01056 emcStatus->motion.traj.actualPosition.tran.y,
01057 emcStatus->motion.traj.actualPosition.tran.z);
01058 }
01059 else
01060 {
01061 sprintf(pos_string, "%13.4f %18.4f %18.4f",
01062 emcStatus->motion.traj.position.tran.x,
01063 emcStatus->motion.traj.position.tran.y,
01064 emcStatus->motion.traj.position.tran.z);
01065 }
01066 }
01067 else
01068 {
01069 coords = COORD_RELATIVE;
01070 if (posDisplay == POS_DISPLAY_ACT)
01071 {
01072 sprintf(pos_string, "%13.4f %18.4f %18.4f",
01073 emcStatus->motion.traj.actualPosition.tran.x -
01074 emcStatus->task.origin.tran.x,
01075 emcStatus->motion.traj.actualPosition.tran.y -
01076 emcStatus->task.origin.tran.y,
01077 emcStatus->motion.traj.actualPosition.tran.z -
01078 emcStatus->task.origin.tran.z -
01079 emcStatus->task.toolOffset.tran.z);
01080 }
01081 else
01082 {
01083 sprintf(pos_string, "%13.4f %18.4f %18.4f",
01084 emcStatus->motion.traj.position.tran.x -
01085 emcStatus->task.origin.tran.x,
01086 emcStatus->motion.traj.position.tran.y -
01087 emcStatus->task.origin.tran.y,
01088 emcStatus->motion.traj.position.tran.z -
01089 emcStatus->task.origin.tran.z -
01090 emcStatus->task.toolOffset.tran.z);
01091 }
01092 }
01093
01094 sprintf(origin_string, "%13.4f %18.4f %18.4f",
01095 emcStatus->task.origin.tran.x,
01096 emcStatus->task.origin.tran.y,
01097 emcStatus->task.origin.tran.z);
01098
01099 sprintf(speed_string, "%10.1f", jogSpeed);
01100 if (jogMode == JOG_INCREMENTAL)
01101 {
01102 sprintf(incr_string, "%10.4f", jogIncrement);
01103 }
01104 else
01105 {
01106 sprintf(incr_string, "continuous");
01107 }
01108
01109 if (! programOpened)
01110 {
01111 // print the last one opened, since we'll send this by default
01112 strcpy(prog_string, programFile);
01113 }
01114 else
01115 {
01116 // print the one the controller knows about
01117 strcpy(prog_string, emcStatus->task.file);
01118 }
01119
01120 if (emcStatus->task.currentLine > 0)
01121 {
01122 if (emcStatus->task.motionLine > 0 &&
01123 emcStatus->task.motionLine < emcStatus->task.currentLine)
01124 {
01125 programActiveLine = emcStatus->task.motionLine;
01126 }
01127 else
01128 {
01129 programActiveLine = emcStatus->task.currentLine;
01130 }
01131 sprintf(line_string, "%d", programActiveLine);
01132 if (programFp != 0)
01133 {
01134 if (programFpLine > programActiveLine)
01135 {
01136 rewind(programFp);
01137 programFpLine = 0;
01138 programLineText[0] = 0;
01139 }
01140
01141 // fast forward over past lines
01142 while (programFpLine < programActiveLine)
01143 {
01144 fgets(programLineText, EMC_TASK_COMMAND_LEN, programFp);
01145 programFpLine++;
01146 }
01147
01148 // now we have the current line
01149 // knock off CR, LF
01150 len = strlen(programLineText) - 1;
01151 while (len >= 0)
01152 {
01153 if (isspace(programLineText[len]))
01154 {
01155 programLineText[len] = 0;
01156 len--;
01157 }
01158 else
01159 {
01160 break;
01161 }
01162 }
01163 }
01164 else
01165 {
01166 programLineText[0] = 0;
01167 }
01168 }
01169 else
01170 {
01171 programActiveLine = 0;
01172 programLineText[0] = 0;
01173 line_string[0] = 0;
01174 }
01175
01176 switch (emcStatus->task.interpState)
01177 {
01178 case EMC_TASK_INTERP_IDLE:
01179 sprintf(interp_string, "%s", "IDLE ");
01180 break;
01181 case EMC_TASK_INTERP_READING:
01182 sprintf(interp_string, "%s", "RUNNING ");
01183 break;
01184 case EMC_TASK_INTERP_PAUSED:
01185 sprintf(interp_string, "%s", "PAUSED ");
01186 break;
01187 case EMC_TASK_INTERP_WAITING:
01188 sprintf(interp_string, "%s", "RUNNING ");
01189 break;
01190 default:
01191 sprintf(interp_string, "%s", "? ");
01192 break;
01193 }
01194
01195 // fill in the active G codes
01196 active_g_codes_string[0] = 0;
01197 for (t = 1; t < EMC_TASK_ACTIVE_G_CODES; t++)
01198 {
01199 code = emcStatus->task.activeGCodes[t];
01200 if (code == -1)
01201 continue;
01202 if (code % 10)
01203 sprintf(scratch_string, "G%.1f ", (double) code / 10.0);
01204 else
01205 sprintf(scratch_string, "G%d ", code / 10);
01206 strcat(active_g_codes_string, scratch_string);
01207 }
01208
01209 // fill in the active M codes, settings too
01210 active_m_codes_string[0] = 0;
01211 for (t = 1; t < EMC_TASK_ACTIVE_M_CODES; t++)
01212 {
01213 code = emcStatus->task.activeMCodes[t];
01214 if (code == -1)
01215 continue;
01216 sprintf(scratch_string, "M%d ", code);
01217 strcat(active_m_codes_string, scratch_string);
01218 }
01219 sprintf(scratch_string, "F%.0f ", emcStatus->task.activeSettings[1]);
01220 strcat(active_m_codes_string, scratch_string);
01221 sprintf(scratch_string, "S%.0f ", emcStatus->task.activeSettings[2]);
01222 strcat(active_m_codes_string, scratch_string);
01223
01224 // fill the screen in
01225
01226 override = (int) (emcStatus->motion.traj.scale * 100.0 + 0.5);
01227 sprintf(scratch_string, "%4d%%", override);
01228 if (override < 100)
01229 wattrset(window, A_BOLD);
01230 else
01231 wattrset(window, A_UNDERLINE);
01232 mvwaddstr(window, 6, 14, scratch_string);
01233
01234 sprintf(scratch_string, "%8d", emcStatus->io.tool.toolInSpindle);
01235 wattrset(window, A_UNDERLINE);
01236 mvwaddstr(window, 7, 11, scratch_string);
01237
01238 sprintf(scratch_string, "%8.4f", emcStatus->task.toolOffset.tran.z);
01239 wattrset(window, A_UNDERLINE);
01240 mvwaddstr(window, 8, 11, scratch_string);
01241
01242 wattrset(window, A_REVERSE);
01243
01244 mvwaddstr(window, 5, 1, state_string);
01245 mvwaddstr(window, 5, 21, mode_string);
01246 mvwaddstr(window, 6, 21, lube_on_string);
01247 mvwaddstr(window, 7, 21, lube_level_string);
01248 mvwaddstr(window, 5, 41, spindle_string);
01249 mvwaddstr(window, 6, 41, brake_string);
01250 mvwaddstr(window, 7, 41, mist_string);
01251 mvwaddstr(window, 8, 41, flood_string);
01252 mvwaddstr(window, 5, 61, home_string);
01253 mvwaddstr(window, 6, 61, axisString(axisSelected));
01254
01255 wattrset(window, A_UNDERLINE);
01256
01257 mvwaddstr(window, 11, 21, pos_string);
01258
01259 if (coords == COORD_RELATIVE)
01260 {
01261 wattrset(window, 0);
01262 mvwaddstr(window, 12, 21, origin_string);
01263 }
01264
01265 wattrset(window, A_UNDERLINE);
01266
01267 mvwaddstr(window, 7, 69, speed_string);
01268 mvwaddstr(window, 8, 69, incr_string);
01269
01270 if (emcStatus->task.mode == EMC_TASK_MODE_AUTO)
01271 {
01272 mvwaddstr(window, 14, 21, prog_string);
01273 mvwaddstr(window, 15, 21, line_string);
01274 if (emcStatus->task.interpState == EMC_TASK_INTERP_PAUSED)
01275 wattrset(window, A_BOLD);
01276 mvwaddstr(window, 16, 21, programLineText);
01277 mvwaddstr(window, 17, 21, interp_string);
01278 wattrset(window, A_UNDERLINE);
01279 mvwaddstr(window, 18, 21, active_g_codes_string);
01280 mvwaddstr(window, 19, 21, active_m_codes_string);
01281 }
01282 else if (emcStatus->task.mode == EMC_TASK_MODE_MDI)
01283 {
01284 if (emcStatus->task.interpState == EMC_TASK_INTERP_PAUSED)
01285 wattrset(window, A_BOLD);
01286 mvwaddstr(window, 16, 21, emcStatus->task.command);
01287 mvwaddstr(window, 17, 21, interp_string);
01288 wattrset(window, A_UNDERLINE);
01289 mvwaddstr(window, 18, 21, active_g_codes_string);
01290 mvwaddstr(window, 19, 21, active_m_codes_string);
01291 }
01292
01293 if (error_string[0] != 0)
01294 {
01295 printError(error_string);
01296 }
01297
01298 wattrset(window, A_REVERSE);
01299 mvwaddstr(window, wmaxy - 1, wbegx, bottom_string);
01300 wattrset(window, 0);
01301
01302 // restore cursor position
01303 wmove(window, savey, savex);
01304 wrefresh(window);
01305 }
01306 }
|
|
|
Definition at line 1534 of file keystick.cc. 01535 {
01536 // disable timer
01537 startTimer(0);
01538
01539 // clean up curses windows
01540 delwin(progwin);
01541 progwin = 0;
01542 delwin(logwin);
01543 logwin = 0;
01544 delwin(toolwin);
01545 toolwin = 0;
01546 delwin(diagwin);
01547 diagwin = 0;
01548 delwin(helpwin);
01549 helpwin = 0;
01550 endwin();
01551
01552 // clean up NML buffers
01553
01554 if (emcErrorBuffer != 0)
01555 {
01556 delete emcErrorBuffer;
01557 emcErrorBuffer = 0;
01558 }
01559
01560 if (emcStatusBuffer != 0)
01561 {
01562 delete emcStatusBuffer;
01563 emcStatusBuffer = 0;
01564 emcStatus = 0;
01565 }
01566
01567 if (emcCommandBuffer != 0)
01568 {
01569 delete emcCommandBuffer;
01570 emcCommandBuffer = 0;
01571 }
01572
01573 // close program file
01574 if (programFp != 0)
01575 {
01576 fclose(programFp);
01577 programFp = 0;
01578 }
01579
01580 // close error log file
01581 if (NULL != errorFp)
01582 {
01583 fclose(errorFp);
01584 errorFp = NULL;
01585 }
01586
01587 // reset signal handlers to default
01588 signal(SIGALRM, SIG_DFL);
01589 signal(SIGINT, SIG_DFL);
01590
01591 exit(0);
01592 }
|
|
|
Definition at line 1445 of file keystick.cc. Referenced by main(), and quit().
01446 {
01447 struct itimerval value;
01448
01449 value.it_interval.tv_sec = 0;
01450 value.it_interval.tv_usec = us;
01451 value.it_value.tv_sec = 0;
01452 value.it_value.tv_usec = us;
01453
01454 setitimer(ITIMER_REAL, &value, 0);
01455 }
|
|
|
Definition at line 1656 of file keystick.cc. 01657 {
01658 char *ptr = string;
01659 int jogPol;
01660
01661 while (*ptr != 0)
01662 {
01663 *ptr = toupper(*ptr);
01664 ptr++;
01665 }
01666
01667 return string;
01668 }
|
|
|
Definition at line 1310 of file keystick.cc. 01311 {
01312 NMLTYPE type;
01313
01314 if (0 == emcStatus ||
01315 0 == emcStatusBuffer ||
01316 ! emcStatusBuffer->valid())
01317 {
01318 return -1;
01319 }
01320
01321 if (catchErrors)
01322 {
01323 if (0 == emcErrorBuffer ||
01324 ! emcErrorBuffer->valid())
01325 {
01326 return -1;
01327 }
01328 }
01329
01330 switch (type = emcStatusBuffer->peek())
01331 {
01332 case -1:
01333 // error on CMS channel
01334 return -1;
01335 break;
01336
01337 case 0: // no new data
01338 case EMC_STAT_TYPE: // new data
01339 // new data
01340 break;
01341
01342 default:
01343 return -1;
01344 break;
01345 }
01346
01347 if (catchErrors)
01348 {
01349 switch (type = emcErrorBuffer->read())
01350 {
01351 case -1:
01352 // error reading channel
01353 break;
01354
01355 case 0:
01356 // nothing new
01357 error_string[0] = 0;
01358 break;
01359
01360 case EMC_OPERATOR_ERROR_TYPE:
01361 strncpy(error_string,
01362 ((EMC_OPERATOR_ERROR *) (emcErrorBuffer->get_address()))->error,
01363 EMC_OPERATOR_ERROR_LEN - 1);
01364 error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
01365 break;
01366
01367 case EMC_OPERATOR_TEXT_TYPE:
01368 strncpy(error_string,
01369 ((EMC_OPERATOR_TEXT *) (emcErrorBuffer->get_address()))->text,
01370 EMC_OPERATOR_ERROR_LEN - 1);
01371 error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
01372 break;
01373
01374 case EMC_OPERATOR_DISPLAY_TYPE:
01375 strncpy(error_string,
01376 ((EMC_OPERATOR_DISPLAY *) (emcErrorBuffer->get_address()))->display,
01377 EMC_OPERATOR_ERROR_LEN - 1);
01378 error_string[EMC_OPERATOR_ERROR_LEN - 1] = 0;
01379 break;
01380
01381
01382 case NML_ERROR_TYPE:
01383 strncpy(error_string,
01384 ((NML_ERROR *) (emcErrorBuffer->get_address()))->error,
01385 NML_ERROR_LEN - 1);
01386 error_string[NML_ERROR_LEN - 1] = 0;
01387 break;
01388
01389 case NML_TEXT_TYPE:
01390 strncpy(error_string,
01391 ((NML_TEXT *) (emcErrorBuffer->get_address()))->text,
01392 NML_ERROR_LEN - 1);
01393 error_string[NML_ERROR_LEN - 1] = 0;
01394 break;
01395
01396 case NML_DISPLAY_TYPE:
01397 strncpy(error_string,
01398 ((NML_DISPLAY *) (emcErrorBuffer->get_address()))->display,
01399 NML_ERROR_LEN - 1);
01400 error_string[NML_ERROR_LEN - 1] = 0;
01401 break;
01402
01403 default:
01404 strcpy(error_string, "unrecognized error");
01405 break;
01406 }
01407 }
01408
01409 return 0;
01410 }
|
|
|
Definition at line 301 of file keystick.cc. |
|
|
Definition at line 303 of file keystick.cc. |
|
|
Definition at line 293 of file keystick.cc. |
|
|
Definition at line 294 of file keystick.cc. |
|
|
Definition at line 223 of file keystick.cc. |
|
|
Definition at line 222 of file keystick.cc. |
|
|
Definition at line 297 of file keystick.cc. |
|
|
Definition at line 280 of file keystick.cc. |
|
|
Definition at line 1308 of file keystick.cc. |
|
|
Definition at line 271 of file keystick.cc. |
|
|
Definition at line 257 of file keystick.cc. |
|
|
Definition at line 178 of file keystick.cc. |
|
|
|
|
|
Definition at line 313 of file keystick.cc. |
|
|
Definition at line 1533 of file keystick.cc. |
|
|
Definition at line 129 of file keystick.cc. |
|
|
Definition at line 138 of file keystick.cc. |
|
|
Definition at line 134 of file keystick.cc. |
|
|
Definition at line 131 of file keystick.cc. |
|
|
Definition at line 130 of file keystick.cc. |
|
|
Definition at line 142 of file keystick.cc. |
|
|
Definition at line 141 of file keystick.cc. |
|
|
Definition at line 144 of file keystick.cc. |
|
|
Definition at line 143 of file keystick.cc. |
|
|
Definition at line 157 of file keystick.cc. |
|
|
Definition at line 156 of file keystick.cc. |
|
|
Definition at line 155 of file keystick.cc. |
|
|
Definition at line 154 of file keystick.cc. |
|
|
Definition at line 174 of file keystick.cc. |
|
|
Definition at line 171 of file keystick.cc. |
|
|
Definition at line 172 of file keystick.cc. |
|
|
Definition at line 173 of file keystick.cc. |
|
|
Definition at line 159 of file keystick.cc. |
|
|
Definition at line 158 of file keystick.cc. |
|
|
Definition at line 153 of file keystick.cc. |
|
|
Definition at line 152 of file keystick.cc. |
|
|
Definition at line 151 of file keystick.cc. |
|
|
Definition at line 150 of file keystick.cc. |
|
|
Definition at line 149 of file keystick.cc. |
|
|
Definition at line 148 of file keystick.cc. |
|
|
Definition at line 147 of file keystick.cc. |
|
|
Definition at line 160 of file keystick.cc. |
|
|
Definition at line 146 of file keystick.cc. |
|
|
Definition at line 145 of file keystick.cc. |
|
|
Definition at line 198 of file keystick.cc. |
|
|
Definition at line 135 of file keystick.cc. |
|
|
Definition at line 282 of file keystick.cc. |
|
|
Definition at line 312 of file keystick.cc. |
|
|
Definition at line 285 of file keystick.cc. |
|
|
Definition at line 289 of file keystick.cc. |
|
|
Definition at line 292 of file keystick.cc. |
|
|
Definition at line 208 of file keystick.cc. |
|
|
Definition at line 207 of file keystick.cc. |
|
|
Definition at line 209 of file keystick.cc. |
|
|
Definition at line 305 of file keystick.cc. |
|
|
Definition at line 274 of file keystick.cc. |
|
|
Definition at line 291 of file keystick.cc. |
|
|
|
|
|
Definition at line 315 of file keystick.cc. |
|
|
Definition at line 284 of file keystick.cc. |
|
|
Definition at line 283 of file keystick.cc. |
|
|
Definition at line 281 of file keystick.cc. |
|
|
Definition at line 161 of file keystick.cc. |
|
|
Definition at line 278 of file keystick.cc. |
|
|
Definition at line 271 of file keystick.cc. |
|
|
Definition at line 287 of file keystick.cc. |
|
|
Definition at line 264 of file keystick.cc. |
|
|
Definition at line 286 of file keystick.cc. |
|
|
Definition at line 290 of file keystick.cc. |
|
|
Definition at line 187 of file keystick.cc. |
|
|
Definition at line 183 of file keystick.cc. |
|
|
Definition at line 185 of file keystick.cc. |
|
|
Definition at line 186 of file keystick.cc. |
|
|
Definition at line 188 of file keystick.cc. |
|
|
Definition at line 184 of file keystick.cc. |
|
|
Definition at line 181 of file keystick.cc. |
|
|
Definition at line 316 of file keystick.cc. |
|
|
Definition at line 195 of file keystick.cc. |
|
|
Definition at line 191 of file keystick.cc. |
|
|
Definition at line 193 of file keystick.cc. |
|
|
Definition at line 194 of file keystick.cc. |
|
|
Definition at line 192 of file keystick.cc. |
|
|
Definition at line 276 of file keystick.cc. |
|
|
Definition at line 288 of file keystick.cc. |
|
|
Definition at line 266 of file keystick.cc. |
|
|
Definition at line 279 of file keystick.cc. |
|
|
Definition at line 162 of file keystick.cc. |
|
|
Definition at line 277 of file keystick.cc. |
|
|
Definition at line 163 of file keystick.cc. |
|
|
Definition at line 167 of file keystick.cc. |
|
|
Definition at line 164 of file keystick.cc. |
|
|
Definition at line 165 of file keystick.cc. |
|
|
Definition at line 168 of file keystick.cc. |
|
|
Definition at line 169 of file keystick.cc. |
|
|
Definition at line 166 of file keystick.cc. |
|
|
Definition at line 170 of file keystick.cc. |
|
|
Definition at line 314 of file keystick.cc. |
|
|
Definition at line 269 of file keystick.cc. |
|
|
Definition at line 1653 of file keystick.cc. |
|
|
Definition at line 318 of file keystick.cc. |
|
|
Definition at line 318 of file keystick.cc. |
|
|
Definition at line 311 of file keystick.cc. |
|
|
Definition at line 319 of file keystick.cc. |
|
|
Definition at line 319 of file keystick.cc. |
|
|
Definition at line 211 of file keystick.cc. |
|
|
Definition at line 212 of file keystick.cc. |
|
|
Definition at line 213 of file keystick.cc. |
1.2.11.1 written by Dimitri van Heesch,
© 1997-2001