FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Public Attributes | List of all members
AcqStage1 Class Reference

#include <AcqStage1.h>

Inheritance diagram for AcqStage1:
Inheritance graph
[legend]
Collaboration diagram for AcqStage1:
Collaboration graph
[legend]

Public Member Functions

 AcqStage1 ()
 
int GetLastError (char *Description, int size)
 
int GetLastModalError (char *Description, int size)
 
bool Initialize ()
 
void Monitor ()
 
void ScanToZ0AndGotoXYZ (float Z0, float Z0speed, float Z0acc, float X, float Y, float XYSpeed, float XYAcc, float Z, float Zspeed, float Zacc, u32 Timeout)
 
void Stop ()
 
virtual ~AcqStage1 ()
 

Public Attributes

bool AbsCoords
 
int BoardId
 
EdbAffine2D * eAffine
 
float EmBase
 
float EmBotLayer
 
float EmTopLayer
 
AcqLight * L
 
float NominalEmBase
 
float NominalEmLayer
 
AcqAxis * X
 
AcqAxis * Y
 
AcqAxis * Z
 
float ZHomingXPos
 
float ZHomingYPos
 

Constructor & Destructor Documentation

◆ AcqStage1()

AcqStage1::AcqStage1 ( )
107{
108/* BoardId=1;
109 XYStepsRev=10000; ZStepsRev=10000;
110 XYLinesRev=5000; ZLinesRev=10000;
111 XYEncoderToMicrons=.1; ZEncoderToMicrons=.05;
112 XYMicronsToSteps=XYStepsRev/XYLinesRev/XYEncoderToMicrons;
113 ZMicronsToSteps=ZStepsRev/ZLinesRev/ZEncoderToMicrons;
114 XYAccel=100000.000000; ZAccel=100000.000000;
115 XYMaxSpeed=25000.000000; ZMaxSpeed=30000.000000;
116 LimPol=0;
117 HomePol=0;
118 CtlModeIsCWCCW=0;
119 TurnOffLightTime=60;
120 InvertX=1; InvertY=0; InvertZ=1;
121 ZBaseThickness=130;
122 ZParkDisplacement=2000;
123 ZHomingSpeed=10000;
124*/
125 BoardId=1;
126 ZHomingXPos=-78000; ZHomingYPos=5000;
127 X=new AcqAxis(1); X->BoardId=1;
128 Y=new AcqAxis(2); Y->BoardId=1;
129 Z=new AcqAxis(3); Z->BoardId=1;
130 L=new AcqLight(); L->BoardId=1;
131 X->StepsRev=10000; Y->StepsRev=10000; Z->StepsRev=10000;
132 X->LinesRev=5000; Y->LinesRev=5000; Z->LinesRev=10000;
133 X->EncoderToMicrons=.1; Y->EncoderToMicrons=.1; Z->EncoderToMicrons=.05;
134 X->MicronsToSteps=X->StepsRev/X->LinesRev/X->EncoderToMicrons;
135 Y->MicronsToSteps=Y->StepsRev/Y->LinesRev/Y->EncoderToMicrons;
136 Z->MicronsToSteps=Z->StepsRev/Z->LinesRev/Z->EncoderToMicrons;
137 X->Accel=100000.000000; Y->Accel=100000.000000; Z->Accel=100000.000000;
138 X->MaxSpeed=25000.000000; Y->MaxSpeed=25000.000000; Z->MaxSpeed=30000.000000;
139 X->LimPol=0;Y->LimPol=0;Z->LimPol=0;
140 X->HomePol=0;Y->HomePol=0;Z->HomePol=0;
141 X->CtlModeIsCWCCW=0;Y->CtlModeIsCWCCW=0;Z->CtlModeIsCWCCW=0;
142 X->Invert=1; Y->Invert=0; Z->Invert=1;
143 X->HomingSpeed=X->MaxSpeed;
144 Y->HomingSpeed=Y->MaxSpeed;
145 Z->HomingSpeed=10000;
146
147 L->TurnOffLightTime=60;
148 L->LightLevel=28600;
149 EmTopLayer=30;
150 EmBotLayer=30;
151 NominalEmLayer=30;
152 NominalEmBase=130;
153 EmBase=130;
154 Z->Reference=317;
155 //Z->Reference = 267;
156 X->Reference=-122000;
157 Y->Reference=33793;
158 Z->NominalReference=317;
159 //Z->NominalReference = 267;
160 X->NominalReference=-122000;
161 Y->NominalReference=33793;
162 eAffine=NULL;
163 AbsCoords=false;
164
165 gStage=this;
166}
gStage
AcqStage1 * gStage
Definition: AcqStage1.cxx:29
AcqAxis
Definition: AcqStage1.h:51
AcqAxis::CtlModeIsCWCCW
int CtlModeIsCWCCW
Definition: AcqStage1.h:68
AcqAxis::LinesRev
int LinesRev
Definition: AcqStage1.h:62
AcqAxis::MicronsToSteps
float MicronsToSteps
Definition: AcqStage1.h:64
AcqAxis::StepsRev
int StepsRev
Definition: AcqStage1.h:61
AcqAxis::HomingSpeed
float HomingSpeed
Definition: AcqStage1.h:71
AcqAxis::BoardId
int BoardId
Definition: AcqStage1.h:60
AcqAxis::Accel
float Accel
Definition: AcqStage1.h:65
AcqAxis::HomePol
int HomePol
Definition: AcqStage1.h:67
AcqAxis::Reference
float Reference
Definition: AcqStage1.h:72
AcqAxis::NominalReference
float NominalReference
Definition: AcqStage1.h:73
AcqAxis::EncoderToMicrons
float EncoderToMicrons
Definition: AcqStage1.h:63
AcqAxis::MaxSpeed
float MaxSpeed
Definition: AcqStage1.h:66
AcqAxis::Invert
int Invert
Definition: AcqStage1.h:70
AcqAxis::LimPol
int LimPol
Definition: AcqStage1.h:67
AcqLight
Definition: AcqStage1.h:107
AcqLight::BoardId
int BoardId
Definition: AcqStage1.h:115
AcqLight::TurnOffLightTime
int TurnOffLightTime
Definition: AcqStage1.h:116
AcqLight::LightLevel
int LightLevel
Definition: AcqStage1.h:117
AcqStage1::EmTopLayer
float EmTopLayer
Definition: AcqStage1.h:140
AcqStage1::EmBase
float EmBase
Definition: AcqStage1.h:142
AcqStage1::AbsCoords
bool AbsCoords
Definition: AcqStage1.h:151
AcqStage1::L
AcqLight * L
Definition: AcqStage1.h:148
AcqStage1::BoardId
int BoardId
Definition: AcqStage1.h:138
AcqStage1::NominalEmLayer
float NominalEmLayer
Definition: AcqStage1.h:143
AcqStage1::NominalEmBase
float NominalEmBase
Definition: AcqStage1.h:144
AcqStage1::EmBotLayer
float EmBotLayer
Definition: AcqStage1.h:141
AcqStage1::eAffine
EdbAffine2D * eAffine
Definition: AcqStage1.h:150
AcqStage1::Y
AcqAxis * Y
Definition: AcqStage1.h:146
AcqStage1::ZHomingXPos
float ZHomingXPos
Definition: AcqStage1.h:139
AcqStage1::ZHomingYPos
float ZHomingYPos
Definition: AcqStage1.h:139
AcqStage1::Z
AcqAxis * Z
Definition: AcqStage1.h:147
AcqStage1::X
AcqAxis * X
Definition: AcqStage1.h:145
NULL
#define NULL
Definition: nidaqmx.h:84

◆ ~AcqStage1()

virtual AcqStage1::~AcqStage1 ( )
inlinevirtual
155{X->Stop(); Y->Stop(); Z->Stop();}
AcqAxis::Stop
void Stop()
Definition: AcqStage1.cxx:502

Member Function Documentation

◆ GetLastError()

int AcqStage1::GetLastError ( char *  Description,
int  size 
)
203 {
204 //Reads an error from error stack, returns 1 if there was an error, 0 if not.
205 u32 sz;
206 i32 code;
207 u16 command;
208 u16 resource;
209 sz=(u32)size;
210 flex_get_last_error(BoardId,&command,&resource,&code);
211 flex_get_error_description(NIMC_COMBINED_DESCRIPTION,code,command,resource,Description, &sz);
212 flex_flush_rdb(BoardId);
213 return code;
214 }
flex_flush_rdb
FLEXFUNC flex_flush_rdb(BOARD)
flex_get_last_error
FLEXFUNC flex_get_last_error(BOARD, u16 *commandID, u16 *resourceID, i32 *errorCode)
flex_get_error_description
FLEXFUNC flex_get_error_description(u16 descriptionType, i32 errorCode, u16 commandID, u16 resourceID, i8 FAR *charArray, u32 FAR *sizeOfArray)
i32
long i32
Definition: MotnCnst.h:35
u32
unsigned long u32
Definition: MotnCnst.h:24
u16
unsigned short u16
Definition: MotnCnst.h:23
NIMC_COMBINED_DESCRIPTION
#define NIMC_COMBINED_DESCRIPTION
Definition: MotnCnst.h:304

◆ GetLastModalError()

int AcqStage1::GetLastModalError ( char *  Description,
int  size 
)
217 {
218 //Reads an error from modal error stack, returns 1 if there was an error, 0 if not.
219 u32 sz;
220 i32 code;
221 u16 command;
222 u16 resource;
223 sz=(u32)size;
224 flex_read_error_msg_rtn(BoardId,&command,&resource,&code);
225 flex_flush_rdb(BoardId);
226 flex_get_error_description(NIMC_COMBINED_DESCRIPTION,code,command,resource,Description, &sz);
227 flex_flush_rdb(BoardId);
228 return code;
229 }
flex_read_error_msg_rtn
FLEXFUNC flex_read_error_msg_rtn(BOARD, u16 FAR *commandID, u16 FAR *resourceID, i32 FAR *errorCode)

◆ Initialize()

bool AcqStage1::Initialize ( )
169{
170//Initialises the board with default OPERA stage parameters
171 try
172 {
173 if (flex_clear_pu_status(BoardId) != NIMC_noError) throw(3);
174 }
175 catch (...)
176 {
177 return false;
178 };
179 if(!X->Initialize()) return false;
180 if(!Y->Initialize()) return false;
181 if(!Z->Initialize()) return false;
182 if(!L->Initialize()) return false;
183 X->MicronsToSteps=X->StepsRev/X->LinesRev/X->EncoderToMicrons;
184 Y->MicronsToSteps=Y->StepsRev/Y->LinesRev/Y->EncoderToMicrons;
185 Z->MicronsToSteps=Z->StepsRev/Z->LinesRev/Z->EncoderToMicrons;
186 Dump();
187 return true;
188
189}
flex_clear_pu_status
FLEXFUNC flex_clear_pu_status(BOARD)
NIMC_noError
#define NIMC_noError
Definition: MotnErr.h:21
AcqAxis::Initialize
bool Initialize()
Definition: AcqStage1.cxx:463
AcqLight::Initialize
bool Initialize()
Definition: AcqStage1.cxx:870

◆ Monitor()

void AcqStage1::Monitor ( )
312{
313 EdbMark *xyz=new EdbMark();
314 char hit=' ';
315 float SpeedFactor=100; //defines speed with respect to MAxSpeed
316 bool MustStop=false;
317 int XMoving=0;
318 int YMoving=0;
319 int ZMoving=0;
320 printf("Stage Monitor started. for key help press 'h'.\n");
321 // TCanvas * c=new TCanvas();
322 while(!MustStop){
323// printf("returned %d\n",num);
324 while(!kbhit()) {
325 xyz->SetX(X->GetPos());
326 xyz->SetY(Y->GetPos());
327 xyz->SetZ(Z->GetPos());
328 if(eAffine && AbsCoords) xyz->Transform(eAffine);
329 for(int ch=0;ch<80;ch++) printf("\b");
330 if(eAffine && AbsCoords) printf("A"); else printf("S");
331 if(X->GetLimiter()==1) printf("L");
332 if(X->GetLimiter()==2) printf("H");
333 printf("X:%9.1f ",xyz->X());
334 if(eAffine && AbsCoords) printf("A"); else printf("S");
335 if(Y->GetLimiter()==1) printf("L");
336 if(Y->GetLimiter()==2) printf("H");
337 printf("Y:%9.1f ",xyz->Y());
338 if(Z->GetLimiter()==1) printf("L");
339 if(Z->GetLimiter()==2) printf("H");
340 printf("Z:%9.1f Speed: max/%d Light: %d ",Z->GetPos(),int(SpeedFactor),L->LightLevel);
341 fflush(stdout);
342 gSystem->Sleep(20);
343 }
344 hit=getch(); //printf("%d\n",hit);
345 if(kbhit())
346 {hit=getch();// printf("%d\n",hit);
347 }
348 switch(hit)
349 {
350 case 'h' :
351 printf("\n\nX-Y movement initiated by arrows\nSPACE to stop all axes\n");
352 printf("+ Speed Up\n- Speed Down\n");
353 printf("1 go to the bottom of emulsion Bottom layer\n");
354 printf("2 go to the top of emulsion Bottom layer\n");
355 printf("3 go to the bottom of emulsion Top layer\n");
356 printf("4 go to the top of emulsion Top layer\n");
357 printf("R go to the reference corner on X,Y\n");
358 printf("x and z to uncrease and decrease light\n");
359 printf("ESC or q to exit monitor\n");
360 printf("Limiter active - 'H' or 'L' displayed at the corresponding axis letter\n\n ");
361 break;
362 case '=': SpeedFactor/=5; if(SpeedFactor<1) SpeedFactor=1;
363 if(XMoving!=0) X->Move(XMoving*X->MaxSpeed/SpeedFactor,1e6);
364 if(YMoving!=0) Y->Move(YMoving*Y->MaxSpeed/SpeedFactor,1e6);
365 if(ZMoving!=0) Z->Move(ZMoving*Z->MaxSpeed/SpeedFactor,1e6);
366 // printf("\nSpeed set to Max/%f\n",SpeedFactor);
367 break;
368 case '-': SpeedFactor*=5; if(SpeedFactor>10000) SpeedFactor=10000;
369 // printf("\nSpeed set to Max/%f\n",SpeedFactor);
370 if(XMoving!=0) X->Move(XMoving*X->MaxSpeed/SpeedFactor,1e6);
371 if(YMoving!=0) Y->Move(YMoving*Y->MaxSpeed/SpeedFactor,1e6);
372 if(ZMoving!=0) Z->Move(ZMoving*Z->MaxSpeed/SpeedFactor,1e6);
373 break;
374 case 75 : X->Move(-X->MaxSpeed/SpeedFactor,1e6);
375 XMoving=-1;
376 break;
377 case 77 : X->Move(X->MaxSpeed/SpeedFactor,1e6);
378 XMoving=1;
379 break;
380 case 72 : Y->Move(Y->MaxSpeed/SpeedFactor,1e6);
381 YMoving=1;
382 break;
383 case 80 : Y->Move(-Y->MaxSpeed/SpeedFactor,1e6);
384 YMoving=-1;
385 break;
386 case 73 : Z->Move(Z->MaxSpeed/SpeedFactor,1e6);
387 ZMoving=1;
388 break;
389 case 81 : Z->Move(-Z->MaxSpeed/SpeedFactor,1e6);
390 ZMoving=-1;
391 break;
392 case '1' : Z->PosMove(Z->Reference,Z->MaxSpeed/SpeedFactor,1e6);
393 Z->WaitForMoveComplete(1e4);
394 break;
395 case '2' : Z->PosMove(Z->Reference+EmBotLayer,Z->MaxSpeed/SpeedFactor,1e6);
396 Z->WaitForMoveComplete(1e4);
397 break;
398 case '3' : Z->PosMove(Z->Reference+EmBotLayer+EmBase,Z->MaxSpeed/SpeedFactor,1e6);
399 Z->WaitForMoveComplete(1e4);
400 break;
401 case '4' : Z->PosMove(Z->Reference+EmBotLayer+EmTopLayer+EmBase,Z->MaxSpeed/SpeedFactor,1e6);
402 Z->WaitForMoveComplete(1e4);
403 break;
404 case 'r' :
405 case 'R' : X->PosMove(X->Reference,1e9,1e9); Y->PosMove(Y->Reference,1e9,1e9);
406 X->WaitForMoveComplete(1e4); Y->WaitForMoveComplete(1e4);
407 break;
408 case 'x' : (L->LightLevel)+=10;L->ON();
409 break;
410 case 'z' : (L->LightLevel)-=10;L->ON();
411 break;
412 case 'a' : AbsCoords=true;
413 break;
414 case 's' : AbsCoords=false;
415 break;
416 case 76 :
417 case ' ':
418 case 'q':
419 case 27 : Stop();
420 XMoving=0; YMoving=0;ZMoving=0;
421// case 72 : {}
422 }
423 if(hit==27 || hit=='q') MustStop=true;
424 }
425 for(int ch=0;ch<40;ch++) printf("\b");
426 printf("\n");
427 fflush(stdout);
428 delete xyz;
429 printf("Monitor stoped. \n");
430
431// c->~TCanvas();
432
433}
stdout
FILE * stdout
AcqAxis::Move
void Move(float Speed, float Acc)
Definition: AcqStage1.cxx:548
AcqAxis::GetLimiter
int GetLimiter()
Definition: AcqStage1.cxx:613
AcqAxis::PosMove
void PosMove(float Pos, float Speed, float Acc)
Definition: AcqStage1.cxx:524
AcqAxis::GetPos
float GetPos()
Definition: AcqStage1.cxx:599
AcqAxis::WaitForMoveComplete
int WaitForMoveComplete(u32 Timeout)
Definition: AcqStage1.cxx:514
AcqLight::ON
void ON()
Definition: AcqStage1.cxx:895
AcqStage1::Stop
void Stop()
Definition: AcqStage1.cxx:193
EdbMark
Definition: EdbFiducial.h:21
EdbMark::Y
Float_t Y() const
Definition: EdbFiducial.h:43
EdbMark::SetY
void SetY(float y)
Definition: EdbFiducial.h:45
EdbMark::SetX
void SetX(float x)
Definition: EdbFiducial.h:44
EdbMark::X
Float_t X() const
Definition: EdbFiducial.h:42
EdbPoint2D::SetZ
virtual void SetZ(float z)
Definition: EdbVirtual.h:86
EdbPoint2D::Transform
virtual void Transform(const EdbAffine2D *a)
Definition: EdbVirtual.cxx:107

◆ ScanToZ0AndGotoXYZ()

void AcqStage1::ScanToZ0AndGotoXYZ ( float  Z0,
float  Z0speed,
float  Z0acc,
float  X,
float  Y,
float  XYSpeed,
float  XYAcc,
float  Z,
float  Zspeed,
float  Zacc,
u32  Timeout 
)
232 {
233 // stores the program #2 on NI7344 to go to Z0, then when reached, goto X,Y,Z
234 // and starts the program
235 u16 MComplete;
236 long ActPos;
237 long retval;
238 int ActSpeed;
239 int ActAccel;
240 flex_set_op_mode(BoardId, 1, NIMC_ABSOLUTE_POSITION);
241 flex_set_op_mode(BoardId, 2, NIMC_ABSOLUTE_POSITION);
242 flex_set_op_mode(BoardId, 3, NIMC_ABSOLUTE_POSITION);
243 flex_begin_store(BoardId,2);
244 // Calc Z0 params
245 ActPos = Z0 * Z->MicronsToSteps;
246 if (Z->Invert) ActPos = -ActPos;
247 if (Z0Speed > Z->MaxSpeed) Z0Speed = Z->MaxSpeed;
248 if (Z0Acc > Z->Accel) Z0Acc = Z->Accel;
249 ActSpeed = abs(Z0Speed * Z->MicronsToSteps);
250 ActAccel = abs(Z0Acc * Z->MicronsToSteps);
251 // Z0 params ready
252
253 flex_load_target_pos(BoardId, 3, ActPos, 0xFF);
254 flex_load_velocity(BoardId, 3, ActSpeed, 0xFF);
255 flex_load_acceleration(BoardId, 3, NIMC_ACCELERATION, ActAccel, 0xFF);
256 flex_load_acceleration(BoardId, 3, NIMC_DECELERATION, ActAccel, 0xFF);
257 // Calc X params
258 ActPos = X0 * X->MicronsToSteps;
259 if (X->Invert) ActPos = -ActPos;
260 if (XYSpeed > X->MaxSpeed) XYSpeed = X->MaxSpeed;
261 if (XYAcc > X->Accel) XYAcc = X->Accel;
262 ActSpeed = abs(XYSpeed * X->MicronsToSteps);
263 ActAccel = abs(XYAcc * X->MicronsToSteps);
264 // X params ready
265 flex_load_target_pos(BoardId, 1, ActPos, 0xFF);
266 flex_load_velocity(BoardId, 1, ActSpeed, 0xFF);
267 flex_load_acceleration(BoardId, 1, NIMC_ACCELERATION, ActAccel, 0xFF);
268 flex_load_acceleration(BoardId, 1, NIMC_DECELERATION, ActAccel, 0xFF);
269 // Calc Y params
270 ActPos = Y0 * Y->MicronsToSteps;
271 if (Y->Invert) ActPos = -ActPos;
272 if (XYSpeed > Y->MaxSpeed) XYSpeed = Y->MaxSpeed;
273 if (XYAcc > Y->Accel) XYAcc = Y->Accel;
274 ActSpeed = abs(XYSpeed * Y->MicronsToSteps);
275 ActAccel = abs(XYAcc * Y->MicronsToSteps);
276 // Y params ready
277 flex_load_target_pos(BoardId, 2, ActPos, 0xFF);
278 flex_load_velocity(BoardId, 2, ActSpeed, 0xFF);
279 flex_load_acceleration(BoardId, 2, NIMC_ACCELERATION, ActAccel, 0xFF);
280 flex_load_acceleration(BoardId, 2, NIMC_DECELERATION, ActAccel, 0xFF);
281//Now move to Z0
282 flex_start(BoardId, 3, 0);
283 //and wait till complete
284 flex_wait_on_condition(BoardId, 0,NIMC_WAIT,NIMC_CONDITION_MOVE_COMPLETE,0x08,0x00,NIMC_MATCH_ALL,Timeout, 0);
285// Now move to XY
286 flex_start(BoardId, 1, 0);
287 flex_start(BoardId, 2, 0);
288 // Calc Z params
289 ActPos = Z1 * Z->MicronsToSteps;
290 if (Z->Invert) ActPos = -ActPos;
291 if (ZSpeed > Z->MaxSpeed) ZSpeed = Z->MaxSpeed;
292 if (ZAcc > Z->Accel) ZAcc = Z->Accel;
293 ActSpeed = abs(ZSpeed * Z->MicronsToSteps);
294 ActAccel = abs(ZAcc * Z->MicronsToSteps);
295 // Z params ready
296 flex_load_target_pos(BoardId, 3, ActPos, 0xFF);
297 flex_load_velocity(BoardId, 3, ActSpeed, 0xFF);
298 flex_load_acceleration(BoardId, 3, NIMC_ACCELERATION, ActAccel, 0xFF);
299 flex_load_acceleration(BoardId, 3, NIMC_DECELERATION, ActAccel, 0xFF);
300//Now move to Z
301 flex_start(BoardId, 3, 0);
302 // and wait for complete on all 3 axes
303// flex_wait_on_condition(BoardId, 0,NIMC_WAIT,NIMC_CONDITION_MOVE_COMPLETE,0x02+0x04+0x08,0x00,NIMC_MATCH_ALL,Timeout, 0);
304 flex_end_store(BoardId,2);
305 flex_run_prog(BoardId,2);
306
307 }
flex_load_target_pos
FLEXFUNC flex_load_target_pos(BOARD, u8 axis, i32 targetPosition, u8 inputVector)
flex_load_velocity
FLEXFUNC flex_load_velocity(BOARD, u8 axisOrVectorSpace, i32 velocity, u8 inputVector)
flex_set_op_mode
FLEXFUNC flex_set_op_mode(BOARD, u8 axisOrVectorSpace, u16 operationMode)
flex_start
FLEXFUNC flex_start(BOARD, u8 axisOrVectorSpace, u16 axisOrVSMap)
flex_end_store
FLEXFUNC flex_end_store(BOARD, u8 program)
flex_begin_store
FLEXFUNC flex_begin_store(BOARD, u8 program)
flex_wait_on_condition
FLEXFUNC flex_wait_on_condition(BOARD, u8 resource, u16 waitType, u16 condition, u8 mustOn, u8 mustOff, u16 matchType, u16 timeOut, u8 returnVector)
flex_load_acceleration
FLEXFUNC flex_load_acceleration(BOARD, u8 axisOrVectorSpace, u16 accelerationType, u32 acceleration, u8 inputVector)
flex_run_prog
FLEXFUNC flex_run_prog(BOARD, u8 program)
NIMC_MATCH_ALL
#define NIMC_MATCH_ALL
Definition: MotnCnst.h:228
NIMC_CONDITION_MOVE_COMPLETE
#define NIMC_CONDITION_MOVE_COMPLETE
Definition: MotnCnst.h:251
NIMC_WAIT
#define NIMC_WAIT
Definition: MotnCnst.h:222
NIMC_ACCELERATION
#define NIMC_ACCELERATION
Definition: MotnCnst.h:197
NIMC_DECELERATION
#define NIMC_DECELERATION
Definition: MotnCnst.h:199
NIMC_ABSOLUTE_POSITION
#define NIMC_ABSOLUTE_POSITION
Definition: MotnCnst.h:262
X0
brick X0
Definition: RecDispMC.C:112
Z0
float Z0
Definition: hwinit.C:67

◆ Stop()

void AcqStage1::Stop ( )
194{
195 //Stops all three axes
196 X->Stop();
197 Y->Stop();
198 Z->Stop();
199}

Member Data Documentation

◆ AbsCoords

bool AcqStage1::AbsCoords

◆ BoardId

int AcqStage1::BoardId

◆ eAffine

EdbAffine2D* AcqStage1::eAffine

◆ EmBase

float AcqStage1::EmBase

◆ EmBotLayer

float AcqStage1::EmBotLayer

◆ EmTopLayer

float AcqStage1::EmTopLayer

◆ L

AcqLight* AcqStage1::L

◆ NominalEmBase

float AcqStage1::NominalEmBase

◆ NominalEmLayer

float AcqStage1::NominalEmLayer

◆ X

AcqAxis* AcqStage1::X

◆ Y

AcqAxis* AcqStage1::Y

◆ Z

AcqAxis* AcqStage1::Z

◆ ZHomingXPos

float AcqStage1::ZHomingXPos

◆ ZHomingYPos

float AcqStage1::ZHomingYPos
The documentation for this class was generated from the following files: