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:106

◆ 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
float X0
Definition: emthickness.cpp:69
Y0
float Y0
Definition: emthickness.cpp:70
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: