00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "rcs.hh"
00026 #include "emc.hh"
00027 #include "canon.hh"
00028 #include "emcio.hh"
00029 #include "emcglb.h"
00030 #include "initool.hh"
00031
00032
00033 #ifndef __GNUC__
00034 #ifndef __attribute__
00035 #define __attribute__(x)
00036 #endif
00037 #endif
00038
00039 static char __attribute__((unused)) ident[] = "$Id: bridgeporttool.cc,v 1.4 2001/06/29 20:27:29 wshackle Exp $";
00040
00041
00042 #define spindleStatus ((EMC_SPINDLE_STAT *) statusInData[spindleSubNum])
00043 #define coolantStatus ((EMC_COOLANT_STAT *) statusInData[coolantSubNum])
00044 #define auxStatus ((EMC_AUX_STAT *) statusInData[auxSubNum])
00045 #define lubeStatus ((EMC_LUBE_STAT *) statusInData[lubeSubNum])
00046
00047
00048
00049
00050
00051
00052
00053 static int loadToolTable(const char *filename, CANON_TOOL_TABLE toolTable[])
00054 {
00055 int t;
00056 FILE *fp;
00057 char buffer[CANON_TOOL_ENTRY_LEN];
00058 const char *name;
00059
00060
00061 if (filename[0] == 0)
00062 {
00063 name = TOOL_TABLE_FILE;
00064 }
00065 else
00066 {
00067
00068 name = filename;
00069 }
00070
00071
00072 if (NULL == (fp = fopen(name, "r")))
00073 {
00074
00075 return -1;
00076 }
00077
00078
00079 for (t = 0; t <= CANON_TOOL_MAX; t++)
00080 {
00081
00082 toolTable[t].id = 0;
00083 toolTable[t].length = 0.0;
00084 toolTable[t].diameter = 0.0;
00085 }
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099 if (NULL == fgets(buffer, 256, fp))
00100 {
00101
00102 fclose(fp);
00103 return -1;
00104 }
00105
00106 while (!feof(fp))
00107 {
00108 int pocket;
00109 int id;
00110 double length;
00111 double diameter;
00112
00113
00114 if (NULL == fgets(buffer, CANON_TOOL_ENTRY_LEN, fp))
00115 {
00116 break;
00117 }
00118
00119 if (4 != sscanf(buffer, "%d %d %lf %lf",
00120 &pocket, &id, &length, &diameter))
00121 {
00122
00123 continue;
00124 }
00125 else
00126 {
00127 if (pocket < 0 || pocket > CANON_TOOL_MAX)
00128 {
00129 continue;
00130 }
00131 else
00132 {
00133 toolTable[pocket].id = id;
00134 toolTable[pocket].length = length;
00135 toolTable[pocket].diameter = diameter;
00136 }
00137 }
00138 }
00139
00140
00141 fclose(fp);
00142
00143 return 0;
00144 }
00145
00146
00147
00148
00149
00150
00151
00152 static int saveToolTable(const char *filename, CANON_TOOL_TABLE toolTable[])
00153 {
00154 int pocket;
00155 FILE *fp;
00156 const char *name;
00157
00158
00159 if (filename[0] == 0)
00160 {
00161 name = TOOL_TABLE_FILE;
00162 }
00163 else
00164 {
00165
00166 name = filename;
00167 }
00168
00169
00170 if (NULL == (fp = fopen(name, "w")))
00171 {
00172
00173 return -1;
00174 }
00175
00176
00177 fprintf(fp, "POC\tFMS\tLEN\t\tDIAM\n");
00178
00179 for (pocket = 1; pocket <= CANON_TOOL_MAX; pocket++)
00180 {
00181 fprintf(fp, "%d\t%d\t%f\t%f\n",
00182 pocket,
00183 toolTable[pocket].id,
00184 toolTable[pocket].length,
00185 toolTable[pocket].diameter);
00186 }
00187
00188
00189 fclose(fp);
00190
00191 return 0;
00192 }
00193
00194
00195
00196 EMC_TOOL_MODULE::EMC_TOOL_MODULE()
00197 {
00198 EMC_TOOL_INIT initMsg;
00199
00200 setErrorLogChannel(new NML(nmlErrorFormat, "emcError", "tool", EMC_NMLFILE));
00201
00202 setCmdChannel(new RCS_CMD_CHANNEL(emcFormat, "toolCmd", "tool", EMC_NMLFILE));
00203
00204 setStatChannel(new RCS_STAT_CHANNEL(emcFormat, "toolSts", "tool", EMC_NMLFILE), &ioStatus);
00205
00206 spindleSubNum = addSubordinate(new RCS_CMD_CHANNEL(emcFormat, "spindleCmd", "tool", EMC_NMLFILE), new RCS_STAT_CHANNEL(emcFormat, "spindleSts", "tool", EMC_NMLFILE));
00207
00208 coolantSubNum = addSubordinate(new RCS_CMD_CHANNEL(emcFormat, "coolantCmd", "tool", EMC_NMLFILE), new RCS_STAT_CHANNEL(emcFormat, "coolantSts", "tool", EMC_NMLFILE));
00209
00210 auxSubNum = addSubordinate(new RCS_CMD_CHANNEL(emcFormat, "auxCmd", "tool", EMC_NMLFILE), new RCS_STAT_CHANNEL(emcFormat, "auxSts", "tool", EMC_NMLFILE));
00211
00212 lubeSubNum = addSubordinate(new RCS_CMD_CHANNEL(emcFormat, "lubeCmd", "tool", EMC_NMLFILE), new RCS_STAT_CHANNEL(emcFormat, "lubeSts", "tool", EMC_NMLFILE));
00213
00214
00215 deltaClock = 0.0;
00216
00217
00218 initMsg.serial_number = 1;
00219 commandIn->write(initMsg);
00220 }
00221
00222
00223
00224 EMC_TOOL_MODULE::~EMC_TOOL_MODULE(void)
00225 {
00226 }
00227
00228 void EMC_TOOL_MODULE::DECISION_PROCESS(void)
00229 {
00230 switch (commandInData->type)
00231 {
00232 case EMC_SET_DEBUG_TYPE:
00233
00234
00235
00236 EMC_DEBUG = ((EMC_SET_DEBUG *) commandInData)->debug;
00237 ioStatus.debug = EMC_DEBUG;
00238 status = RCS_DONE;
00239 stateNext(S0);
00240 break;
00241
00242 case EMC_TOOL_INIT_TYPE:
00243 INIT((EMC_TOOL_INIT *) commandInData);
00244 break;
00245
00246 case EMC_TOOL_HALT_TYPE:
00247 HALT((EMC_TOOL_HALT *) commandInData);
00248 break;
00249
00250 case EMC_TOOL_ABORT_TYPE:
00251 ABORT((EMC_TOOL_ABORT *) commandInData);
00252 break;
00253
00254 case EMC_TOOL_PREPARE_TYPE:
00255 TOOL_PREPARE((EMC_TOOL_PREPARE *) commandInData);
00256 break;
00257
00258 case EMC_TOOL_LOAD_TYPE:
00259 TOOL_LOAD((EMC_TOOL_LOAD *) commandInData);
00260 break;
00261
00262 case EMC_TOOL_UNLOAD_TYPE:
00263 TOOL_UNLOAD((EMC_TOOL_UNLOAD *) commandInData);
00264 break;
00265
00266 case EMC_TOOL_LOAD_TOOL_TABLE_TYPE:
00267 TOOL_LOAD_TOOL_TABLE((EMC_TOOL_LOAD_TOOL_TABLE *) commandInData);
00268 break;
00269
00270 case EMC_TOOL_SET_OFFSET_TYPE:
00271 TOOL_SET_OFFSET((EMC_TOOL_SET_OFFSET *) commandInData);
00272 break;
00273
00274 case EMC_SPINDLE_ON_TYPE:
00275 SPINDLE_ON((EMC_SPINDLE_ON *) commandInData);
00276 break;
00277
00278 case EMC_SPINDLE_OFF_TYPE:
00279 SPINDLE_OFF((EMC_SPINDLE_OFF *) commandInData);
00280 break;
00281
00282 case EMC_SPINDLE_INCREASE_TYPE:
00283 SPINDLE_INCREASE((EMC_SPINDLE_INCREASE *) commandInData);
00284 break;
00285
00286 case EMC_SPINDLE_DECREASE_TYPE:
00287 SPINDLE_DECREASE((EMC_SPINDLE_DECREASE *) commandInData);
00288 break;
00289
00290 case EMC_SPINDLE_CONSTANT_TYPE:
00291 SPINDLE_CONSTANT((EMC_SPINDLE_CONSTANT *) commandInData);
00292 break;
00293
00294 case EMC_SPINDLE_BRAKE_RELEASE_TYPE:
00295 SPINDLE_BRAKE_RELEASE((EMC_SPINDLE_BRAKE_RELEASE *) commandInData);
00296 break;
00297
00298 case EMC_SPINDLE_BRAKE_ENGAGE_TYPE:
00299 SPINDLE_BRAKE_ENGAGE((EMC_SPINDLE_BRAKE_ENGAGE *) commandInData);
00300 break;
00301
00302 case EMC_COOLANT_MIST_ON_TYPE:
00303 COOLANT_MIST_ON((EMC_COOLANT_MIST_ON *) commandInData);
00304 break;
00305
00306 case EMC_COOLANT_MIST_OFF_TYPE:
00307 COOLANT_MIST_OFF((EMC_COOLANT_MIST_OFF *) commandInData);
00308 break;
00309
00310 case EMC_COOLANT_FLOOD_ON_TYPE:
00311 COOLANT_FLOOD_ON((EMC_COOLANT_FLOOD_ON *) commandInData);
00312 break;
00313
00314 case EMC_COOLANT_FLOOD_OFF_TYPE:
00315 COOLANT_FLOOD_OFF((EMC_COOLANT_FLOOD_OFF *) commandInData);
00316 break;
00317
00318 case EMC_AUX_ESTOP_ON_TYPE:
00319 AUX_ESTOP_ON((EMC_AUX_ESTOP_ON *) commandInData);
00320 break;
00321
00322 case EMC_AUX_ESTOP_OFF_TYPE:
00323 AUX_ESTOP_OFF((EMC_AUX_ESTOP_OFF *) commandInData);
00324 break;
00325
00326 case EMC_AUX_DIO_WRITE_TYPE:
00327 AUX_DIO_WRITE((EMC_AUX_DIO_WRITE *) commandInData);
00328 break;
00329
00330 case EMC_AUX_AIO_WRITE_TYPE:
00331 AUX_AIO_WRITE((EMC_AUX_AIO_WRITE *) commandInData);
00332 break;
00333
00334 case EMC_LUBE_ON_TYPE:
00335 LUBE_ON((EMC_LUBE_ON *) commandInData);
00336 break;
00337
00338 case EMC_LUBE_OFF_TYPE:
00339 LUBE_OFF((EMC_LUBE_OFF *) commandInData);
00340 break;
00341
00342 default:
00343 REPORT_ERROR(commandInData);
00344 break;
00345 }
00346 }
00347
00348 void EMC_TOOL_MODULE::PRE_PROCESS(void)
00349 {
00350 }
00351
00352 void EMC_TOOL_MODULE::POST_PROCESS(void)
00353 {
00354
00355 ioStatus.spindle = *spindleStatus;
00356 ioStatus.coolant = *coolantStatus;
00357 ioStatus.aux = *auxStatus;
00358 ioStatus.lube = *lubeStatus;
00359
00360
00361 ioStatus.heartbeat++;
00362 }
00363
00364 void EMC_TOOL_MODULE::INIT(EMC_TOOL_INIT *cmdIn)
00365 {
00366 EMC_SPINDLE_INIT spindleInitMsg;
00367 EMC_COOLANT_INIT coolantInitMsg;
00368 EMC_AUX_INIT auxInitMsg;
00369 EMC_LUBE_INIT lubeInitMsg;
00370
00371 if (STATE_MATCH(NEW_COMMAND))
00372 {
00373
00374 iniTool(EMC_INIFILE);
00375 loadToolTable(TOOL_TABLE_FILE, ioStatus.tool.toolTable);
00376
00377
00378 sendCommand(&spindleInitMsg, spindleSubNum);
00379 sendCommand(&coolantInitMsg, coolantSubNum);
00380 sendCommand(&auxInitMsg, auxSubNum);
00381 sendCommand(&lubeInitMsg, lubeSubNum);
00382
00383 status = RCS_EXEC;
00384 stateNext(S1);
00385
00386 }
00387 else if (STATE_MATCH(S0))
00388 {
00389
00390 }
00391 else if (STATE_MATCH(S1,
00392 spindleStatus->status == RCS_DONE &&
00393 coolantStatus->status == RCS_DONE &&
00394 auxStatus->status == RCS_DONE &&
00395 lubeStatus->status == RCS_DONE))
00396 {
00397
00398 status = RCS_DONE;
00399 stateNext(S0);
00400 }
00401 else if (STATE_MATCH(S1,
00402 spindleStatus->status == RCS_ERROR ||
00403 coolantStatus->status == RCS_ERROR ||
00404 auxStatus->status == RCS_ERROR ||
00405 lubeStatus->status == RCS_ERROR))
00406 {
00407
00408 status = RCS_ERROR;
00409 stateNext(S0);
00410 }
00411 else if (STATE_MATCH(S1))
00412 {
00413
00414 }
00415 }
00416
00417 void EMC_TOOL_MODULE::HALT(EMC_TOOL_HALT *cmdIn)
00418 {
00419 EMC_SPINDLE_HALT spindleHaltMsg;
00420 EMC_COOLANT_HALT coolantHaltMsg;
00421 EMC_AUX_HALT auxHaltMsg;
00422 EMC_LUBE_HALT lubeHaltMsg;
00423
00424 if (STATE_MATCH(NEW_COMMAND))
00425 {
00426 sendCommand(&spindleHaltMsg, spindleSubNum);
00427 sendCommand(&coolantHaltMsg, coolantSubNum);
00428 sendCommand(&auxHaltMsg, auxSubNum);
00429 sendCommand(&lubeHaltMsg, lubeSubNum);
00430
00431 status = RCS_EXEC;
00432 stateNext(S1);
00433 }
00434 else if (STATE_MATCH(S0))
00435 {
00436
00437 }
00438 else if (STATE_MATCH(S1,
00439 spindleStatus->status == RCS_DONE &&
00440 coolantStatus->status == RCS_DONE &&
00441 auxStatus->status == RCS_DONE &&
00442 lubeStatus->status == RCS_DONE))
00443 {
00444
00445
00446 status = RCS_DONE;
00447 stateNext(S0);
00448 }
00449 else if (STATE_MATCH(S1,
00450 spindleStatus->status == RCS_ERROR ||
00451 coolantStatus->status == RCS_ERROR ||
00452 auxStatus->status == RCS_ERROR ||
00453 lubeStatus->status == RCS_ERROR))
00454 {
00455
00456
00457 status = RCS_ERROR;
00458 stateNext(S0);
00459 }
00460 else if (STATE_MATCH(S1))
00461 {
00462
00463 }
00464 }
00465
00466 void EMC_TOOL_MODULE::ABORT(EMC_TOOL_ABORT *cmdIn)
00467 {
00468 EMC_SPINDLE_ABORT spindleAbortMsg;
00469 EMC_COOLANT_ABORT coolantAbortMsg;
00470 EMC_AUX_ABORT auxAbortMsg;
00471 EMC_LUBE_ABORT lubeAbortMsg;
00472
00473 if (STATE_MATCH(NEW_COMMAND))
00474 {
00475 sendCommand(&spindleAbortMsg, spindleSubNum);
00476 sendCommand(&coolantAbortMsg, coolantSubNum);
00477 sendCommand(&auxAbortMsg, auxSubNum);
00478 sendCommand(&lubeAbortMsg, lubeSubNum);
00479
00480 status = RCS_EXEC;
00481 stateNext(S1);
00482 }
00483 else if (STATE_MATCH(S0))
00484 {
00485
00486 }
00487 else if (STATE_MATCH(S1,
00488 spindleStatus->status == RCS_DONE &&
00489 coolantStatus->status == RCS_DONE &&
00490 auxStatus->status == RCS_DONE &&
00491 lubeStatus->status == RCS_DONE))
00492 {
00493
00494
00495 status = RCS_DONE;
00496 stateNext(S0);
00497 }
00498 else if (STATE_MATCH(S1,
00499 spindleStatus->status == RCS_ERROR ||
00500 coolantStatus->status == RCS_ERROR ||
00501 auxStatus->status == RCS_ERROR ||
00502 lubeStatus->status == RCS_ERROR))
00503 {
00504
00505
00506 status = RCS_ERROR;
00507 stateNext(S0);
00508 }
00509 else if (STATE_MATCH(S1))
00510 {
00511
00512 }
00513 }
00514
00515 void EMC_TOOL_MODULE::REPORT_ERROR(RCS_CMD_MSG *cmdIn)
00516 {
00517 if (STATE_MATCH(NEW_COMMAND))
00518 {
00519 rcs_print_error("EMC_TOOL_MODULE: unknown command %d\n",
00520 cmdIn->type);
00521 status = RCS_ERROR;
00522 stateNext(S0);
00523 }
00524 else if (STATE_MATCH(S0))
00525 {
00526
00527 }
00528 }
00529
00530 void EMC_TOOL_MODULE::TOOL_PREPARE(EMC_TOOL_PREPARE *cmdIn)
00531 {
00532 if (STATE_MATCH(NEW_COMMAND))
00533 {
00534 ioStatus.tool.toolPrepped = cmdIn->tool;
00535
00536 status = RCS_DONE;
00537 stateNext(S0);
00538 }
00539 else if (STATE_MATCH(S0))
00540 {
00541
00542 }
00543 }
00544
00545 void EMC_TOOL_MODULE::TOOL_LOAD(EMC_TOOL_LOAD *cmdIn)
00546 {
00547 if (STATE_MATCH(NEW_COMMAND))
00548 {
00549 ioStatus.tool.toolInSpindle = ioStatus.tool.toolPrepped;
00550 ioStatus.tool.toolPrepped = 0;
00551
00552 status = RCS_DONE;
00553 stateNext(S0);
00554 }
00555 else if (STATE_MATCH(S0))
00556 {
00557
00558 }
00559 }
00560
00561 void EMC_TOOL_MODULE::TOOL_UNLOAD(EMC_TOOL_UNLOAD *cmdIn)
00562 {
00563 if (STATE_MATCH(NEW_COMMAND))
00564 {
00565 ioStatus.tool.toolInSpindle = 0;
00566
00567 status = RCS_DONE;
00568 stateNext(S0);
00569 }
00570 else if (STATE_MATCH(S0))
00571 {
00572
00573 }
00574 }
00575
00576 void EMC_TOOL_MODULE::TOOL_LOAD_TOOL_TABLE(EMC_TOOL_LOAD_TOOL_TABLE *cmdIn)
00577 {
00578 if (STATE_MATCH(NEW_COMMAND))
00579 {
00580 if (0 != loadToolTable(cmdIn->file, ioStatus.tool.toolTable))
00581 {
00582 status = RCS_ERROR;
00583 }
00584 else
00585 {
00586 status = RCS_DONE;
00587 }
00588 stateNext(S0);
00589 }
00590 else if (STATE_MATCH(S0))
00591 {
00592
00593 }
00594 }
00595
00596 void EMC_TOOL_MODULE::TOOL_SET_OFFSET(EMC_TOOL_SET_OFFSET *cmdIn)
00597 {
00598 if (STATE_MATCH(NEW_COMMAND))
00599 {
00600 if (cmdIn->tool < 0 || cmdIn->tool > CANON_TOOL_MAX)
00601 {
00602 status = RCS_ERROR;
00603 stateNext(S0);
00604 }
00605 else
00606 {
00607
00608 ioStatus.tool.toolTable[cmdIn->tool].length = cmdIn->length;
00609 ioStatus.tool.toolTable[cmdIn->tool].diameter = cmdIn->diameter;
00610
00611 if (0 != saveToolTable(TOOL_TABLE_FILE, ioStatus.tool.toolTable))
00612 {
00613 status = RCS_ERROR;
00614 }
00615 else
00616 {
00617 status = RCS_DONE;
00618 }
00619 stateNext(S0);
00620 }
00621 }
00622 else if (STATE_MATCH(S0))
00623 {
00624
00625 }
00626 }
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639 void EMC_TOOL_MODULE::SPINDLE_ON(EMC_SPINDLE_ON *cmdIn)
00640 {
00641 EMC_SPINDLE_FORWARD forwardMsg;
00642 EMC_SPINDLE_REVERSE reverseMsg;
00643 EMC_SPINDLE_BRAKE_RELEASE brakeReleaseMsg;
00644 EMC_SPINDLE_STOP stopMsg;
00645
00646 if (STATE_MATCH(NEW_COMMAND,
00647 auxStatus->estop))
00648 {
00649 status = RCS_ERROR;
00650 stateNext(S0);
00651 }
00652 else if (STATE_MATCH(NEW_COMMAND,
00653 ! auxStatus->estop))
00654 {
00655
00656 sendCommand(&brakeReleaseMsg, spindleSubNum);
00657
00658 deltaClock = SPINDLE_ON_WAIT;
00659
00660 status = RCS_EXEC;
00661 stateNext(S1);
00662 }
00663 else if (STATE_MATCH(S0))
00664 {
00665
00666 }
00667 else if (STATE_MATCH(S1))
00668 {
00669
00670 if (deltaClock <= 0.0)
00671 {
00672 stateNext(S2);
00673 }
00674 else
00675 {
00676 deltaClock -= EMC_IO_CYCLE_TIME;
00677 }
00678 }
00679 else if (STATE_MATCH(S2))
00680 {
00681 if (cmdIn->speed < 0.0)
00682 {
00683 sendCommand(&reverseMsg, spindleSubNum);
00684 }
00685 else if (cmdIn->speed > 0.0)
00686 {
00687 sendCommand(&forwardMsg, spindleSubNum);
00688 }
00689 else
00690 {
00691 sendCommand(&stopMsg, spindleSubNum);
00692 }
00693
00694 stateNext(S3);
00695 }
00696 else if (STATE_MATCH(S3,
00697 spindleStatus->status == RCS_DONE))
00698 {
00699
00700 status = RCS_DONE;
00701 stateNext(S0);
00702 }
00703 else if (STATE_MATCH(S3,
00704 spindleStatus->status == RCS_ERROR))
00705 {
00706
00707 status = RCS_ERROR;
00708 stateNext(S0);
00709 }
00710 else if (STATE_MATCH(S3,
00711 spindleStatus->status == RCS_EXEC))
00712 {
00713
00714 }
00715 }
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725 void EMC_TOOL_MODULE::SPINDLE_OFF(EMC_SPINDLE_OFF *cmdIn)
00726 {
00727 EMC_SPINDLE_STOP stopMsg;
00728 EMC_SPINDLE_BRAKE_ENGAGE brakeEngageMsg;
00729
00730 if (STATE_MATCH(NEW_COMMAND))
00731 {
00732
00733 sendCommand(&stopMsg, spindleSubNum);
00734
00735 status = RCS_EXEC;
00736 stateNext(S1);
00737 }
00738 else if (STATE_MATCH(S0))
00739 {
00740
00741 }
00742 else if (STATE_MATCH(S1,
00743 spindleStatus->status == RCS_ERROR))
00744 {
00745 status = RCS_ERROR;
00746 stateNext(S0);
00747 }
00748 else if (STATE_MATCH(S1,
00749 spindleStatus->status == RCS_EXEC))
00750 {
00751
00752 }
00753 else if (STATE_MATCH(S1,
00754 spindleStatus->status == RCS_DONE))
00755 {
00756
00757 deltaClock = SPINDLE_OFF_WAIT;
00758 stateNext(S2);
00759 }
00760 else if (STATE_MATCH(S2))
00761 {
00762 if (deltaClock <= 0.0)
00763 {
00764 stateNext(S3);
00765 }
00766 else
00767 {
00768 deltaClock -= EMC_IO_CYCLE_TIME;
00769 }
00770 }
00771 else if (STATE_MATCH(S3))
00772 {
00773
00774 sendCommand(&brakeEngageMsg, spindleSubNum);
00775
00776 stateNext(S4);
00777 }
00778 else if (STATE_MATCH(S4,
00779 spindleStatus->status == RCS_DONE))
00780 {
00781
00782 status = RCS_DONE;
00783 stateNext(S0);
00784 }
00785 else if (STATE_MATCH(S4,
00786 spindleStatus->status == RCS_ERROR))
00787 {
00788
00789 status = RCS_ERROR;
00790 stateNext(S0);
00791 }
00792 else if (STATE_MATCH(S4,
00793 spindleStatus->status == RCS_EXEC))
00794 {
00795
00796 }
00797 }
00798
00799 void EMC_TOOL_MODULE::SPINDLE_INCREASE(EMC_SPINDLE_INCREASE *cmdIn)
00800 {
00801 EMC_SPINDLE_INCREASE spindleIncreaseMsg;
00802
00803 if (STATE_MATCH(NEW_COMMAND))
00804 {
00805 sendCommand(&spindleIncreaseMsg, spindleSubNum);
00806
00807 status = RCS_EXEC;
00808 stateNext(S1);
00809 }
00810 else if (STATE_MATCH(S0))
00811 {
00812
00813 }
00814 else if (STATE_MATCH(S1,
00815 spindleStatus->status == RCS_DONE))
00816 {
00817 status = RCS_DONE;
00818 stateNext(S0);
00819 }
00820 else if (STATE_MATCH(S1,
00821 spindleStatus->status == RCS_ERROR))
00822 {
00823 status = RCS_ERROR;
00824 stateNext(S0);
00825 }
00826 else if (STATE_MATCH(S1,
00827 spindleStatus->status == RCS_EXEC))
00828 {
00829
00830 }
00831 }
00832
00833 void EMC_TOOL_MODULE::SPINDLE_DECREASE(EMC_SPINDLE_DECREASE *cmdIn)
00834 {
00835 EMC_SPINDLE_DECREASE spindleDecreaseMsg;
00836
00837 if (STATE_MATCH(NEW_COMMAND))
00838 {
00839 sendCommand(&spindleDecreaseMsg, spindleSubNum);
00840
00841 status = RCS_EXEC;
00842 stateNext(S1);
00843 }
00844 else if (STATE_MATCH(S0))
00845 {
00846
00847 }
00848 else if (STATE_MATCH(S1,
00849 spindleStatus->status == RCS_DONE))
00850 {
00851 status = RCS_DONE;
00852 stateNext(S0);
00853 }
00854 else if (STATE_MATCH(S1,
00855 spindleStatus->status == RCS_ERROR))
00856 {
00857 status = RCS_ERROR;
00858 stateNext(S0);
00859 }
00860 else if (STATE_MATCH(S1,
00861 spindleStatus->status == RCS_EXEC))
00862 {
00863
00864 }
00865 }
00866
00867 void EMC_TOOL_MODULE::SPINDLE_CONSTANT(EMC_SPINDLE_CONSTANT *cmdIn)
00868 {
00869 EMC_SPINDLE_CONSTANT spindleConstantMsg;
00870
00871 if (STATE_MATCH(NEW_COMMAND))
00872 {
00873 sendCommand(&spindleConstantMsg, spindleSubNum);
00874
00875 status = RCS_EXEC;
00876 stateNext(S1);
00877 }
00878 else if (STATE_MATCH(S0))
00879 {
00880
00881 }
00882 else if (STATE_MATCH(S1,
00883 spindleStatus->status == RCS_DONE))
00884 {
00885 status = RCS_DONE;
00886 stateNext(S0);
00887 }
00888 else if (STATE_MATCH(S1,
00889 spindleStatus->status == RCS_ERROR))
00890 {
00891 status = RCS_ERROR;
00892 stateNext(S0);
00893 }
00894 else if (STATE_MATCH(S1,
00895 spindleStatus->status == RCS_EXEC))
00896 {
00897
00898 }
00899 }
00900
00901 void EMC_TOOL_MODULE::SPINDLE_BRAKE_RELEASE(EMC_SPINDLE_BRAKE_RELEASE *cmdIn)
00902 {
00903 EMC_SPINDLE_BRAKE_RELEASE spindleBrakeReleaseMsg;
00904
00905 if (STATE_MATCH(NEW_COMMAND))
00906 {
00907 sendCommand(&spindleBrakeReleaseMsg, spindleSubNum);
00908
00909 status = RCS_EXEC;
00910 stateNext(S1);
00911 }
00912 else if (STATE_MATCH(S0))
00913 {
00914
00915 }
00916 else if (STATE_MATCH(S1,
00917 spindleStatus->status == RCS_DONE))
00918 {
00919 status = RCS_DONE;
00920 stateNext(S0);
00921 }
00922 else if (STATE_MATCH(S1,
00923 spindleStatus->status == RCS_ERROR))
00924 {
00925 status = RCS_ERROR;
00926 stateNext(S0);
00927 }
00928 else if (STATE_MATCH(S1,
00929 spindleStatus->status == RCS_EXEC))
00930 {
00931
00932 }
00933 }
00934
00935 void EMC_TOOL_MODULE::SPINDLE_BRAKE_ENGAGE(EMC_SPINDLE_BRAKE_ENGAGE *cmdIn)
00936 {
00937 EMC_SPINDLE_BRAKE_ENGAGE spindleBrakeEngageMsg;
00938
00939 if (STATE_MATCH(NEW_COMMAND))
00940 {
00941 sendCommand(&spindleBrakeEngageMsg, spindleSubNum);
00942
00943 status = RCS_EXEC;
00944 stateNext(S1);
00945 }
00946 else if (STATE_MATCH(S0))
00947 {
00948
00949 }
00950 else if (STATE_MATCH(S1,
00951 spindleStatus->status == RCS_DONE))
00952 {
00953 status = RCS_DONE;
00954 stateNext(S0);
00955 }
00956 else if (STATE_MATCH(S1,
00957 spindleStatus->status == RCS_ERROR))
00958 {
00959 status = RCS_ERROR;
00960 stateNext(S0);
00961 }
00962 else if (STATE_MATCH(S1,
00963 spindleStatus->status == RCS_EXEC))
00964 {
00965
00966 }
00967 }
00968
00969
00970 void EMC_TOOL_MODULE::COOLANT_MIST_ON(EMC_COOLANT_MIST_ON *cmdIn)
00971 {
00972 EMC_COOLANT_MIST_ON mistOnMsg;
00973
00974 if (STATE_MATCH(NEW_COMMAND))
00975 {
00976 sendCommand(&mistOnMsg, coolantSubNum);
00977
00978 status = RCS_EXEC;
00979 stateNext(S1);
00980 }
00981 else if (STATE_MATCH(S0))
00982 {
00983
00984 }
00985 else if (STATE_MATCH(S1,
00986 coolantStatus->status == RCS_DONE))
00987 {
00988 status = RCS_DONE;
00989 stateNext(S0);
00990 }
00991 else if (STATE_MATCH(S1,
00992 coolantStatus->status == RCS_ERROR))
00993 {
00994 status = RCS_ERROR;
00995 stateNext(S0);
00996 }
00997 else if (STATE_MATCH(S1,
00998 coolantStatus->status == RCS_EXEC))
00999 {
01000
01001 }
01002 }
01003
01004 void EMC_TOOL_MODULE::COOLANT_MIST_OFF(EMC_COOLANT_MIST_OFF *cmdIn)
01005 {
01006 EMC_COOLANT_MIST_OFF mistOffMsg;
01007
01008 if (STATE_MATCH(NEW_COMMAND))
01009 {
01010 sendCommand(&mistOffMsg, coolantSubNum);
01011 status = RCS_EXEC;
01012 stateNext(S1);
01013 }
01014 else if (STATE_MATCH(S0))
01015 {
01016
01017 }
01018 else if (STATE_MATCH(S1,
01019 coolantStatus->status == RCS_DONE))
01020 {
01021 status = RCS_DONE;
01022 stateNext(S0);
01023 }
01024 else if (STATE_MATCH(S1,
01025 coolantStatus->status == RCS_ERROR))
01026 {
01027 status = RCS_ERROR;
01028 stateNext(S0);
01029 }
01030 else if (STATE_MATCH(S1,
01031 coolantStatus->status == RCS_EXEC))
01032 {
01033
01034 }
01035 else
01036 {
01037 printf("mist off %d %d\n", state, coolantStatus->status);
01038 }
01039 }
01040
01041 void EMC_TOOL_MODULE::COOLANT_FLOOD_ON(EMC_COOLANT_FLOOD_ON *cmdIn)
01042 {
01043 EMC_COOLANT_FLOOD_ON floodOnMsg;
01044
01045 if (STATE_MATCH(NEW_COMMAND))
01046 {
01047 sendCommand(&floodOnMsg, coolantSubNum);
01048 status = RCS_EXEC;
01049 stateNext(S1);
01050 }
01051 else if (STATE_MATCH(S0))
01052 {
01053
01054 }
01055 else if (STATE_MATCH(S1,
01056 coolantStatus->status == RCS_DONE))
01057 {
01058 status = RCS_DONE;
01059 stateNext(S0);
01060 }
01061 else if (STATE_MATCH(S1,
01062 coolantStatus->status == RCS_ERROR))
01063 {
01064 status = RCS_ERROR;
01065 stateNext(S0);
01066 }
01067 else if (STATE_MATCH(S1,
01068 coolantStatus->status == RCS_EXEC))
01069 {
01070
01071 }
01072 }
01073
01074 void EMC_TOOL_MODULE::COOLANT_FLOOD_OFF(EMC_COOLANT_FLOOD_OFF *cmdIn)
01075 {
01076 EMC_COOLANT_FLOOD_OFF floodOffMsg;
01077
01078 if (STATE_MATCH(NEW_COMMAND))
01079 {
01080 sendCommand(&floodOffMsg, coolantSubNum);
01081 status = RCS_EXEC;
01082 stateNext(S1);
01083 }
01084 else if (STATE_MATCH(S0))
01085 {
01086
01087 }
01088 else if (STATE_MATCH(S1,
01089 coolantStatus->status == RCS_DONE))
01090 {
01091 status = RCS_DONE;
01092 stateNext(S0);
01093 }
01094 else if (STATE_MATCH(S1,
01095 coolantStatus->status == RCS_ERROR))
01096 {
01097 status = RCS_ERROR;
01098 stateNext(S0);
01099 }
01100 else if (STATE_MATCH(S1,
01101 coolantStatus->status == RCS_EXEC))
01102 {
01103
01104 }
01105 else
01106 {
01107 printf("flood off %d %d\n", state, coolantStatus->status);
01108 }
01109 }
01110
01111
01112 void EMC_TOOL_MODULE::AUX_ESTOP_ON(EMC_AUX_ESTOP_ON *cmdIn)
01113 {
01114 EMC_AUX_ESTOP_ON estopOnMsg;
01115
01116 if (STATE_MATCH(NEW_COMMAND))
01117 {
01118 sendCommand(&estopOnMsg, auxSubNum);
01119
01120 status = RCS_EXEC;
01121 stateNext(S1);
01122 }
01123 else if (STATE_MATCH(S0))
01124 {
01125
01126 }
01127 else if (STATE_MATCH(S1,
01128 auxStatus->status == RCS_DONE))
01129 {
01130 status = RCS_DONE;
01131 stateNext(S0);
01132 }
01133 else if (STATE_MATCH(S1,
01134 auxStatus->status == RCS_ERROR))
01135 {
01136 status = RCS_ERROR;
01137 stateNext(S0);
01138 }
01139 else if (STATE_MATCH(S1,
01140 auxStatus->status == RCS_EXEC))
01141 {
01142
01143 }
01144 }
01145
01146 void EMC_TOOL_MODULE::AUX_ESTOP_OFF(EMC_AUX_ESTOP_OFF *cmdIn)
01147 {
01148 EMC_AUX_ESTOP_OFF estopOffMsg;
01149
01150 if (STATE_MATCH(NEW_COMMAND))
01151 {
01152 sendCommand(&estopOffMsg, auxSubNum);
01153
01154 status = RCS_EXEC;
01155 stateNext(S1);
01156 }
01157 else if (STATE_MATCH(S0))
01158 {
01159
01160 }
01161 else if (STATE_MATCH(S1,
01162 auxStatus->status == RCS_DONE))
01163 {
01164 status = RCS_DONE;
01165 stateNext(S0);
01166 }
01167 else if (STATE_MATCH(S1,
01168 auxStatus->status == RCS_ERROR))
01169 {
01170 status = RCS_ERROR;
01171 stateNext(S0);
01172 }
01173 else if (STATE_MATCH(S1,
01174 auxStatus->status == RCS_EXEC))
01175 {
01176
01177 }
01178 }
01179
01180 void EMC_TOOL_MODULE::AUX_DIO_WRITE(EMC_AUX_DIO_WRITE *cmdIn)
01181 {
01182 EMC_AUX_DIO_WRITE dioWriteMsg = *cmdIn;
01183
01184 if (STATE_MATCH(NEW_COMMAND))
01185 {
01186 sendCommand(&dioWriteMsg, auxSubNum);
01187
01188 status = RCS_EXEC;
01189 stateNext(S1);
01190 }
01191 else if (STATE_MATCH(S0))
01192 {
01193
01194 }
01195 else if (STATE_MATCH(S1,
01196 auxStatus->status == RCS_DONE))
01197 {
01198 status = RCS_DONE;
01199 stateNext(S0);
01200 }
01201 else if (STATE_MATCH(S1,
01202 auxStatus->status == RCS_ERROR))
01203 {
01204 status = RCS_ERROR;
01205 stateNext(S0);
01206 }
01207 else if (STATE_MATCH(S1,
01208 auxStatus->status == RCS_EXEC))
01209 {
01210
01211 }
01212 }
01213
01214 void EMC_TOOL_MODULE::AUX_AIO_WRITE(EMC_AUX_AIO_WRITE *cmdIn)
01215 {
01216 EMC_AUX_AIO_WRITE aioWriteMsg = *cmdIn;
01217
01218 if (STATE_MATCH(NEW_COMMAND))
01219 {
01220 sendCommand(&aioWriteMsg, auxSubNum);
01221
01222 status = RCS_EXEC;
01223 stateNext(S1);
01224 }
01225 else if (STATE_MATCH(S0))
01226 {
01227
01228 }
01229 else if (STATE_MATCH(S1,
01230 auxStatus->status == RCS_DONE))
01231 {
01232 status = RCS_DONE;
01233 stateNext(S0);
01234 }
01235 else if (STATE_MATCH(S1,
01236 auxStatus->status == RCS_ERROR))
01237 {
01238 status = RCS_ERROR;
01239 stateNext(S0);
01240 }
01241 else if (STATE_MATCH(S1,
01242 auxStatus->status == RCS_EXEC))
01243 {
01244
01245 }
01246 }
01247
01248
01249 void EMC_TOOL_MODULE::LUBE_ON(EMC_LUBE_ON *cmdIn)
01250 {
01251 EMC_LUBE_ON lubeOnMsg;
01252
01253 if (STATE_MATCH(NEW_COMMAND,
01254 auxStatus->estop))
01255 {
01256 status = RCS_ERROR;
01257 stateNext(S0);
01258 }
01259 else if (STATE_MATCH(NEW_COMMAND,
01260 ! auxStatus->estop))
01261 {
01262 sendCommand(&lubeOnMsg, lubeSubNum);
01263
01264 status = RCS_EXEC;
01265 stateNext(S1);
01266 }
01267 else if (STATE_MATCH(S0))
01268 {
01269
01270 }
01271 else if (STATE_MATCH(S1,
01272 lubeStatus->status == RCS_DONE))
01273 {
01274 status = RCS_DONE;
01275 stateNext(S0);
01276 }
01277 else if (STATE_MATCH(S1,
01278 lubeStatus->status == RCS_ERROR))
01279 {
01280 status = RCS_ERROR;
01281 stateNext(S0);
01282 }
01283 else if (STATE_MATCH(S1,
01284 lubeStatus->status == RCS_EXEC))
01285 {
01286
01287 }
01288 }
01289
01290 void EMC_TOOL_MODULE::LUBE_OFF(EMC_LUBE_OFF *cmdIn)
01291 {
01292 EMC_LUBE_OFF lubeOffMsg;
01293
01294 if (STATE_MATCH(NEW_COMMAND))
01295 {
01296 sendCommand(&lubeOffMsg, lubeSubNum);
01297
01298 status = RCS_EXEC;
01299 stateNext(S1);
01300 }
01301 else if (STATE_MATCH(S0))
01302 {
01303
01304 }
01305 else if (STATE_MATCH(S1,
01306 lubeStatus->status == RCS_DONE))
01307 {
01308 status = RCS_DONE;
01309 stateNext(S0);
01310 }
01311 else if (STATE_MATCH(S1,
01312 lubeStatus->status == RCS_ERROR))
01313 {
01314 status = RCS_ERROR;
01315 stateNext(S0);
01316 }
01317 else if (STATE_MATCH(S1,
01318 lubeStatus->status == RCS_EXEC))
01319 {
01320
01321 }
01322 }