AcqAxis Class Reference

#include <AcqStage1.h>

Inheritance diagram for AcqAxis:

Collaboration diagram for AcqAxis:

Public Member Functions
	AcqAxis ()
	AcqAxis (int Ax)
void	ArmBreakpoint (float Pos)
void	ArmBreakpointSequence ()
void	DisarmBreakpoint ()
void	DisarmBreakpointSequence ()
void	DumpBreakpointSequence ()
int	FindHome (int Direction)
int	GetLimiter ()
float	GetPos ()
bool	Initialize ()
bool	IsBreakpointOccured ()
int	IsBreakpointSequenceArmed ()
bool	IsMoveComplete ()
void	LoadBreakpointSequence (float *Pos, int N)
void	LoadMoveCompleteCriteria (bool MotorOff, bool Stop, bool Delay, bool InPosition, float DeadBand, int sdelay, int minPulse)
void	Move (float Speed, float Acc)
void	PosMove (float Pos, float Speed, float Acc)
int	ReadFollowingError ()
void	Reset ()
void	SetFilterFrequency (int Freq)
void	SetFollowingError (u16 Error)
void	Stop ()
void	Test (float *Pos, int N)
int	WaitForHome (int Timeout)
int	WaitForMoveComplete (u32 Timeout)
virtual	~AcqAxis ()

Public Attributes
float	Accel
int	Axis
int	BoardId
int	CtlModeIsCWCCW
float	EncoderToMicrons
int	HomePol
float	HomingSpeed
int	Invert
int	LimPol
int	LinesRev
float	MaxSpeed
float	MicronsToSteps
float	NominalReference
float	Reference
int	StepsRev
int	TurnOffLightTime

Constructor & Destructor Documentation

AcqAxis() [1/2]

AcqAxis::AcqAxis

(

)

{
    BoardId=1;
    StepsRev=10000;
    LinesRev=10000;
    EncoderToMicrons=.05;
    MicronsToSteps=StepsRev/LinesRev/EncoderToMicrons;
    Accel=100000.000000; 
    MaxSpeed=25000.000000; 
    LimPol=0;
    HomePol=0;
    CtlModeIsCWCCW=0;
    Invert=1; 
    HomingSpeed=10000;
    Reference=0;
 
}

AcqAxis() [2/2]

AcqAxis::AcqAxis

(

int

Ax

)

{
    Axis=Ax;
}

~AcqAxis()

virtual AcqAxis::~AcqAxis ( )

inlinevirtual

{} 

Member Function Documentation

ArmBreakpoint()

void AcqAxis::ArmBreakpoint

(

float

Pos

)

  {
//Sets breakpoint at position [mic] on an axis
    long ActPos;
     ActPos = Pos / EncoderToMicrons ;
        if (Invert) ActPos = -ActPos;
      flex_load_pos_bp(BoardId,0x20+Axis,ActPos,0xFF);
      flex_enable_breakpoint(BoardId,0x20+Axis,0x01);
  } 

ArmBreakpointSequence()

void AcqAxis::ArmBreakpointSequence

(

)

  {
      //refresh index Var78 from Var76, where it's saved
      // and starts BP grab sequence
      // Doesn't check if the program is loaded!!!! - TODO
      flex_xor_vars(BoardId,0x78,0x78,0x78);  //set index to 0 to be sure
//    DumpBreakpointSequence();
      flex_add_vars(BoardId,0x78,0x76,0x78);  //set index to Var76
//    DumpBreakpointSequence();
      flex_run_prog(BoardId,1);
      //gSystem->Sleep(500);
  } 

DisarmBreakpoint()

void AcqAxis::DisarmBreakpoint

(

)

  {
      flex_enable_breakpoint(BoardId,Axis,0x00);
  } 

DisarmBreakpointSequence()

void AcqAxis::DisarmBreakpointSequence

(

)

  {
      //stops BP grab sequence
      flex_stop_prog(BoardId,1);
  } 

DumpBreakpointSequence()

void AcqAxis::DumpBreakpointSequence

(

)

 {
     // Debug function
     i32 var;
     i32 N78,N77,N76;
     flex_read_var_rtn(BoardId,0x78,&N78);
     flex_read_var_rtn(BoardId,0x77,&N77);
     flex_read_var_rtn(BoardId,0x76,&N76);
    //  flex_flush_rdb(BoardId);
 
     printf("0x76:%d 0x77:%d 0x78:%d\n",N76,N77,N78);
//   flex_read_var_rtn(BoardId,0x78,&N78);
 }

FindHome()

int AcqAxis::FindHome

(

int

Direction

)

here the homing sequence itself starts

{
// Finds home switch using the NI7344 onboard sequence 
// the initial seacrh is performed with XY(Z)MaxSpeed 
// in a given Direction (+1 or -1);
// the final approach is done with the fixed speed of 1/4 RPS to provide good
// accuracy.
// returns immidiately 1 if the sequence started, and 0 if parameters are wrong.
// To wait for the end use WaitForHome() function
    int ActSpeed;
    int ActAccel;
    flex_set_op_mode(BoardId, Axis, NIMC_ABSOLUTE_POSITION);
        ActSpeed = abs(HomingSpeed * MicronsToSteps);
        ActAccel = abs(Accel * MicronsToSteps);
    flex_load_velocity(BoardId, Axis, ActSpeed, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_ACCELERATION, ActAccel, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_DECELERATION, ActAccel, 0xFF);
    int DirMap;
    if(Direction>0) DirMap=0x0004;
    else DirMap=0x0003;
    flex_find_home(BoardId, Axis, DirMap);
//  flex_find_reference(BoardId, Axis, 0, NIMC_FIND_HOME_REFERENCE);//Flex6.1.2
    printf("Home Finding is started on axis %d..\n",Axis);
     return 1;
}

GetLimiter()

int AcqAxis::GetLimiter

(

)

{
//returns status of limiters on a given axis: 
// 0 - no limiters reached
// 1 - "-" limiter reached 
// 2- "+" limiter reached
    unsigned char fwdStatus, revStatus;
    flex_read_limit_status_rtn(BoardId, NIMC_LIMIT_INPUTS, &fwdStatus, &revStatus);
    //  flex_flush_rdb(BoardId);
 
    DWORD a = 0;
    bool invert = Invert;
    if (revStatus & (0x02 << (Axis-1))) a |= invert ? 2 : 1;
    if (fwdStatus & (0x02 << (Axis-1))) a |= invert ? 1 : 2;
    return a;
}

GetPos()

float AcqAxis::GetPos

(

)

{
// returns position in [mic] of a given axis
    long retval;    
    Double_t fretval;
    flex_read_pos_rtn(BoardId, Axis, &retval);
//  flex_flush_rdb(BoardId);
 
    if (Invert) retval = -retval;
    fretval= retval * EncoderToMicrons * LinesRev / StepsRev;
    return fretval;
;
}

Initialize()

bool AcqAxis::Initialize

(

)

{
//Initialises the axis
    try
    {
 
        if (flex_enable_axes( BoardId, 0, 2, 0x00) != NIMC_noError) throw(3);
        if (flex_config_axis( BoardId, Axis, 0x20+Axis, 0, 0x40+Axis, 0) != NIMC_noError) throw(3);
        if (flex_set_stepper_loop_mode( BoardId, Axis, 1) != NIMC_noError) throw(3);
        if (flex_config_step_mode_pol( BoardId, Axis, 0x04 | ((! CtlModeIsCWCCW) ? 1 : 0)) != NIMC_noError) throw(3);
        if (flex_load_counts_steps_rev( BoardId, Axis, NIMC_COUNTS,  LinesRev) != NIMC_noError) throw(3);
        if (flex_load_counts_steps_rev( BoardId, Axis, NIMC_STEPS,  StepsRev) != NIMC_noError) throw(3);
        if (flex_load_follow_err( BoardId, Axis, 0, 0xFF) != NIMC_noError) throw(3);
        if (flex_enable_home_inputs( BoardId, 0x0E) != NIMC_noError) throw(3);
        if (flex_set_home_polarity( BoardId, ( HomePol) ? 0x0E : 0) != NIMC_noError) throw(3);
        if (flex_set_limit_polarity( BoardId, ( LimPol) ? 0x0E : 0, ( LimPol) ? 0x0E : 0) != NIMC_noError) throw(3);
        if (flex_enable_limits( BoardId, NIMC_LIMIT_INPUTS, 0x0E, 0x0E) != NIMC_noError) throw(3);
        if (flex_set_op_mode( BoardId, Axis, NIMC_ABSOLUTE_POSITION) != NIMC_noError) throw(3);
 
        if (flex_load_acceleration( BoardId, Axis, NIMC_ACCELERATION, abs( Accel *  MicronsToSteps), 0xFF) != NIMC_noError) throw(3);
        if (flex_load_acceleration( BoardId, Axis, NIMC_DECELERATION, abs( Accel *  MicronsToSteps), 0xFF) != NIMC_noError) throw(3);
//       if (flex_configure_breakpoint( BoardId, Axis, NIMC_ABSOLUTE_BREAKPOINT, NIMC_SET_BREAKPOINT,0) != NIMC_noError) throw(3);
       if (flex_configure_breakpoint( BoardId, Axis, NIMC_ABSOLUTE_BREAKPOINT, NIMC_SET_BREAKPOINT,NIMC_OPERATION_SINGLE) != NIMC_noError) throw(3);
        if (flex_enable_axes( BoardId, 0, 2, 0x0E) != NIMC_noError) throw(3);
    }
        catch (...)
    {
        return false;
    };
        SetFilterFrequency(0); //Must be set to maximum 25.6MHz to avoid missing lines at high speed
        printf("Axis %d initialized siccessfully with parameters:\n",Axis);
        Dump();
    return true;
 
}

IsBreakpointOccured()

bool AcqAxis::IsBreakpointOccured

(

)

  {
      u16 status;
      flex_read_breakpoint_status_rtn(BoardId,0x20,0,&status);
    //      flex_flush_rdb(BoardId);
 
      printf("Breakpoint Status: %d\n",status);
      if(status & (0x01 << Axis))
      return true;
      else return false;
  }

IsBreakpointSequenceArmed()

int AcqAxis::IsBreakpointSequenceArmed

(

)

  {
      //Returns number of breakpoints to occur in sequence.
      // if 0 - sequence is not active or finished
      i32 N78;
     flex_read_var_rtn(BoardId,0x78,&N78);
    //  flex_flush_rdb(BoardId);
 
     return int(N78);
  }

IsMoveComplete()

bool AcqAxis::IsMoveComplete

(

)

{
// chacks if Move Complete Flag is set
    u16 mc;
    flex_check_move_complete_status(BoardId,Axis,0,&mc);
    if(mc==1) return true;
    else return false;
}

LoadBreakpointSequence()

void AcqAxis::LoadBreakpointSequence	(	float *	Pos,
		int	N
	)

  {
//Sets breakpoint sequence and store the BP grab program.
      u16 mask;
      int label1=1;
      int label2=2;
      if(N>100) N=100;
      if(N<=0) return;
    i32 ActPos[120];
    i32 NPos=N;
    flex_load_var(BoardId,NPos,0x76); //store number of breakpoints in Var76 (save)
    flex_load_var(BoardId,NPos,0x78); //store number of breakpoints in Var78 (index)
    flex_load_var(BoardId,1,0x77); //store decrement=1 in Var77
    for(u8 i=0;i<N;i++)
     {
      ActPos[i] = Pos[i] / EncoderToMicrons ;
        if (Invert) ActPos[i] = -ActPos[i];
        flex_load_var(BoardId,ActPos[i],i+1); //store breakpoints in Vars from 0x01 up
     }
     mask=(0x01 << Axis);
      flex_begin_store(BoardId,1);
//    flex_load_program_time_slice(BoardId,1,20,0xFF);
      // Start the loop, index is in var 0x01 decrementing down to 0
      flex_insert_program_label(BoardId,label1);
      flex_load_pos_bp(BoardId,0x20+Axis,0,0xF8); //load indirect from the index Var78
      flex_enable_breakpoint(BoardId,0x20+Axis,0x01); //arm breakpoint
      flex_insert_program_label(BoardId,label2); //loop till bp is occured
      flex_jump_label_on_condition(BoardId,0x20+Axis,NIMC_CONDITION_POSITION_BREAKPOINT,0,mask,NIMC_MATCH_ALL,label2);
 //     flex_wait_on_event(BoardId,0,NIMC_WAIT,NIMC_CONDITION_POSITION_BREAKPOINT,(u8)(1<<Axis),0,NIMC_MATCH_ALL,65535,0);//FlexMotion6.1.2
      //OK, BP is occured, decrementing index Var78 by Var77=1
      flex_sub_vars(BoardId,0x78,0x77,0x78);
      //Now if N=0 flag EQUALTO must be set... checking
      flex_jump_label_on_condition(BoardId,0,NIMC_CONDITION_NOT_EQUAL,0,0,0,label1);
      flex_set_breakpoint_momo(BoardId,0x20+Axis,0,mask,0xFF); //reset output
    //  flex_enable_breakpoint(BoardId,0x20+Axis,0x00); //disable breakpoint
      flex_end_store(BoardId,1);
 
  } 

LoadMoveCompleteCriteria()

void AcqAxis::LoadMoveCompleteCriteria	(	bool	MotorOff,
		bool	Stop,
		bool	Delay,
		bool	InPosition,
		float	DeadBand,
		int	sdelay,
		int	minPulse
	)

{
// Defines conditions under which the Move Complete flag is set:
// Motor Off - says for itself
// Stop - Run/Stop flag must be Stopped
// Delay - MoveComplete flag is set after a given sdelay [ms]
// InPosition - when stage is within DeadBand [mic] from the target position.
//
// sdelay - settling time delay [ms]
// minPulse [ms] - minimum time for which MoveComplete status must be true
// even if the axis re-started, the flag stays for this time anyway
    int criteria=1;
    if(MotorOff) criteria+=2;
    if(Stop) criteria+=4;
    if(Delay) criteria+=8;
    if(InPosition) criteria+=16;
    int DBand;
    DBand=DeadBand/EncoderToMicrons;
//  printf("flex_config_mc_criteria(%d,%d,%d,%d,%d,%d)\n",BoardId, Axis, criteria, DBand, Delay, minPulse);
    flex_config_mc_criteria(BoardId, Axis, criteria, DBand, sdelay, minPulse);
 
}

Move()

void AcqAxis::Move	(	float	Speed,
		float	Acc
	)

{
//Moves stage axis infinitely with given speed [mic/s] and acceleration [mic/s2]
    long retval;    
    int ActSpeed;
    int ActAccel;
    flex_set_op_mode(BoardId, Axis, NIMC_VELOCITY);
        if (Speed > MaxSpeed) Speed = MaxSpeed;
        if (Acc > Accel) Acc = Accel;
        ActSpeed = Speed * MicronsToSteps;
        if(Invert) ActSpeed=-ActSpeed;
        ActAccel = Acc * MicronsToSteps;
    flex_load_velocity(BoardId, Axis, ActSpeed, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_ACCELERATION, ActAccel, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_DECELERATION, ActAccel, 0xFF);
    flex_start(BoardId, Axis, 0);
 
}

PosMove()

void AcqAxis::PosMove	(	float	Pos,
		float	Speed,
		float	Acc
	)

{
//Moves stage axis to position [mic] with given speed [mic/s] and acceleration [mic/s2]
    long ActPos;
    long retval;    
    int ActSpeed;
    int ActAccel;
    flex_set_op_mode(BoardId, Axis, NIMC_ABSOLUTE_POSITION);
        ActPos = Pos * MicronsToSteps;
        if (Invert) ActPos = -ActPos;
        if (Speed > MaxSpeed) Speed = MaxSpeed;
        if (Acc > Accel) Acc = Accel;
        ActSpeed = abs(Speed * MicronsToSteps);
        ActAccel = abs(Acc * MicronsToSteps);
    flex_read_pos_rtn(BoardId, Axis, &retval);
//  flex_flush_rdb(BoardId);
    if(retval==ActPos) return; //Already at position
    flex_load_target_pos(BoardId, Axis, ActPos, 0xFF);
    flex_load_velocity(BoardId, Axis, ActSpeed, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_ACCELERATION, ActAccel, 0xFF);
    flex_load_acceleration(BoardId, Axis, NIMC_DECELERATION, ActAccel, 0xFF);
    flex_start(BoardId, Axis, 0);
 
}//_____________________________________________________________________________ 

ReadFollowingError()

int AcqAxis::ReadFollowingError

(

)

{
    // returns current position following error
    // useful for debugging of the stage
    short retval;
    flex_read_follow_err_rtn(BoardId,Axis, &retval);
    //  flex_flush_rdb(BoardId);
 
   return retval;
}

Reset()

void AcqAxis::Reset

(

)

{
//Resets a given axis
    flex_reset_pos(BoardId, Axis, 0, 0, 0xFF);
}

SetFilterFrequency()

void AcqAxis::SetFilterFrequency

(

int

Freq

)

{
    //sets digital filter cutoff frequency for the encoder
    // F=25.6 /(2**Freq) MHz
    flex_configure_encoder_filter(BoardId,Axis,Freq);
}

SetFollowingError()

void AcqAxis::SetFollowingError

(

u16

Error

)

{
    flex_load_follow_err(BoardId,Axis,Error,0xFF); 
}

Stop()

void AcqAxis::Stop

(

)

{
//Stops a given axis
    flex_stop_motion(BoardId, Axis, NIMC_HALT_STOP, 0);
}

Test()

void AcqAxis::Test	(	float *	Pos,
		int	N
	)

  {
      u16 mask;
      int label1=1;
      int label2=2;
      if(N>100) N=100;
      if(N<=0) return;
    i32 ActPos[120];
    i32 NPos=N;
    flex_load_var(BoardId,NPos,0x78); //store number of breakpoints in Var78
    flex_load_var(BoardId,1,0x77); //store decrement=1 in Var77
    for(u8 i=0;i<N;i++)
     {
      ActPos[i] = Pos[i] / EncoderToMicrons ;
        if (Invert) ActPos[i] = -ActPos[i];
        flex_load_var(BoardId,ActPos[i],i+1); //store breakpoints in Vars from 0x01 up
     }
      mask=(0x01 << Axis);
 
      flex_begin_store(BoardId,1);
      // Start the loop, index is in var 0x01 decrementing down to 0
      flex_insert_program_label(BoardId,label1);
      flex_load_pos_bp(BoardId,0x20+Axis,0,0xF8); //load indirect from the index Var78
      flex_enable_breakpoint(BoardId,0x20+Axis,0x01); //arm breakpoint
      flex_insert_program_label(BoardId,label2); //loop till bp is occured
      flex_jump_label_on_condition(BoardId,0x20+Axis,NIMC_CONDITION_POSITION_BREAKPOINT,mask,0,NIMC_MATCH_ALL,label1);
      //OK, BP is occured, decrementing index Var78 by Var77=1
      flex_sub_vars(BoardId,0x78,0x77,0x78);
      //Now if N=0 flag EQUALTO must be set... checking
      flex_jump_label_on_condition(BoardId,0,NIMC_CONDITION_NOT_EQUAL,0,0,0,label1);
      flex_end_store(BoardId,1);
      flex_run_prog(BoardId,1);
 
  }

WaitForHome()

int AcqAxis::WaitForHome

(

int

Timeout

)

  {
      int res;
      printf("Waiting Home Finding Complete on axis %d..\n",Axis);
      res=WaitForMoveComplete(Timeout);
      gSystem->Sleep(100);
      res=WaitForMoveComplete(Timeout);
      gSystem->Sleep(100);
      res=WaitForMoveComplete(Timeout);
      if(res!=1) return 0;
      u16 AxisStatus;
      flex_read_axis_status_rtn(BoardId, Axis, &AxisStatus);
     //     flex_flush_rdb(BoardId);
 
      if(AxisStatus & 0x0400) {
          printf("Home Finding Complete on axis %d..\n",Axis);
          return 1;
      }
      else {
          printf("*** Home Finding Failed on axis %d..\n",Axis);
          return 0;
      }
 //Flex5.x
/*        u16 found, finding;
      flex_check_reference(BoardId, Axis, 0, &found, &finding);
      while(finding) flex_check_reference(BoardId, Axis, 0, &found, &finding);
      if(found) {
          printf("Home Finding Complete on axis %d..\n",Axis);
          return 1;
      }
      else {
          printf("*** Home Finding Failed on axis %d..\n",Axis);
          return 0;
      }
*/ //Flex6.1.2
  }

WaitForMoveComplete()

int AcqAxis::WaitForMoveComplete

(

u32

Timeout

)

{
//Waits for a movement complete on a given axis ar timeout [ms], 
//returns 1 if movement complete, 0 if timeout happened
    u16 MComplete;
    flex_wait_for_move_complete(BoardId, Axis,0,Timeout,10, &MComplete);
return MComplete;
}

Member Data Documentation

Accel

float AcqAxis::Accel

Axis

int AcqAxis::Axis

BoardId

int AcqAxis::BoardId

CtlModeIsCWCCW

int AcqAxis::CtlModeIsCWCCW

EncoderToMicrons

float AcqAxis::EncoderToMicrons

HomePol

int AcqAxis::HomePol

HomingSpeed

float AcqAxis::HomingSpeed

Invert

int AcqAxis::Invert

LimPol

int AcqAxis::LimPol

LinesRev

int AcqAxis::LinesRev

MaxSpeed

float AcqAxis::MaxSpeed

MicronsToSteps

float AcqAxis::MicronsToSteps

NominalReference

float AcqAxis::NominalReference

Reference

float AcqAxis::Reference

StepsRev

int AcqAxis::StepsRev

TurnOffLightTime

int AcqAxis::TurnOffLightTime

---

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

• src/libACQ/AcqStage1.h
• src/libACQ/AcqStage1.cxx