/* C code for program setGap, generated by snc from ../setGap.stt */ #include #include #include #include #include "seq_snc.h" # line 9 "../setGap.stt" #include #include #include #include #include #include #include #include #include #include #define inputEos "\r" #define outputEos " " #define BUF_SIZE 200 static int writeCommand(SS_ID ssId, struct UserVar *pVar, char *command, char *stateName); static int writeRead(SS_ID ssId, struct UserVar *pVar, char *command, char *reply, char *stateName); static int getMotorMoving(SS_ID ssId, struct UserVar *pVar); static int waitEpicsMotors(SS_ID ssId, struct UserVar *pVar); static int getTimeStamp(SS_ID ssId, char *timeStampString); static int logToIOCshell(SS_ID ssId, char *logMessage); static int waitBrakesReleased(SS_ID ssId, struct UserVar *pVar); static int queryBrakesReleased(SS_ID ssId, struct UserVar *pVar); /* Variable declarations */ struct seqg_vars { # line 37 "../setGap.stt" char stringOut[200]; # line 38 "../setGap.stt" char stringIn[200]; # line 39 "../setGap.stt" char *asynPort; # line 40 "../setGap.stt" char *pasynUser; # line 41 "../setGap.stt" int initStatus; # line 42 "../setGap.stt" int numAxes; # line 43 "../setGap.stt" int movingLarger; # line 45 "../setGap.stt" int sg_status; # line 46 "../setGap.stt" int am_status; # line 47 "../setGap.stt" int brake_status; # line 51 "../setGap.stt" double distEndToEnd; # line 53 "../setGap.stt" double distToUsMtr; # line 55 "../setGap.stt" double distToDsMtr; # line 57 "../setGap.stt" double distBtwnMtr; # line 60 "../setGap.stt" double desiredGapTemp; # line 61 "../setGap.stt" double deadbandTemp; # line 62 "../setGap.stt" double desiredUsMotorPosition; # line 63 "../setGap.stt" double desiredDsMotorPosition; # line 64 "../setGap.stt" double usaMotorAmountToMove; # line 65 "../setGap.stt" double uswMotorAmountToMove; # line 66 "../setGap.stt" double dsaMotorAmountToMove; # line 67 "../setGap.stt" double dswMotorAmountToMove; # line 68 "../setGap.stt" double moveFraction; # line 69 "../setGap.stt" double deadband_hg; # line 70 "../setGap.stt" double deadband_fg; # line 73 "../setGap.stt" int fullGapEncCorrection; # line 74 "../setGap.stt" int fullGapCorrectionNeeded; # line 75 "../setGap.stt" double currentGapFromFullGapEncoders; # line 76 "../setGap.stt" double currentTaperFromFullGapEncoders; # line 77 "../setGap.stt" double userDesiredGap; # line 78 "../setGap.stt" double userDesiredTaper; # line 79 "../setGap.stt" double usError; # line 80 "../setGap.stt" double dsError; # line 81 "../setGap.stt" double deltaError; # line 83 "../setGap.stt" double usaPos; # line 84 "../setGap.stt" double uswPos; # line 85 "../setGap.stt" double dsaPos; # line 86 "../setGap.stt" double dswPos; # line 87 "../setGap.stt" int usaPos_raw; # line 88 "../setGap.stt" int uswPos_raw; # line 89 "../setGap.stt" int dsaPos_raw; # line 90 "../setGap.stt" int dswPos_raw; # line 91 "../setGap.stt" int moveVelo_raw; # line 92 "../setGap.stt" int acclDccl_raw; # line 94 "../setGap.stt" int sampleRate; # line 95 "../setGap.stt" double scalingFactorVelo; # line 96 "../setGap.stt" double scalingFactorAD; # line 97 "../setGap.stt" double deadband; # line 100 "../setGap.stt" double desiredGap; # line 101 "../setGap.stt" double desiredTaper; # line 102 "../setGap.stt" double desiredUsGap; # line 103 "../setGap.stt" double desiredDsGap; # line 105 "../setGap.stt" double deadband_mm; # line 106 "../setGap.stt" double deadband_enc; # line 107 "../setGap.stt" double moveFrac; # line 108 "../setGap.stt" double finalMoveFrac; # line 109 "../setGap.stt" double finalMoveRange; # line 110 "../setGap.stt" double moveVelo; # line 111 "../setGap.stt" double acclDccl; # line 112 "../setGap.stt" int singleApproach; # line 113 "../setGap.stt" int overcurrents; # line 114 "../setGap.stt" int retry; # line 115 "../setGap.stt" int retryMax; # line 116 "../setGap.stt" double clRegionOfIntr; # line 117 "../setGap.stt" int clEncSelection; # line 120 "../setGap.stt" double actualGap; # line 121 "../setGap.stt" double actualTaper; # line 122 "../setGap.stt" double calcUsGap; # line 123 "../setGap.stt" double calcDsGap; # line 124 "../setGap.stt" double calcAisleTaper; # line 125 "../setGap.stt" double calcWallTaper; # line 126 "../setGap.stt" double calcUsSymmetry; # line 127 "../setGap.stt" double calcDsSymmetry; # line 130 "../setGap.stt" double usFullGapEncoder; # line 131 "../setGap.stt" double dsFullGapEncoder; # line 134 "../setGap.stt" double usaHalfGapEncoder; # line 135 "../setGap.stt" double uswHalfGapEncoder; # line 136 "../setGap.stt" double dsaHalfGapEncoder; # line 137 "../setGap.stt" double dswHalfGapEncoder; # line 140 "../setGap.stt" double usaMotorVal; # line 141 "../setGap.stt" double uswMotorVal; # line 142 "../setGap.stt" double dsaMotorVal; # line 143 "../setGap.stt" double dswMotorVal; # line 145 "../setGap.stt" double usaMotorRbv; # line 146 "../setGap.stt" double uswMotorRbv; # line 147 "../setGap.stt" double dsaMotorRbv; # line 148 "../setGap.stt" double dswMotorRbv; # line 150 "../setGap.stt" double usaMotorGap; # line 151 "../setGap.stt" double uswMotorGap; # line 152 "../setGap.stt" double dsaMotorGap; # line 153 "../setGap.stt" double dswMotorGap; # line 154 "../setGap.stt" double motorResolution; # line 157 "../setGap.stt" int startGapAdjustment; # line 158 "../setGap.stt" int stop; # line 159 "../setGap.stt" int checkGap; # line 160 "../setGap.stt" int undulatorError; # line 161 "../setGap.stt" int calibMotors; # line 162 "../setGap.stt" int movingDirection; # line 163 "../setGap.stt" int deviceActive; # line 164 "../setGap.stt" string message1; # line 165 "../setGap.stt" string message2; # line 169 "../setGap.stt" int debugLevel; # line 170 "../setGap.stt" int simMode; # line 171 "../setGap.stt" string setGapState; }; /* Function declarations */ #define seqg_var (*(struct seqg_vars *const *)seqg_env) /* Program init func */ static void seqg_init(PROG_ID seqg_env) { { # line 41 "../setGap.stt" static int seqg_initvar_initStatus = 0; memcpy(&seqg_var->initStatus, &seqg_initvar_initStatus, sizeof(seqg_initvar_initStatus)); } { # line 42 "../setGap.stt" static int seqg_initvar_numAxes = 4; memcpy(&seqg_var->numAxes, &seqg_initvar_numAxes, sizeof(seqg_initvar_numAxes)); } { # line 43 "../setGap.stt" static int seqg_initvar_movingLarger = 0; memcpy(&seqg_var->movingLarger, &seqg_initvar_movingLarger, sizeof(seqg_initvar_movingLarger)); } { # line 45 "../setGap.stt" static int seqg_initvar_sg_status = 0; memcpy(&seqg_var->sg_status, &seqg_initvar_sg_status, sizeof(seqg_initvar_sg_status)); } { # line 46 "../setGap.stt" static int seqg_initvar_am_status = 0; memcpy(&seqg_var->am_status, &seqg_initvar_am_status, sizeof(seqg_initvar_am_status)); } { # line 47 "../setGap.stt" static int seqg_initvar_brake_status = 0; memcpy(&seqg_var->brake_status, &seqg_initvar_brake_status, sizeof(seqg_initvar_brake_status)); } { # line 51 "../setGap.stt" static double seqg_initvar_distEndToEnd = 3419.050; memcpy(&seqg_var->distEndToEnd, &seqg_initvar_distEndToEnd, sizeof(seqg_initvar_distEndToEnd)); } { # line 53 "../setGap.stt" static double seqg_initvar_distToUsMtr = 798.525; memcpy(&seqg_var->distToUsMtr, &seqg_initvar_distToUsMtr, sizeof(seqg_initvar_distToUsMtr)); } { # line 55 "../setGap.stt" static double seqg_initvar_distToDsMtr = 2620.525; memcpy(&seqg_var->distToDsMtr, &seqg_initvar_distToDsMtr, sizeof(seqg_initvar_distToDsMtr)); } { # line 57 "../setGap.stt" static double seqg_initvar_distBtwnMtr = 1822.000; memcpy(&seqg_var->distBtwnMtr, &seqg_initvar_distBtwnMtr, sizeof(seqg_initvar_distBtwnMtr)); } { # line 60 "../setGap.stt" static double seqg_initvar_desiredGapTemp = 0; memcpy(&seqg_var->desiredGapTemp, &seqg_initvar_desiredGapTemp, sizeof(seqg_initvar_desiredGapTemp)); } { # line 61 "../setGap.stt" static double seqg_initvar_deadbandTemp = 0; memcpy(&seqg_var->deadbandTemp, &seqg_initvar_deadbandTemp, sizeof(seqg_initvar_deadbandTemp)); } { # line 62 "../setGap.stt" static double seqg_initvar_desiredUsMotorPosition = 0; memcpy(&seqg_var->desiredUsMotorPosition, &seqg_initvar_desiredUsMotorPosition, sizeof(seqg_initvar_desiredUsMotorPosition)); } { # line 63 "../setGap.stt" static double seqg_initvar_desiredDsMotorPosition = 0; memcpy(&seqg_var->desiredDsMotorPosition, &seqg_initvar_desiredDsMotorPosition, sizeof(seqg_initvar_desiredDsMotorPosition)); } { # line 64 "../setGap.stt" static double seqg_initvar_usaMotorAmountToMove = 0; memcpy(&seqg_var->usaMotorAmountToMove, &seqg_initvar_usaMotorAmountToMove, sizeof(seqg_initvar_usaMotorAmountToMove)); } { # line 65 "../setGap.stt" static double seqg_initvar_uswMotorAmountToMove = 0; memcpy(&seqg_var->uswMotorAmountToMove, &seqg_initvar_uswMotorAmountToMove, sizeof(seqg_initvar_uswMotorAmountToMove)); } { # line 66 "../setGap.stt" static double seqg_initvar_dsaMotorAmountToMove = 0; memcpy(&seqg_var->dsaMotorAmountToMove, &seqg_initvar_dsaMotorAmountToMove, sizeof(seqg_initvar_dsaMotorAmountToMove)); } { # line 67 "../setGap.stt" static double seqg_initvar_dswMotorAmountToMove = 0; memcpy(&seqg_var->dswMotorAmountToMove, &seqg_initvar_dswMotorAmountToMove, sizeof(seqg_initvar_dswMotorAmountToMove)); } { # line 68 "../setGap.stt" static double seqg_initvar_moveFraction = 0.9; memcpy(&seqg_var->moveFraction, &seqg_initvar_moveFraction, sizeof(seqg_initvar_moveFraction)); } { # line 69 "../setGap.stt" static double seqg_initvar_deadband_hg = 0.0010; memcpy(&seqg_var->deadband_hg, &seqg_initvar_deadband_hg, sizeof(seqg_initvar_deadband_hg)); } { # line 70 "../setGap.stt" static double seqg_initvar_deadband_fg = 0.00025; memcpy(&seqg_var->deadband_fg, &seqg_initvar_deadband_fg, sizeof(seqg_initvar_deadband_fg)); } { # line 73 "../setGap.stt" static int seqg_initvar_fullGapEncCorrection = 0; memcpy(&seqg_var->fullGapEncCorrection, &seqg_initvar_fullGapEncCorrection, sizeof(seqg_initvar_fullGapEncCorrection)); } { # line 74 "../setGap.stt" static int seqg_initvar_fullGapCorrectionNeeded = 0; memcpy(&seqg_var->fullGapCorrectionNeeded, &seqg_initvar_fullGapCorrectionNeeded, sizeof(seqg_initvar_fullGapCorrectionNeeded)); } { # line 75 "../setGap.stt" static double seqg_initvar_currentGapFromFullGapEncoders = 0; memcpy(&seqg_var->currentGapFromFullGapEncoders, &seqg_initvar_currentGapFromFullGapEncoders, sizeof(seqg_initvar_currentGapFromFullGapEncoders)); } { # line 76 "../setGap.stt" static double seqg_initvar_currentTaperFromFullGapEncoders = 0; memcpy(&seqg_var->currentTaperFromFullGapEncoders, &seqg_initvar_currentTaperFromFullGapEncoders, sizeof(seqg_initvar_currentTaperFromFullGapEncoders)); } { # line 77 "../setGap.stt" static double seqg_initvar_userDesiredGap = 0; memcpy(&seqg_var->userDesiredGap, &seqg_initvar_userDesiredGap, sizeof(seqg_initvar_userDesiredGap)); } { # line 78 "../setGap.stt" static double seqg_initvar_userDesiredTaper = 0; memcpy(&seqg_var->userDesiredTaper, &seqg_initvar_userDesiredTaper, sizeof(seqg_initvar_userDesiredTaper)); } { # line 79 "../setGap.stt" static double seqg_initvar_usError = 0; memcpy(&seqg_var->usError, &seqg_initvar_usError, sizeof(seqg_initvar_usError)); } { # line 80 "../setGap.stt" static double seqg_initvar_dsError = 0; memcpy(&seqg_var->dsError, &seqg_initvar_dsError, sizeof(seqg_initvar_dsError)); } { # line 81 "../setGap.stt" static double seqg_initvar_deltaError = 0; memcpy(&seqg_var->deltaError, &seqg_initvar_deltaError, sizeof(seqg_initvar_deltaError)); } { # line 83 "../setGap.stt" static double seqg_initvar_usaPos = 0; memcpy(&seqg_var->usaPos, &seqg_initvar_usaPos, sizeof(seqg_initvar_usaPos)); } { # line 84 "../setGap.stt" static double seqg_initvar_uswPos = 0; memcpy(&seqg_var->uswPos, &seqg_initvar_uswPos, sizeof(seqg_initvar_uswPos)); } { # line 85 "../setGap.stt" static double seqg_initvar_dsaPos = 0; memcpy(&seqg_var->dsaPos, &seqg_initvar_dsaPos, sizeof(seqg_initvar_dsaPos)); } { # line 86 "../setGap.stt" static double seqg_initvar_dswPos = 0; memcpy(&seqg_var->dswPos, &seqg_initvar_dswPos, sizeof(seqg_initvar_dswPos)); } { # line 87 "../setGap.stt" static int seqg_initvar_usaPos_raw = 0; memcpy(&seqg_var->usaPos_raw, &seqg_initvar_usaPos_raw, sizeof(seqg_initvar_usaPos_raw)); } { # line 88 "../setGap.stt" static int seqg_initvar_uswPos_raw = 0; memcpy(&seqg_var->uswPos_raw, &seqg_initvar_uswPos_raw, sizeof(seqg_initvar_uswPos_raw)); } { # line 89 "../setGap.stt" static int seqg_initvar_dsaPos_raw = 0; memcpy(&seqg_var->dsaPos_raw, &seqg_initvar_dsaPos_raw, sizeof(seqg_initvar_dsaPos_raw)); } { # line 90 "../setGap.stt" static int seqg_initvar_dswPos_raw = 0; memcpy(&seqg_var->dswPos_raw, &seqg_initvar_dswPos_raw, sizeof(seqg_initvar_dswPos_raw)); } { # line 91 "../setGap.stt" static int seqg_initvar_moveVelo_raw = 0; memcpy(&seqg_var->moveVelo_raw, &seqg_initvar_moveVelo_raw, sizeof(seqg_initvar_moveVelo_raw)); } { # line 92 "../setGap.stt" static int seqg_initvar_acclDccl_raw = 0; memcpy(&seqg_var->acclDccl_raw, &seqg_initvar_acclDccl_raw, sizeof(seqg_initvar_acclDccl_raw)); } { # line 94 "../setGap.stt" static int seqg_initvar_sampleRate = 0; memcpy(&seqg_var->sampleRate, &seqg_initvar_sampleRate, sizeof(seqg_initvar_sampleRate)); } { # line 95 "../setGap.stt" static double seqg_initvar_scalingFactorVelo = 0; memcpy(&seqg_var->scalingFactorVelo, &seqg_initvar_scalingFactorVelo, sizeof(seqg_initvar_scalingFactorVelo)); } { # line 96 "../setGap.stt" static double seqg_initvar_scalingFactorAD = 0; memcpy(&seqg_var->scalingFactorAD, &seqg_initvar_scalingFactorAD, sizeof(seqg_initvar_scalingFactorAD)); } { # line 97 "../setGap.stt" static double seqg_initvar_deadband = 0.010; memcpy(&seqg_var->deadband, &seqg_initvar_deadband, sizeof(seqg_initvar_deadband)); } } /****** Code for state "init" in state set "setGap" ******/ /* Entry function for state "init" in state set "setGap" */ static void seqg_entry_setGap_0_init(SS_ID seqg_env) { # line 180 "../setGap.stt" seq_pvGetTmo(seqg_env, 53/*debugLevel*/, SYNC, DEFAULT_TIMEOUT); # line 181 "../setGap.stt" if (seqg_var->debugLevel) # line 181 "../setGap.stt" logToIOCshell(ssId, "setGap:init: entry"); # line 183 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:init"); # line 184 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); # line 185 "../setGap.stt" seqg_var->sg_status = 0; # line 188 "../setGap.stt" seqg_var->stop = 0; # line 189 "../setGap.stt" seq_pvPutTmo(seqg_env, 45/*stop*/, SYNC, DEFAULT_TIMEOUT); # line 190 "../setGap.stt" seqg_var->retry = 0; # line 191 "../setGap.stt" seq_pvPutTmo(seqg_env, 13/*retry*/, SYNC, DEFAULT_TIMEOUT); # line 192 "../setGap.stt" seqg_var->overcurrents = 0; # line 193 "../setGap.stt" seq_pvPutTmo(seqg_env, 12/*overcurrents*/, SYNC, DEFAULT_TIMEOUT); # line 194 "../setGap.stt" seqg_var->startGapAdjustment = 0; # line 195 "../setGap.stt" seq_pvPutTmo(seqg_env, 44/*startGapAdjustment*/, SYNC, DEFAULT_TIMEOUT); # line 196 "../setGap.stt" seqg_var->deviceActive = 0; # line 197 "../setGap.stt" seq_pvPutTmo(seqg_env, 50/*deviceActive*/, SYNC, DEFAULT_TIMEOUT); # line 198 "../setGap.stt" seqg_var->numAxes = 4; # line 201 "../setGap.stt" seqg_var->asynPort = seq_macValueGet(seqg_env, "PORT"); pVar->sg_status = pasynOctetSyncIO->connect(pVar->asynPort, 0, (asynUser **)&pVar->pasynUser, NULL); # line 203 "../setGap.stt" if (seqg_var->sg_status != 0) { # line 204 "../setGap.stt" logToIOCshell(ssId, "trajectoryScan error in pasynOctetSyncIO->connect"); # line 205 "../setGap.stt" printf(" sg_status=%d, port=%s\n", seqg_var->sg_status, seqg_var->asynPort); } # line 209 "../setGap.stt" sprintf(seqg_var->stringOut, "RSAMP:1"); pVar->sg_status = writeRead(ssId, pVar, pVar->stringOut, pVar->stringIn, pVar->setGapState); # line 211 "../setGap.stt" if (seqg_var->sg_status != 0) # line 212 "../setGap.stt" seqg_var->sampleRate = 8000; else # line 214 "../setGap.stt" seqg_var->sampleRate = atoi(seqg_var->stringIn); # line 217 "../setGap.stt" seqg_var->scalingFactorVelo = 65536.0 / seqg_var->sampleRate; # line 218 "../setGap.stt" seqg_var->scalingFactorAD = seqg_var->scalingFactorVelo / seqg_var->sampleRate; # line 220 "../setGap.stt" if (seqg_var->initStatus == 0) # line 220 "../setGap.stt" seqg_var->initStatus = 1; # line 221 "../setGap.stt" if (seqg_var->debugLevel) # line 221 "../setGap.stt" logToIOCshell(ssId, "setGap:init: done; going to 'idle'"); } /* Event function for state "init" in state set "setGap" */ static seqBool seqg_event_setGap_0_init(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { if (TRUE) { *seqg_pnst = 1; *seqg_ptrn = 0; return TRUE; } return FALSE; } /* Action function for state "init" in state set "setGap" */ static void seqg_action_setGap_0_init(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { } return; } } /****** Code for state "idle" in state set "setGap" ******/ /* Entry function for state "idle" in state set "setGap" */ static void seqg_entry_setGap_0_idle(SS_ID seqg_env) { # line 232 "../setGap.stt" if (seqg_var->debugLevel) # line 232 "../setGap.stt" logToIOCshell(ssId, "setGap:idle: entry"); # line 233 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:idle"); # line 234 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); # line 236 "../setGap.stt" seqg_var->startGapAdjustment = 0; # line 237 "../setGap.stt" seq_pvPutTmo(seqg_env, 44/*startGapAdjustment*/, SYNC, DEFAULT_TIMEOUT); # line 238 "../setGap.stt" if (seqg_var->deviceActive < 2) { # line 239 "../setGap.stt" seqg_var->deviceActive = 0; # line 240 "../setGap.stt" seq_pvPutTmo(seqg_env, 50/*deviceActive*/, SYNC, DEFAULT_TIMEOUT); } # line 242 "../setGap.stt" seqg_var->movingLarger = 0; # line 243 "../setGap.stt" seqg_var->fullGapEncCorrection = 0; } /* Event function for state "idle" in state set "setGap" */ static seqBool seqg_event_setGap_0_idle(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 247 "../setGap.stt" if (seqg_var->sg_status != 0) { *seqg_pnst = 1; *seqg_ptrn = 0; return TRUE; } # line 253 "../setGap.stt" if (seqg_var->stop == 1) { *seqg_pnst = 7; *seqg_ptrn = 1; return TRUE; } # line 258 "../setGap.stt" if ((seqg_var->startGapAdjustment == 1) && ((seqg_var->undulatorError == 1) || (seqg_var->checkGap == 1))) { *seqg_pnst = 1; *seqg_ptrn = 2; return TRUE; } # line 268 "../setGap.stt" if ((seqg_var->startGapAdjustment == 1) && (seqg_var->undulatorError == 0) && (seqg_var->checkGap == 0)) { *seqg_pnst = 2; *seqg_ptrn = 3; return TRUE; } return FALSE; } /* Action function for state "idle" in state set "setGap" */ static void seqg_action_setGap_0_idle(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 248 "../setGap.stt" printf(" setGap:idle ERROR: previous writeCommand()/writeRead() returned %d. Clearing the status and returning to idle.\n", seqg_var->sg_status); # line 249 "../setGap.stt" seqg_var->sg_status = 0; } return; case 1: { # line 254 "../setGap.stt" if (seqg_var->debugLevel) # line 254 "../setGap.stt" logToIOCshell(ssId, "setGap:idle: going to 'stop'"); } return; case 2: { # line 260 "../setGap.stt" sprintf(seqg_var->message2, "Device not ready to move!"); # line 261 "../setGap.stt" seq_pvPutTmo(seqg_env, 52/*message2*/, SYNC, DEFAULT_TIMEOUT); # line 263 "../setGap.stt" seqg_var->startGapAdjustment = 0; # line 264 "../setGap.stt" seq_pvPutTmo(seqg_env, 44/*startGapAdjustment*/, SYNC, DEFAULT_TIMEOUT); } return; case 3: { # line 271 "../setGap.stt" seq_pvGetTmo(seqg_env, 0/*desiredGap*/, SYNC, DEFAULT_TIMEOUT); # line 272 "../setGap.stt" seq_pvGetTmo(seqg_env, 1/*desiredTaper*/, SYNC, DEFAULT_TIMEOUT); # line 273 "../setGap.stt" seqg_var->userDesiredGap = seqg_var->desiredGap; # line 274 "../setGap.stt" seqg_var->userDesiredTaper = seqg_var->desiredTaper; # line 275 "../setGap.stt" seq_pvGetTmo(seqg_env, 2/*desiredUsGap*/, SYNC, DEFAULT_TIMEOUT); # line 276 "../setGap.stt" seq_pvGetTmo(seqg_env, 3/*desiredDsGap*/, SYNC, DEFAULT_TIMEOUT); # line 277 "../setGap.stt" seq_pvGetTmo(seqg_env, 4/*deadband_mm*/, SYNC, DEFAULT_TIMEOUT); # line 278 "../setGap.stt" seq_pvGetTmo(seqg_env, 5/*deadband_enc*/, SYNC, DEFAULT_TIMEOUT); # line 280 "../setGap.stt" seqg_var->deadband_mm = seqg_var->deadband_mm / 1000.; # line 281 "../setGap.stt" seqg_var->deadband_enc = seqg_var->deadband_enc / 1000.; # line 282 "../setGap.stt" seq_pvGetTmo(seqg_env, 6/*moveFrac*/, SYNC, DEFAULT_TIMEOUT); # line 283 "../setGap.stt" seq_pvGetTmo(seqg_env, 9/*moveVelo*/, SYNC, DEFAULT_TIMEOUT); # line 284 "../setGap.stt" seq_pvGetTmo(seqg_env, 10/*acclDccl*/, SYNC, DEFAULT_TIMEOUT); # line 285 "../setGap.stt" seq_pvGetTmo(seqg_env, 43/*motorResolution*/, SYNC, DEFAULT_TIMEOUT); # line 286 "../setGap.stt" seq_pvGetTmo(seqg_env, 14/*retryMax*/, SYNC, DEFAULT_TIMEOUT); # line 289 "../setGap.stt" seqg_var->deadband_fg = seqg_var->deadband_mm; # line 293 "../setGap.stt" if (seqg_var->clEncSelection == 0) { # line 294 "../setGap.stt" seqg_var->deadband_hg = seqg_var->deadband_mm; # line 295 "../setGap.stt" seqg_var->deadband_enc = (seqg_var->deadband_mm * 1000.0); # line 296 "../setGap.stt" seq_pvPutTmo(seqg_env, 5/*deadband_enc*/, SYNC, DEFAULT_TIMEOUT); } else { # line 300 "../setGap.stt" seqg_var->deadband_hg = seqg_var->deadband_enc; } # line 303 "../setGap.stt" if (seqg_var->debugLevel) # line 303 "../setGap.stt" printf("setGap:dle: deadband_mm = %f, deadband_enc = %f, deadband_hg = %f, deadband_fg = %f\n", seqg_var->deadband_mm, seqg_var->deadband_enc, seqg_var->deadband_hg, seqg_var->deadband_fg); # line 306 "../setGap.stt" sprintf(seqg_var->message1, "Device Started"); # line 307 "../setGap.stt" seq_pvPutTmo(seqg_env, 51/*message1*/, SYNC, DEFAULT_TIMEOUT); # line 308 "../setGap.stt" sprintf(seqg_var->message2, " "); # line 309 "../setGap.stt" seq_pvPutTmo(seqg_env, 52/*message2*/, SYNC, DEFAULT_TIMEOUT); # line 312 "../setGap.stt" if (seqg_var->desiredGap > seqg_var->actualGap) # line 313 "../setGap.stt" seqg_var->movingDirection = 1; else # line 315 "../setGap.stt" seqg_var->movingDirection = 0; # line 316 "../setGap.stt" seq_pvPutTmo(seqg_env, 49/*movingDirection*/, SYNC, DEFAULT_TIMEOUT); # line 319 "../setGap.stt" seqg_var->retry = 0; # line 320 "../setGap.stt" seq_pvPutTmo(seqg_env, 13/*retry*/, SYNC, DEFAULT_TIMEOUT); # line 321 "../setGap.stt" seqg_var->startGapAdjustment = 0; # line 322 "../setGap.stt" seq_pvPutTmo(seqg_env, 44/*startGapAdjustment*/, SYNC, DEFAULT_TIMEOUT); # line 323 "../setGap.stt" seqg_var->deviceActive = 1; # line 324 "../setGap.stt" seq_pvPutTmo(seqg_env, 50/*deviceActive*/, SYNC, DEFAULT_TIMEOUT); # line 327 "../setGap.stt" if ((seqg_var->desiredGap > seqg_var->actualGap) && (seqg_var->singleApproach == 1)) { # line 329 "../setGap.stt" seqg_var->desiredGapTemp = seqg_var->desiredGap; # line 330 "../setGap.stt" seqg_var->deadbandTemp = seqg_var->deadband_mm; # line 332 "../setGap.stt" seqg_var->desiredGap = seqg_var->desiredGap + 1; # line 333 "../setGap.stt" seqg_var->deadband_mm = 0.0005; # line 334 "../setGap.stt" seqg_var->movingLarger = 1; } # line 336 "../setGap.stt" if (seqg_var->debugLevel) # line 336 "../setGap.stt" logToIOCshell(ssId, "setGap:idle: going to 'calcMove'"); } return; } } /****** Code for state "calcMove" in state set "setGap" ******/ /* Entry function for state "calcMove" in state set "setGap" */ static void seqg_entry_setGap_0_calcMove(SS_ID seqg_env) { # line 343 "../setGap.stt" if (seqg_var->debugLevel) # line 343 "../setGap.stt" logToIOCshell(ssId, "setGap:calcMove: entry'"); # line 344 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:calcMove"); # line 345 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); } /* Event function for state "calcMove" in state set "setGap" */ static seqBool seqg_event_setGap_0_calcMove(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 349 "../setGap.stt" if ((seqg_var->stop == 1) || (seqg_var->sg_status != 0)) { *seqg_pnst = 7; *seqg_ptrn = 0; return TRUE; } # line 355 "../setGap.stt" if (seqg_var->retry >= seqg_var->retryMax) { *seqg_pnst = 6; *seqg_ptrn = 1; return TRUE; } # line 360 "../setGap.stt" if ((seqg_var->movingLarger == 1) && (seqg_var->actualGap > (seqg_var->desiredGap - 0.5))) { *seqg_pnst = 6; *seqg_ptrn = 2; return TRUE; } if (TRUE) { *seqg_pnst = 3; *seqg_ptrn = 3; return TRUE; } return FALSE; } /* Action function for state "calcMove" in state set "setGap" */ static void seqg_action_setGap_0_calcMove(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 350 "../setGap.stt" if (seqg_var->sg_status != 0) # line 351 "../setGap.stt" printf(" setGap:calcMove ERROR: previous writeRead() returned %d. Going to stop.\n", seqg_var->sg_status); } return; case 1: { # line 356 "../setGap.stt" if (seqg_var->debugLevel) # line 356 "../setGap.stt" printf("setGap:calcMove: retry >= retryMax %d >= %d\n", seqg_var->retry, seqg_var->retryMax); } return; case 2: { # line 361 "../setGap.stt" if (seqg_var->debugLevel) # line 361 "../setGap.stt" logToIOCshell(ssId, "setGap:calcMove: single approach, above desired gap"); } return; case 3: { # line 367 "../setGap.stt" seqg_var->calibMotors = 1; # line 368 "../setGap.stt" seq_pvPutTmo(seqg_env, 48/*calibMotors*/, SYNC, DEFAULT_TIMEOUT); # line 371 "../setGap.stt" if (seqg_var->fullGapEncCorrection && (seqg_var->movingLarger == 0)) { # line 372 "../setGap.stt" if (seqg_var->debugLevel) # line 373 "../setGap.stt" printf(" ** Performing full gap encoder correction **\n"); # line 374 "../setGap.stt" printf(" US encoder: %f , DS encoder: %f\n", seqg_var->usFullGapEncoder, seqg_var->dsFullGapEncoder); # line 375 "../setGap.stt" seqg_var->usError = (seqg_var->desiredUsGap - seqg_var->usFullGapEncoder) / 2.0; # line 376 "../setGap.stt" seqg_var->dsError = (seqg_var->desiredDsGap - seqg_var->dsFullGapEncoder) / 2.0; # line 377 "../setGap.stt" seqg_var->deltaError = seqg_var->dsError - seqg_var->usError; # line 379 "../setGap.stt" seqg_var->usaMotorAmountToMove = seqg_var->usError + (seqg_var->distToUsMtr / seqg_var->distEndToEnd) * seqg_var->deltaError; # line 380 "../setGap.stt" seqg_var->uswMotorAmountToMove = seqg_var->usError + (seqg_var->distToUsMtr / seqg_var->distEndToEnd) * seqg_var->deltaError; # line 381 "../setGap.stt" seqg_var->dsaMotorAmountToMove = seqg_var->usError + (seqg_var->distToDsMtr / seqg_var->distEndToEnd) * seqg_var->deltaError; # line 382 "../setGap.stt" seqg_var->dswMotorAmountToMove = seqg_var->usError + (seqg_var->distToDsMtr / seqg_var->distEndToEnd) * seqg_var->deltaError; # line 384 "../setGap.stt" printf("usError %f dsError %f deltaError %f\n", seqg_var->usError, seqg_var->dsError, seqg_var->deltaError); # line 385 "../setGap.stt" printf("usaMotorAmountToMove %f uswMotorAmountToMove %f \n", seqg_var->usaMotorAmountToMove, seqg_var->uswMotorAmountToMove); # line 386 "../setGap.stt" printf("dsaMotorAmountToMove %f dswMotorAmountToMove %f \n", seqg_var->dsaMotorAmountToMove, seqg_var->dswMotorAmountToMove); } else { # line 394 "../setGap.stt" if (seqg_var->debugLevel) # line 395 "../setGap.stt" printf(" ** Performing half gap encoder correction **\n"); # line 398 "../setGap.stt" seqg_var->desiredUsMotorPosition = (seqg_var->desiredGap / 2.0) + (seqg_var->distToUsMtr / seqg_var->distEndToEnd) * (seqg_var->desiredTaper / 2.0); # line 399 "../setGap.stt" seqg_var->desiredDsMotorPosition = (seqg_var->desiredGap / 2.0) + (seqg_var->distToDsMtr / seqg_var->distEndToEnd) * (seqg_var->desiredTaper / 2.0); # line 401 "../setGap.stt" seqg_var->usaMotorAmountToMove = seqg_var->desiredUsMotorPosition - seqg_var->usaMotorGap; # line 402 "../setGap.stt" seqg_var->uswMotorAmountToMove = seqg_var->desiredUsMotorPosition - seqg_var->uswMotorGap; # line 403 "../setGap.stt" seqg_var->dsaMotorAmountToMove = seqg_var->desiredDsMotorPosition - seqg_var->dsaMotorGap; # line 404 "../setGap.stt" seqg_var->dswMotorAmountToMove = seqg_var->desiredDsMotorPosition - seqg_var->dswMotorGap; } # line 408 "../setGap.stt" if (fabs(seqg_var->actualGap - seqg_var->desiredGap) < seqg_var->finalMoveRange) # line 410 "../setGap.stt" seqg_var->moveFraction = seqg_var->finalMoveFrac; else # line 413 "../setGap.stt" seqg_var->moveFraction = seqg_var->moveFrac; # line 416 "../setGap.stt" seqg_var->usaPos = seqg_var->usaMotorRbv + seqg_var->moveFraction * seqg_var->usaMotorAmountToMove; # line 417 "../setGap.stt" seqg_var->uswPos = seqg_var->uswMotorRbv + seqg_var->moveFraction * seqg_var->uswMotorAmountToMove; # line 418 "../setGap.stt" seqg_var->dsaPos = seqg_var->dsaMotorRbv + seqg_var->moveFraction * seqg_var->dsaMotorAmountToMove; # line 419 "../setGap.stt" seqg_var->dswPos = seqg_var->dswMotorRbv + seqg_var->moveFraction * seqg_var->dswMotorAmountToMove; # line 422 "../setGap.stt" seqg_var->usaPos_raw = (int)(seqg_var->usaPos / seqg_var->motorResolution); # line 423 "../setGap.stt" seqg_var->uswPos_raw = (int)(seqg_var->uswPos / seqg_var->motorResolution); # line 424 "../setGap.stt" seqg_var->dsaPos_raw = (int)(seqg_var->dsaPos / seqg_var->motorResolution); # line 425 "../setGap.stt" seqg_var->dswPos_raw = (int)(seqg_var->dswPos / seqg_var->motorResolution); # line 426 "../setGap.stt" seqg_var->moveVelo_raw = (int)((seqg_var->moveVelo / seqg_var->motorResolution) * seqg_var->scalingFactorVelo); # line 428 "../setGap.stt" seqg_var->acclDccl_raw = (int)(((seqg_var->moveVelo / seqg_var->motorResolution) / seqg_var->acclDccl) * (seqg_var->scalingFactorAD * 100)); # line 430 "../setGap.stt" if (seqg_var->debugLevel) { # line 431 "../setGap.stt" printf(" calcMove: desiredGap = %f, desiredTaper = %f'\n", seqg_var->desiredGap, seqg_var->desiredTaper); # line 432 "../setGap.stt" printf(" calcMove: currentGap = %f, currentTaper = %f'\n", seqg_var->actualGap, seqg_var->actualTaper); # line 433 "../setGap.stt" printf(" calcMove: moveFraction = %f'\n", seqg_var->moveFraction); # line 434 "../setGap.stt" printf(" calcMove: retry = %d'\n", seqg_var->retry); # line 435 "../setGap.stt" printf(" calcMove: usError = %.6f dsError = %.6f'\n", seqg_var->usError, seqg_var->dsError); # line 436 "../setGap.stt" printf(" calcMove: uswPos = %f (%d) Delta to target: %f\n", seqg_var->uswPos, seqg_var->uswPos_raw, seqg_var->uswMotorAmountToMove); # line 437 "../setGap.stt" printf(" calcMove: dswPos = %f (%d) Delta to target: %f\n", seqg_var->dswPos, seqg_var->dswPos_raw, seqg_var->dswMotorAmountToMove); # line 438 "../setGap.stt" printf(" calcMove: dsaPos = %f (%d) Delta to target: %f\n", seqg_var->dsaPos, seqg_var->dsaPos_raw, seqg_var->dsaMotorAmountToMove); # line 439 "../setGap.stt" printf(" calcMove: usaPos = %f (%d) Delta to target: %f\n", seqg_var->usaPos, seqg_var->usaPos_raw, seqg_var->usaMotorAmountToMove); # line 440 "../setGap.stt" printf(" calcMove: moveVelo = %f (%d)\n", seqg_var->moveVelo, seqg_var->moveVelo_raw); # line 441 "../setGap.stt" printf(" calcMove: acclDccl = %f (%d)\n", seqg_var->acclDccl, seqg_var->acclDccl_raw); } } return; } } /****** Code for state "checkMove" in state set "setGap" ******/ /* Entry function for state "checkMove" in state set "setGap" */ static void seqg_entry_setGap_0_checkMove(SS_ID seqg_env) { # line 449 "../setGap.stt" if (seqg_var->debugLevel) { # line 450 "../setGap.stt" logToIOCshell(ssId, "setGap:checkMove: entry"); } # line 452 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:checkMove"); # line 453 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); # line 457 "../setGap.stt" seqg_var->fullGapCorrectionNeeded = ((seqg_var->clEncSelection == 1) && (seqg_var->desiredGap < seqg_var->clRegionOfIntr) && (seqg_var->retry < seqg_var->retryMax) && (fabs(seqg_var->desiredUsGap - seqg_var->usFullGapEncoder) > (2.0 * seqg_var->deadband_fg) || fabs(seqg_var->desiredDsGap - seqg_var->dsFullGapEncoder) > (2.0 * seqg_var->deadband_fg))); # line 462 "../setGap.stt" if (seqg_var->fullGapEncCorrection) { # line 463 "../setGap.stt" seqg_var->deadband = seqg_var->deadband_fg; } else { # line 467 "../setGap.stt" seqg_var->deadband = seqg_var->deadband_hg; } # line 470 "../setGap.stt" if (seqg_var->debugLevel) # line 471 "../setGap.stt" printf(" checkMove: fullGapCorrectionNeeded = %d deadband = %f fullGapEncCorrection = %d\n", seqg_var->fullGapCorrectionNeeded, seqg_var->deadband, seqg_var->fullGapEncCorrection); } /* Event function for state "checkMove" in state set "setGap" */ static seqBool seqg_event_setGap_0_checkMove(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 477 "../setGap.stt" if ((fabs(seqg_var->usaMotorAmountToMove) < seqg_var->deadband) && (fabs(seqg_var->uswMotorAmountToMove) < seqg_var->deadband) && (fabs(seqg_var->dsaMotorAmountToMove) < seqg_var->deadband) && (fabs(seqg_var->dswMotorAmountToMove) < seqg_var->deadband)) { *seqg_pnst = 6; *seqg_ptrn = 0; return TRUE; } if (TRUE) { *seqg_pnst = 4; *seqg_ptrn = 1; return TRUE; } return FALSE; } /* Action function for state "checkMove" in state set "setGap" */ static void seqg_action_setGap_0_checkMove(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 479 "../setGap.stt" if (seqg_var->debugLevel) # line 480 "../setGap.stt" logToIOCshell(ssId, "setGap:checkMove: Move unnecessary; skipping"); } return; case 1: { # line 486 "../setGap.stt" sprintf(seqg_var->stringOut, "iii:1=%d", seqg_var->uswPos_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 488 "../setGap.stt" sprintf(seqg_var->stringOut, "jjj:1=%d", seqg_var->dswPos_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 490 "../setGap.stt" sprintf(seqg_var->stringOut, "kkk:1=%d", seqg_var->dsaPos_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 492 "../setGap.stt" sprintf(seqg_var->stringOut, "lll:1=%d", seqg_var->usaPos_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 494 "../setGap.stt" sprintf(seqg_var->stringOut, "vvv:1=%d", seqg_var->moveVelo_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 496 "../setGap.stt" sprintf(seqg_var->stringOut, "aaa:1=%d", seqg_var->acclDccl_raw); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 500 "../setGap.stt" sprintf(seqg_var->stringOut, "BRKRLS:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); pVar->brake_status = waitBrakesReleased(ssId, pVar); } return; } } /****** Code for state "move" in state set "setGap" ******/ /* Entry function for state "move" in state set "setGap" */ static void seqg_entry_setGap_0_move(SS_ID seqg_env) { # line 511 "../setGap.stt" if (seqg_var->debugLevel) { # line 512 "../setGap.stt" logToIOCshell(ssId, "setGap:move: entry"); } # line 514 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:move"); # line 515 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); } /* Event function for state "move" in state set "setGap" */ static seqBool seqg_event_setGap_0_move(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 519 "../setGap.stt" if ((seqg_var->stop == 1) || (seqg_var->sg_status != 0) || (seqg_var->brake_status == 1)) { *seqg_pnst = 7; *seqg_ptrn = 0; return TRUE; } # line 525 "../setGap.stt" if (seq_delay(seqg_env, 0.2)) { *seqg_pnst = 5; *seqg_ptrn = 1; return TRUE; } return FALSE; } /* Action function for state "move" in state set "setGap" */ static void seqg_action_setGap_0_move(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 520 "../setGap.stt" if (seqg_var->sg_status != 0) # line 521 "../setGap.stt" printf(" setGap:move ERROR: previous write returned %d. Going to stop.\n", seqg_var->sg_status); } return; case 1: { # line 526 "../setGap.stt" if (seqg_var->debugLevel) # line 526 "../setGap.stt" logToIOCshell(ssId, "setGap:move: Waiting for any previous motion to complete"); pVar->sg_status = waitEpicsMotors(ssId, pVar); # line 529 "../setGap.stt" if (seqg_var->debugLevel) # line 529 "../setGap.stt" logToIOCshell(ssId, "setGap:move: Wait complete"); # line 530 "../setGap.stt" printf("waitEpicsMotors status: %d\n", seqg_var->sg_status); # line 533 "../setGap.stt" sprintf(seqg_var->stringOut, "GOSUB(1)"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); } return; } } /****** Code for state "moving" in state set "setGap" ******/ /* Entry function for state "moving" in state set "setGap" */ static void seqg_entry_setGap_0_moving(SS_ID seqg_env) { # line 542 "../setGap.stt" if (seqg_var->debugLevel) # line 542 "../setGap.stt" logToIOCshell(ssId, "setGap:moving: entry"); # line 543 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:moving"); # line 544 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); } /* Event function for state "moving" in state set "setGap" */ static seqBool seqg_event_setGap_0_moving(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 548 "../setGap.stt" if ((seqg_var->stop == 1) || (seqg_var->sg_status != 0)) { *seqg_pnst = 7; *seqg_ptrn = 0; return TRUE; } # line 554 "../setGap.stt" if (seq_delay(seqg_env, 0.2)) { *seqg_pnst = 2; *seqg_ptrn = 1; return TRUE; } return FALSE; } /* Action function for state "moving" in state set "setGap" */ static void seqg_action_setGap_0_moving(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 549 "../setGap.stt" if (seqg_var->sg_status != 0) # line 550 "../setGap.stt" printf(" setGap:move ERROR: previous writeRead() returned %d. Going to stop.\n", seqg_var->sg_status); } return; case 1: { /* C code definitions */ # line 556 "../setGap.stt" pVar->sg_status = waitEpicsMotors(ssId, pVar); # line 557 "../setGap.stt" printf("moving: waitEpicsMotors status: %d\n", seqg_var->sg_status); # line 559 "../setGap.stt" if (seqg_var->sg_status == 2) { # line 560 "../setGap.stt" seqg_var->stop = 1; # line 561 "../setGap.stt" sprintf(seqg_var->message2, "Over-current fault!!"); # line 562 "../setGap.stt" seq_pvPutTmo(seqg_env, 52/*message2*/, SYNC, DEFAULT_TIMEOUT); # line 564 "../setGap.stt" seqg_var->deviceActive = 2; # line 565 "../setGap.stt" seq_pvPutTmo(seqg_env, 50/*deviceActive*/, SYNC, DEFAULT_TIMEOUT); # line 567 "../setGap.stt" seqg_var->overcurrents = seqg_var->overcurrents + 1; # line 568 "../setGap.stt" seq_pvPutTmo(seqg_env, 12/*overcurrents*/, SYNC, DEFAULT_TIMEOUT); } else { # line 572 "../setGap.stt" seqg_var->retry = seqg_var->retry + 1; # line 573 "../setGap.stt" seq_pvPutTmo(seqg_env, 13/*retry*/, SYNC, DEFAULT_TIMEOUT); } } return; } } /****** Code for state "moveComplete" in state set "setGap" ******/ /* Entry function for state "moveComplete" in state set "setGap" */ static void seqg_entry_setGap_0_moveComplete(SS_ID seqg_env) { # line 581 "../setGap.stt" if (seqg_var->debugLevel) # line 581 "../setGap.stt" logToIOCshell(ssId, "setGap:moveComplete: entry'"); # line 582 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:moveComplete"); # line 583 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); } /* Event function for state "moveComplete" in state set "setGap" */ static seqBool seqg_event_setGap_0_moveComplete(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { # line 587 "../setGap.stt" if ((seqg_var->stop == 1) || (seqg_var->sg_status != 0)) { *seqg_pnst = 7; *seqg_ptrn = 0; return TRUE; } # line 593 "../setGap.stt" if (seqg_var->movingLarger == 1) { *seqg_pnst = 2; *seqg_ptrn = 1; return TRUE; } # line 608 "../setGap.stt" if ((seqg_var->clEncSelection == 1) && (seqg_var->desiredGap < seqg_var->clRegionOfIntr) && (seqg_var->retry < seqg_var->retryMax) && (seqg_var->fullGapEncCorrection == 0) && (fabs(seqg_var->desiredUsGap - seqg_var->usFullGapEncoder) > (2.0 * seqg_var->deadband_fg) || fabs(seqg_var->desiredDsGap - seqg_var->dsFullGapEncoder) > (2.0 * seqg_var->deadband_fg))) { *seqg_pnst = 2; *seqg_ptrn = 2; return TRUE; } if (TRUE) { *seqg_pnst = 1; *seqg_ptrn = 3; return TRUE; } return FALSE; } /* Action function for state "moveComplete" in state set "setGap" */ static void seqg_action_setGap_0_moveComplete(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 588 "../setGap.stt" if (seqg_var->sg_status != 0) # line 589 "../setGap.stt" printf(" setGap:move ERROR: previous writeRead() returned %d. Going to stop.\n", seqg_var->sg_status); } return; case 1: { # line 595 "../setGap.stt" seqg_var->movingLarger = 0; # line 596 "../setGap.stt" seqg_var->desiredGap = seqg_var->desiredGapTemp; # line 597 "../setGap.stt" seqg_var->deadband_mm = seqg_var->deadbandTemp; } return; case 2: { # line 611 "../setGap.stt" if (seqg_var->debugLevel) # line 612 "../setGap.stt" logToIOCshell(ssId, "setGap: moveComplete: FullGapEncoder closedLoop: adjusting desired position"); # line 616 "../setGap.stt" seqg_var->fullGapEncCorrection = 1; } return; case 3: { # line 622 "../setGap.stt" sprintf(seqg_var->stringOut, "S:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 624 "../setGap.stt" if (seqg_var->sg_status != 0) { # line 625 "../setGap.stt" sprintf(seqg_var->stringOut, "S:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); } # line 629 "../setGap.stt" sprintf(seqg_var->stringOut, "BRKENG:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 632 "../setGap.stt" sprintf(seqg_var->stringOut, "OFF:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 636 "../setGap.stt" seqg_var->calibMotors = 1; # line 637 "../setGap.stt" seq_pvPutTmo(seqg_env, 48/*calibMotors*/, SYNC, DEFAULT_TIMEOUT); # line 639 "../setGap.stt" if (seqg_var->retry >= seqg_var->retryMax) { # line 640 "../setGap.stt" seqg_var->deviceActive = 2; # line 641 "../setGap.stt" seq_pvPutTmo(seqg_env, 50/*deviceActive*/, SYNC, DEFAULT_TIMEOUT); # line 642 "../setGap.stt" sprintf(seqg_var->message1, "Max Retries Failed"); # line 643 "../setGap.stt" seq_pvPutTmo(seqg_env, 51/*message1*/, DEFAULT, DEFAULT_TIMEOUT); } else { # line 648 "../setGap.stt" sprintf(seqg_var->message1, "Device At Destination"); # line 649 "../setGap.stt" seq_pvPutTmo(seqg_env, 51/*message1*/, DEFAULT, DEFAULT_TIMEOUT); } # line 653 "../setGap.stt" if (seqg_var->debugLevel) { # line 654 "../setGap.stt" printf(" moveComplete: usFullGapEncoder = %f mm, dsFullGapEncoder = %f mm\n", seqg_var->usFullGapEncoder, seqg_var->dsFullGapEncoder); # line 655 "../setGap.stt" printf(" moveComplete: usaHalfGapEncoder = %f mm, uswHalfGapEncoder = %f mm\n", seqg_var->usaHalfGapEncoder, seqg_var->uswHalfGapEncoder); # line 656 "../setGap.stt" printf(" moveComplete: dsaHalfGapEncoder = %f mm, dswHalfGapEncoder = %f mm\n", seqg_var->dsaHalfGapEncoder, seqg_var->dswHalfGapEncoder); } } return; } } /****** Code for state "stop" in state set "setGap" ******/ /* Entry function for state "stop" in state set "setGap" */ static void seqg_entry_setGap_0_stop(SS_ID seqg_env) { # line 664 "../setGap.stt" if (seqg_var->debugLevel) # line 664 "../setGap.stt" logToIOCshell(ssId, "setGap:stop: entry'"); # line 665 "../setGap.stt" sprintf(seqg_var->setGapState, "setGap:stop"); # line 666 "../setGap.stt" seq_pvPutTmo(seqg_env, 55/*setGapState*/, SYNC, DEFAULT_TIMEOUT); } /* Event function for state "stop" in state set "setGap" */ static seqBool seqg_event_setGap_0_stop(SS_ID seqg_env, int *seqg_ptrn, int *seqg_pnst) { if (TRUE) { *seqg_pnst = 1; *seqg_ptrn = 0; return TRUE; } return FALSE; } /* Action function for state "stop" in state set "setGap" */ static void seqg_action_setGap_0_stop(SS_ID seqg_env, int seqg_trn, int *seqg_pnst) { switch(seqg_trn) { case 0: { # line 672 "../setGap.stt" if (seqg_var->sg_status > 0) # line 673 "../setGap.stt" logToIOCshell(ssId, "Trying to stop the motors after writeRead error! Then transition into idle"); # line 676 "../setGap.stt" sprintf(seqg_var->stringOut, "S:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 678 "../setGap.stt" sprintf(seqg_var->stringOut, "BRKENG:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 681 "../setGap.stt" sprintf(seqg_var->stringOut, "OFF:0"); pVar->sg_status = writeCommand(ssId, pVar, pVar->stringOut, pVar->setGapState); # line 689 "../setGap.stt" seqg_var->stop = 0; # line 690 "../setGap.stt" seq_pvPutTmo(seqg_env, 45/*stop*/, SYNC, DEFAULT_TIMEOUT); # line 692 "../setGap.stt" sprintf(seqg_var->message1, "Device Stopped"); # line 693 "../setGap.stt" seq_pvPutTmo(seqg_env, 51/*message1*/, SYNC, DEFAULT_TIMEOUT); } return; } } #undef seqg_var /************************ Tables ************************/ /* Channel table */ static seqChan seqg_chans[] = { /* chName, offset, varName, varType, count, eventNum, efId, monitored, queueSize, queueIndex */ {"{DEV}:GapDes", offsetof(struct seqg_vars, desiredGap), "desiredGap", P_DOUBLE, 1, 1, 0, 0, 0, 0}, {"{DEV}:TaperDes", offsetof(struct seqg_vars, desiredTaper), "desiredTaper", P_DOUBLE, 1, 2, 0, 0, 0, 0}, {"{DEV}:US:GapDes", offsetof(struct seqg_vars, desiredUsGap), "desiredUsGap", P_DOUBLE, 1, 3, 0, 0, 0, 0}, {"{DEV}:DS:GapDes", offsetof(struct seqg_vars, desiredDsGap), "desiredDsGap", P_DOUBLE, 1, 4, 0, 0, 0, 0}, {"{DEV}:DeadbandHgEnc", offsetof(struct seqg_vars, deadband_mm), "deadband_mm", P_DOUBLE, 1, 5, 0, 0, 0, 0}, {"{DEV}:DeadbandFgEnc", offsetof(struct seqg_vars, deadband_enc), "deadband_enc", P_DOUBLE, 1, 6, 0, 0, 0, 0}, {"{DEV}:MoveFraction", offsetof(struct seqg_vars, moveFrac), "moveFrac", P_DOUBLE, 1, 7, 0, 0, 0, 0}, {"{DEV}:FinalMoveFraction", offsetof(struct seqg_vars, finalMoveFrac), "finalMoveFrac", P_DOUBLE, 1, 8, 0, 0, 0, 0}, {"{DEV}:FinalMoveRange", offsetof(struct seqg_vars, finalMoveRange), "finalMoveRange", P_DOUBLE, 1, 9, 0, 0, 0, 0}, {"{DEV}:MotorsVelocity", offsetof(struct seqg_vars, moveVelo), "moveVelo", P_DOUBLE, 1, 10, 0, 0, 0, 0}, {"{DEV}:MotorsAccl", offsetof(struct seqg_vars, acclDccl), "acclDccl", P_DOUBLE, 1, 11, 0, 0, 0, 0}, {"{DEV}:SingleApproach", offsetof(struct seqg_vars, singleApproach), "singleApproach", P_INT, 1, 12, 0, 1, 0, 0}, {"{DEV}:Overcurrents", offsetof(struct seqg_vars, overcurrents), "overcurrents", P_INT, 1, 13, 0, 0, 0, 0}, {"{DEV}:Retries", offsetof(struct seqg_vars, retry), "retry", P_INT, 1, 14, 0, 0, 0, 0}, {"{DEV}:MaxRetries", offsetof(struct seqg_vars, retryMax), "retryMax", P_INT, 1, 15, 0, 0, 0, 0}, {"{DEV}:CLRegionOfInterest", offsetof(struct seqg_vars, clRegionOfIntr), "clRegionOfIntr", P_DOUBLE, 1, 16, 0, 1, 0, 0}, {"{DEV}:CloseLoopEncoder", offsetof(struct seqg_vars, clEncSelection), "clEncSelection", P_INT, 1, 17, 0, 1, 0, 0}, {"{DEV}:GapAct", offsetof(struct seqg_vars, actualGap), "actualGap", P_DOUBLE, 1, 18, 0, 1, 0, 0}, {"{DEV}:TaperAct", offsetof(struct seqg_vars, actualTaper), "actualTaper", P_DOUBLE, 1, 19, 0, 1, 0, 0}, {"{DEV}:US:GapAct", offsetof(struct seqg_vars, calcUsGap), "calcUsGap", P_DOUBLE, 1, 20, 0, 1, 0, 0}, {"{DEV}:DS:GapAct", offsetof(struct seqg_vars, calcDsGap), "calcDsGap", P_DOUBLE, 1, 21, 0, 1, 0, 0}, {"{DEV}:AisleTaper", offsetof(struct seqg_vars, calcAisleTaper), "calcAisleTaper", P_DOUBLE, 1, 22, 0, 1, 0, 0}, {"{DEV}:WallTaper", offsetof(struct seqg_vars, calcWallTaper), "calcWallTaper", P_DOUBLE, 1, 23, 0, 1, 0, 0}, {"{DEV}:US:Symmetry", offsetof(struct seqg_vars, calcUsSymmetry), "calcUsSymmetry", P_DOUBLE, 1, 24, 0, 1, 0, 0}, {"{DEV}:DS:Symmetry", offsetof(struct seqg_vars, calcDsSymmetry), "calcDsSymmetry", P_DOUBLE, 1, 25, 0, 1, 0, 0}, {"{SDEV}:US:EncRbck", offsetof(struct seqg_vars, usFullGapEncoder), "usFullGapEncoder", P_DOUBLE, 1, 26, 0, 1, 0, 0}, {"{SDEV}:DS:EncRbck", offsetof(struct seqg_vars, dsFullGapEncoder), "dsFullGapEncoder", P_DOUBLE, 1, 27, 0, 1, 0, 0}, {"{DEV}:USPOSX:EncRbck", offsetof(struct seqg_vars, usaHalfGapEncoder), "usaHalfGapEncoder", P_DOUBLE, 1, 28, 0, 1, 0, 0}, {"{DEV}:USNEGX:EncRbck", offsetof(struct seqg_vars, uswHalfGapEncoder), "uswHalfGapEncoder", P_DOUBLE, 1, 29, 0, 1, 0, 0}, {"{DEV}:DSPOSX:EncRbck", offsetof(struct seqg_vars, dsaHalfGapEncoder), "dsaHalfGapEncoder", P_DOUBLE, 1, 30, 0, 1, 0, 0}, {"{DEV}:DSNEGX:EncRbck", offsetof(struct seqg_vars, dswHalfGapEncoder), "dswHalfGapEncoder", P_DOUBLE, 1, 31, 0, 1, 0, 0}, {"{DEV}:USPOSX:Motor.VAL", offsetof(struct seqg_vars, usaMotorVal), "usaMotorVal", P_DOUBLE, 1, 32, 0, 1, 0, 0}, {"{DEV}:USNEGX:Motor.VAL", offsetof(struct seqg_vars, uswMotorVal), "uswMotorVal", P_DOUBLE, 1, 33, 0, 1, 0, 0}, {"{DEV}:DSPOSX:Motor.VAL", offsetof(struct seqg_vars, dsaMotorVal), "dsaMotorVal", P_DOUBLE, 1, 34, 0, 1, 0, 0}, {"{DEV}:DSNEGX:Motor.VAL", offsetof(struct seqg_vars, dswMotorVal), "dswMotorVal", P_DOUBLE, 1, 35, 0, 1, 0, 0}, {"{DEV}:USPOSX:Motor.RBV", offsetof(struct seqg_vars, usaMotorRbv), "usaMotorRbv", P_DOUBLE, 1, 36, 0, 1, 0, 0}, {"{DEV}:USNEGX:Motor.RBV", offsetof(struct seqg_vars, uswMotorRbv), "uswMotorRbv", P_DOUBLE, 1, 37, 0, 1, 0, 0}, {"{DEV}:DSPOSX:Motor.RBV", offsetof(struct seqg_vars, dsaMotorRbv), "dsaMotorRbv", P_DOUBLE, 1, 38, 0, 1, 0, 0}, {"{DEV}:DSNEGX:Motor.RBV", offsetof(struct seqg_vars, dswMotorRbv), "dswMotorRbv", P_DOUBLE, 1, 39, 0, 1, 0, 0}, {"{DEV}:USPOSX:MotorHalfGapAct", offsetof(struct seqg_vars, usaMotorGap), "usaMotorGap", P_DOUBLE, 1, 40, 0, 1, 0, 0}, {"{DEV}:USNEGX:MotorHalfGapAct", offsetof(struct seqg_vars, uswMotorGap), "uswMotorGap", P_DOUBLE, 1, 41, 0, 1, 0, 0}, {"{DEV}:DSPOSX:MotorHalfGapAct", offsetof(struct seqg_vars, dsaMotorGap), "dsaMotorGap", P_DOUBLE, 1, 42, 0, 1, 0, 0}, {"{DEV}:DSNEGX:MotorHalfGapAct", offsetof(struct seqg_vars, dswMotorGap), "dswMotorGap", P_DOUBLE, 1, 43, 0, 1, 0, 0}, {"{DEV}:USPOSX:Motor.MRES", offsetof(struct seqg_vars, motorResolution), "motorResolution", P_DOUBLE, 1, 44, 0, 0, 0, 0}, {"{DEV}:Go", offsetof(struct seqg_vars, startGapAdjustment), "startGapAdjustment", P_INT, 1, 45, 0, 1, 0, 0}, {"{DEV}:Stop", offsetof(struct seqg_vars, stop), "stop", P_INT, 1, 46, 0, 1, 0, 0}, {"{DEV}:CheckGap", offsetof(struct seqg_vars, checkGap), "checkGap", P_INT, 1, 47, 0, 1, 0, 0}, {"{DEV}:UndulatorError", offsetof(struct seqg_vars, undulatorError), "undulatorError", P_INT, 1, 48, 0, 1, 0, 0}, {"{DEV}:CalibrateMotors.PROC", offsetof(struct seqg_vars, calibMotors), "calibMotors", P_INT, 1, 49, 0, 0, 0, 0}, {"{DEV}:MotionDirection", offsetof(struct seqg_vars, movingDirection), "movingDirection", P_INT, 1, 50, 0, 0, 0, 0}, {"{DEV}:DeviceActive", offsetof(struct seqg_vars, deviceActive), "deviceActive", P_INT, 1, 51, 0, 0, 0, 0}, {"{DEV}:IdControlMsg.VAL", offsetof(struct seqg_vars, message1), "message1", P_STRING, 1, 52, 0, 0, 0, 0}, {"{DEV}:EmergencyMsg.VAL", offsetof(struct seqg_vars, message2), "message2", P_STRING, 1, 53, 0, 0, 0, 0}, {"{DEV}:DebugLevel.VAL", offsetof(struct seqg_vars, debugLevel), "debugLevel", P_INT, 1, 54, 0, 1, 0, 0}, {"{DEV}:SimMode.VAL", offsetof(struct seqg_vars, simMode), "simMode", P_INT, 1, 55, 0, 1, 0, 0}, {"{DEV}:SeqProgramState.VAL", offsetof(struct seqg_vars, setGapState), "setGapState", P_STRING, 1, 56, 0, 0, 0, 0}, }; /* Event masks for state set "setGap" */ static const seqMask seqg_mask_setGap_0_init[] = { 0x00000000, 0x00000000, }; static const seqMask seqg_mask_setGap_0_idle[] = { 0x00000000, 0x0001e000, }; static const seqMask seqg_mask_setGap_0_calcMove[] = { 0x0004c002, 0x00004000, }; static const seqMask seqg_mask_setGap_0_checkMove[] = { 0x00000000, 0x00000000, }; static const seqMask seqg_mask_setGap_0_move[] = { 0x00000000, 0x00004000, }; static const seqMask seqg_mask_setGap_0_moving[] = { 0x00000000, 0x00004000, }; static const seqMask seqg_mask_setGap_0_moveComplete[] = { 0x0c03c01a, 0x00004000, }; static const seqMask seqg_mask_setGap_0_stop[] = { 0x00000000, 0x00000000, }; /* State table for state set "setGap" */ static seqState seqg_states_setGap[] = { { /* state name */ "init", /* action function */ seqg_action_setGap_0_init, /* event function */ seqg_event_setGap_0_init, /* entry function */ seqg_entry_setGap_0_init, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_init, /* state options */ (0) }, { /* state name */ "idle", /* action function */ seqg_action_setGap_0_idle, /* event function */ seqg_event_setGap_0_idle, /* entry function */ seqg_entry_setGap_0_idle, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_idle, /* state options */ (0) }, { /* state name */ "calcMove", /* action function */ seqg_action_setGap_0_calcMove, /* event function */ seqg_event_setGap_0_calcMove, /* entry function */ seqg_entry_setGap_0_calcMove, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_calcMove, /* state options */ (0) }, { /* state name */ "checkMove", /* action function */ seqg_action_setGap_0_checkMove, /* event function */ seqg_event_setGap_0_checkMove, /* entry function */ seqg_entry_setGap_0_checkMove, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_checkMove, /* state options */ (0) }, { /* state name */ "move", /* action function */ seqg_action_setGap_0_move, /* event function */ seqg_event_setGap_0_move, /* entry function */ seqg_entry_setGap_0_move, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_move, /* state options */ (0) }, { /* state name */ "moving", /* action function */ seqg_action_setGap_0_moving, /* event function */ seqg_event_setGap_0_moving, /* entry function */ seqg_entry_setGap_0_moving, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_moving, /* state options */ (0) }, { /* state name */ "moveComplete", /* action function */ seqg_action_setGap_0_moveComplete, /* event function */ seqg_event_setGap_0_moveComplete, /* entry function */ seqg_entry_setGap_0_moveComplete, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_moveComplete, /* state options */ (0) }, { /* state name */ "stop", /* action function */ seqg_action_setGap_0_stop, /* event function */ seqg_event_setGap_0_stop, /* entry function */ seqg_entry_setGap_0_stop, /* exit function */ 0, /* event mask array */ seqg_mask_setGap_0_stop, /* state options */ (0) }, }; /* State set table */ static seqSS seqg_statesets[] = { { /* state set name */ "setGap", /* states */ seqg_states_setGap, /* number of states */ 8 }, }; /* Program table (global) */ seqProgram setGap = { /* magic number */ 2002004, /* program name */ "setGap", /* channels */ seqg_chans, /* num. channels */ 56, /* state sets */ seqg_statesets, /* num. state sets */ 1, /* user var size */ sizeof(struct seqg_vars), /* param */ "", /* num. event flags */ 0, /* encoded options */ (0 | OPT_DEBUG | OPT_NEWEF | OPT_REENT), /* init func */ seqg_init, /* entry func */ 0, /* exit func */ 0, /* num. queues */ 0 }; # line 699 "../setGap.stt" /* Write operation through asyn port */ static int writeCommand(SS_ID ssId, struct UserVar *pVar, char *command, char *stateName) { asynStatus status=0; size_t nwrite; char output_buf[BUF_SIZE]; sprintf(output_buf, "%s ", command); if (!(pVar->simMode)) { status = pasynOctetSyncIO->write((asynUser *)pVar->pasynUser, output_buf, strlen(output_buf), 2.0, &nwrite); if (status) printf("writeCommand called from %s: pasynOctetSyncIO->write returned %d\n", stateName, status); } if (pVar->simMode || pVar->debugLevel) { printf(" writeCommand:command='%s'\n", output_buf); } return(status); } /* WriteRead operation through asyn port */ static int writeRead(SS_ID ssId, struct UserVar *pVar, char *command, char *reply, char *stateName) { asynStatus status=0; size_t nwrite, nread; int eomReason; char output_buf[BUF_SIZE]; sprintf(output_buf, "%s ", command); if (!(pVar->simMode)) { status = pasynOctetSyncIO->writeRead((asynUser *)pVar->pasynUser, output_buf, strlen(output_buf), reply, BUF_SIZE, 2.0, &nwrite, &nread, &eomReason); if (status) printf("writeRead called from %s: pasynOctetSyncIO->writeRead returned %d\n", stateName, status); } if (pVar->simMode || pVar->debugLevel) { printf(" writeRead:command='%s', reply='%s'\n", output_buf, reply); } return(status); } /* Check if motors are moving */ static int getMotorMoving(SS_ID ssId, struct UserVar *pVar) { char inputBuff[BUF_SIZE], outputBuff[BUF_SIZE]; size_t nwrite, nread; int eomReason; int move_active = 0; int over_current = 0; int count, status, can_addr; #define MOVING 0x4 #define OVERCURRENT 0x10 for (can_addr=1, count=0; can_addr <= pVar->numAxes; can_addr++) { /* If Stop is issued while in for loop */ if ( pVar->stop == 1 ) return 0; /* Create command that reads motor status word */ sprintf(outputBuff, "RW(0):%d", can_addr); /* Send command to the controller */ status = pasynOctetSyncIO->writeRead((asynUser *)pVar->pasynUser, outputBuff, strlen(outputBuff), inputBuff, BUF_SIZE, 1.0, &nwrite, &nread, &eomReason); if (status) printf("getMotorMoving: pasynOctetSyncIO->writeRead returned %d\n", status); /* Parse return of the command */ move_active |= (atoi(inputBuff) & MOVING) == MOVING; /*parse if overcurrent fault*/ over_current = (atoi(inputBuff) & OVERCURRENT) == OVERCURRENT; if(pVar->debugLevel){ printf("getMotorMoving: can_addr %d inputBuff %s move_active %d over_current %d\n", can_addr, inputBuff, move_active, over_current); } if(over_current == 1) { /*return error exit code*/ return 2; } /* If any motor is moving return 1 */ if (move_active) return 1; /* Otherwise increase the count and continue */ else { count++; if (count>3) break; } } return 0; } /* Wait while motors are moving */ static int waitEpicsMotors(SS_ID ssId, struct UserVar *pVar) { if(pVar->debugLevel) logToIOCshell(ssId, "waitEpicsMotors"); /* Read status of motors, if they are moving */ int rv = 0; rv = getMotorMoving(ssId, pVar); /* Try one more time if motors are not moving */ if(rv == 0) { epicsThreadSleep((1/10.0)); rv = getMotorMoving(ssId, pVar); } epicsThreadSleep((1/10.0)); /*while (getMotorMoving(ssId, pVar)) {*/ while (rv == 1) { epicsThreadSleep((1/10.0)); rv = getMotorMoving(ssId, pVar); printf("waitEpicsMotors %d \n", rv); } return rv; } static int queryBrakesReleased(SS_ID ssId, struct UserVar *pVar) { char inputBuff[BUF_SIZE], outputBuff[BUF_SIZE]; size_t nwrite, nread; int eomReason; int brake_engaged = 0; int status, can_addr; #define BRAKE_ENGAGED 0x1000 for (can_addr=1; can_addr <= pVar->numAxes; can_addr++) { /* If Stop is issued while in for loop */ if ( pVar->stop == 1 ) return 0; /* Create command that reads motor status word */ sprintf(outputBuff, "RW(3):%d", can_addr); /* Send command to the controller */ status = pasynOctetSyncIO->writeRead((asynUser *)pVar->pasynUser, outputBuff, strlen(outputBuff), inputBuff, BUF_SIZE, 1.0, &nwrite, &nread, &eomReason); /* Parse return of the command */ brake_engaged = ((atoi(inputBuff) & BRAKE_ENGAGED) == BRAKE_ENGAGED); if (pVar->debugLevel) { if (status) printf(" checkBrakesReleased: pasynOctetSyncIO->writeRead returned %d\n", status); printf(" checkBrakesReleased: '%s'=>'%s' brake_engaged=%d\n", outputBuff, inputBuff, brake_engaged); } /* If any motor has a brake engaged, return immediately */ if (brake_engaged) return 1; } return 0; } static int waitBrakesReleased(SS_ID ssId, struct UserVar *pVar) { if(pVar->debugLevel) logToIOCshell(ssId, "waitBrakesReleased"); /* Read status of motors, if they are moving */ int failed_count=0; while (queryBrakesReleased(ssId, pVar)) { failed_count++; if (failed_count > 5) { printf("here\n"); return 1; } writeCommand(ssId, pVar, "BRKRLS:0", "waitBrakesReleased"); /* wait a little */ epicsThreadSleep((1/10.0)); } /* Even if the brakes are released, wait a little before returning */ int counter = 0; printf("BRAKES RELEASE WAIT counter %d\n", counter); epicsThreadSleep((1/2.0)); printf("BRAKES RELEASE WAIT done sleeping\n"); return 0; } /* Create a timestamp with current time */ static int getTimeStamp(SS_ID ssId, char *timeStampString) { struct timeval preciseCurrentTime; time_t currentTime_sec; struct tm *currentTime; char tmp_buff[32]; size_t size; gettimeofday(&preciseCurrentTime, NULL); currentTime_sec = preciseCurrentTime.tv_sec; currentTime = localtime(¤tTime_sec); size = strftime(tmp_buff, sizeof tmp_buff, "%Y-%m-%d_%H:%M:%S", currentTime); snprintf(timeStampString, (size + 8) , "%s.%06ld", tmp_buff, preciseCurrentTime.tv_usec); return(0); } static int logToIOCshell(SS_ID ssId, char *logMessage) { char timestamp[32]; getTimeStamp(ssId, timestamp); printf("%s : %s\n",timestamp, logMessage); return(0); } /* Register sequencer commands and program */ #include "epicsExport.h" static void setGapRegistrar (void) { seqRegisterSequencerCommands(); seqRegisterSequencerProgram (&setGap); } epicsExportRegistrar(setGapRegistrar);