/******************************************************************************
|
*
|
* (C) Copyright WDI 2010
|
*
|
******************************************************************************
|
*
|
* FILE: atf_lib.h
|
*
|
* PROJECT: AFT Sensors
|
*
|
* SUBPROJECT: .
|
*
|
* Description: ATF sensor communication library
|
*
|
******************************************************************************
|
*
|
* Change Activity
|
* Defect Date Developer Description
|
* Number DD/MM/YYYY Name
|
* ======= ========== ================ =======================================
|
* 21/09/2009 Andrew L. Initial version
|
* 03/11/2010 Chris O.
|
* 15/11/2010 Chris O. Added synchronization objects for
|
* multithreaded applications
|
*
|
*****************************************************************************/
|
|
// atf_lib.h
|
|
#pragma once
|
|
#include "atf_def.h"
|
#include "epp.h"
|
#include "logger.h"
|
#include "llc.h"
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
// ---------------------------------------------------------------------------------
|
// error codes returned by application
|
|
// returns text name of most recent error
|
const char* atf_GetErrorInfo(int iErr);
|
|
// establishing connection. Return 0 if OK, or something else in case of error
|
int atf_OpenConnection (char *port, int speed);
|
void atf_CloseConnection (void);
|
// if multiple atf sensors are opend atf_OpenConnection allocates a new
|
// communication object. This index can be read and set in case switching
|
// between objects is needed. Conm index is a thread local, therefore if multiple
|
// threads call atf_OpenConnection each by default is using different com object.
|
// Using atf_GetComIdx/atf_SetComIdx is only necessary if a single thread
|
// communicates with multiple objects. in this case com index needs to be set when
|
// object is being changed
|
int atf_GetComIdx(); // returns index
|
int atf_SetComIdx(int idx); // returns ErrOK if index is valid or error otherwise
|
|
// serial Com port baudrate
|
int atf_ChangeCommBaudrate(DWORD dwBaudRate);
|
int atf_GetCommBaudrate(DWORD *dwBaudrate);
|
bool atf_isSerialConnection();
|
|
// read current sensor baudrate setting
|
int atf_ReadBaud (int &br);
|
// writes new baudrate setting (need to follow up with change of port setting if communication is to continue)
|
int atf_WriteBaud (int br);
|
|
// attempts to recover in case of communication loss
|
// verify what is running. Returns:
|
// 0 - no communnication could be established
|
// 1 - application found
|
// 2 - bootloader found, it was restarted back to application
|
int atf_RecoverSensor();
|
// check if "A" is returned which indicate that software is working
|
int atf_PingAck();
|
// resets sensor
|
int atf_Reset();
|
|
// direct access to read abd write
|
int atf_ReadArray (void *to, int bid, int pid, EppDataType tag, int num, int offset);
|
int atf_WriteArray (void *from, int bid, int pid, EppDataType tag, int num, int offset);
|
|
// part identification -------------------------------------------------------------------
|
//
|
// returns text corresponding to
|
const char* atf_PartInfo();
|
|
int atf_ReadSerialNumber(unsigned int* SensorSN);
|
int atf_ReadFirmwareVer(int* ver);
|
|
// one time initialization ---------------------------------------------------------------
|
// read all possible magnifications to choose from. Up to 16 elements are provided. On call
|
// 'pnum' defines size of the array. On return 'pnum' lists actual number of elements
|
// defined in the sensor ('pnum'<16)
|
int atf_ReadAllAvailableMagnification (short* pMag, int* pnum);
|
// generate default name for the given objective magnification
|
const char *atf_DecodeMagnification (int mag) ;
|
// read magnification assigned to particular objective
|
int atf_ReadMagnification (int obj, short* pMag) ;
|
// extract magnification and description portion
|
#define GetMag(mag) ((mag)&0xff)
|
#define GetDesc(mag) (((mag)>>8)&0xff)
|
// assignses magnification to the objective. This will cause to reinitialize all the parameters
|
// associated with objective
|
int atf_WriteMagnification (int obj, short uMag) ;
|
|
// objective configuration ----------------------------------------------------------------
|
// assign current z position to be best in focus
|
int atf_Make0();
|
|
// save all parameters into the eprom memory
|
int atf_SaveAll();
|
// read and set current objective number
|
int atf_ReadObjNum (int *pObj);
|
int atf_WriteObjNum(int iObj);
|
|
// read peak offset
|
enum PeakOffsetWhich
|
{
|
/*
|
type reading offset Number of reading elements
|
----------------------------------------------------------
|
RPOW_VFar (1) 13 1
|
RPOW_VNear1 (2) 12 1
|
RPOW_VNear7 (3) 16 7
|
RPOW_VAll (4) 12 12
|
RPOW_VHAll (8) 0 24
|
*/
|
RPOW_VFar = 1, // only peak for analog ATF4 (number 1, offset 13)
|
RPOW_VNear1 = 2, // near mode peak (number 1, offset 12)
|
RPOW_VNear7 = 3, // All 7 near peaks (number 7, offset 12+4=16)
|
RPOW_VAll = 4, // All 12 peaks V (number 12, offset 12)
|
RPOW_VHAll = 8, // All 24 peaks V and H (number 24, offset 0)
|
};
|
int atf_ReadPeakOffset (int obj, PeakOffsetWhich pow, int* peakArray);
|
int atf_WritePeakOffset(int obj, PeakOffsetWhich pow, int* peakArray);
|
|
// read acceleration in mm/ss
|
int atf_ReadAccel (int obj, float *pAccel);
|
int atf_WriteAccel (int obj, float fAccel);
|
// read speed in mm/s
|
int atf_ReadSpeed (int obj, float* pSpeed);
|
int atf_WriteSpeed (int obj, float fSpeed);
|
// read proportional gain factor
|
int atf_ReadP (int obj, float* pP) ;
|
int atf_WriteP (int obj, float fP) ;
|
|
|
// read number of steps correponding to 1 mm of motion
|
// Note: with firmware 7.1.41.19 and up atf_ReadStepPerMmConversion is relevent to currently
|
// selected objective
|
int atf_ReadStepPerMmConversion (u_short* puStepMm);
|
// write number of steps correponding to 1 mm of motion
|
// Note: with firmware 7.1.41.19 and up atf_WriteStepPerMmConversion affects only currently
|
// selected objective
|
int atf_WriteStepPerMmConversion (u_short uStepMm);
|
|
// read number of microsteps assigned per each stepper motor step
|
// Note: with firmware 7.1.41.19 and up atf_ReadMicrostep is relevent to currently
|
// selected objective
|
int atf_ReadMicrostep (u_short* puUstep);
|
// change number os microsteps
|
// write number of steps correponding to 1 mm of motion
|
// Note: with firmware 7.1.41.19 and up atf_WriteMicrostep affects only currently
|
// selected objective
|
int atf_WriteMicrostep (u_short uUstep);
|
|
// read number of micrometers corresponding to unit on sensor output
|
int atf_ReadSlopeUmPerOut (int obj, float* pfumout);
|
int atf_WriteSlopeUmPerOut (int obj, float fumout);
|
|
// DUV jump dist
|
int atf_WriteDuvJump (int obj, short sUStep);
|
int atf_ReadDuvJump (int obj, short* pUStep);
|
|
// write number of units as reported by sensor position defining infocus range
|
int atf_WriteInfocusRange (int obj, int iRange) ;
|
int atf_ReadInfocusRange (int obj, int* pRange) ;
|
|
// prevent sensor from changing current window mode to the different one
|
int atf_DisableAutoWindowTransit (void) ;
|
// alows automatic window selection. TYpically: near mode (7 segments) at focus and far mode if distance is
|
// greater then linear range
|
int atf_EnableAutoWindowTransit (void) ;
|
|
// read/write number of imager pixels assigned to represent linear range
|
int atf_ReadLinearRange (int obj, int *pLinearRange);
|
int atf_WriteLinearRange (int obj, int iLinearRange);
|
|
// read and write surface for currently selected objective
|
int atf_ReadSurface (short *piSurf);
|
int atf_WriteSurface (short iSurf);
|
|
// reads/writes row delay parameter for specified objective and specified window
|
int atf_ReadWindowRowDelay (int obj, WindowEnm which, short* prd);
|
int atf_WriteWindowRowDelay (int obj, WindowEnm which, short rd);
|
|
// auto focus tracking setup ----------------------------------------------------------------
|
// sets upper and lower limits (in abs position units) for motion executed during AF cycle.
|
// if adaptive_lim!=0 then upper and lower limits are adjusted up or down around 0 position if number
|
// of samples in a row falls within InFocusRange
|
int atf_WriteMotionLimits (int upper_limit, int lower_limit, int adaptive_lim);
|
|
// sets mode in which laser is going to be turned off once focus is reached. Next
|
// AF command id going to enable laser
|
int atf_EnableAutoOff(void);
|
int atf_DisableAutoOff(void);
|
|
// set far moed
|
int atf_ForceFarMode () ;
|
// set near moed
|
int atf_ForceNearMode () ;
|
// set center of the imager
|
int atf_CenterFarWindow ();
|
int atf_ClearFarWindowCentering ();
|
|
|
// commands and tracking --------------------------------------------------------------------
|
// executes motion of move microsteps
|
int atf_MoveZ (int move);
|
// executes motion of move micrometers
|
int atf_MoveZum (int iMoveUm);
|
// reads most recent motion distance
|
int atf_ReadLastMoveZ (int &zMove);
|
// executes stop motor motion
|
int atf_StopZMotor();
|
// executes motion of move microsteps followed by clear abs position
|
int atf_MoveZ_ClearAbs (int move);
|
|
// reads position in microstepps updated by the sensor with every z motion
|
int atf_ReadAbsZPos (int* absZ) ;
|
int atf_WriteAbsZPos (int absZ) ;
|
|
// stops AF tracking
|
int atf_AfStop ();
|
// starts AF tracking
|
int atf_AFTrack ();
|
// start AF tracking first, once at focus continue on AOI tracking
|
int atf_AFAoiTrack ();
|
// start Video tracking
|
int atf_AFVideoTrack();
|
// execute focus and disables, if DUV jump is defined will be taken
|
int atf_AfDuvJump ();
|
// start AOI tracking
|
int atf_AFAoiOnlyTrack ();
|
|
// status and results ------------------------------------------------------------------------
|
// reads sensor position, typically in range +-512
|
int atf_ReadPosition (float &fpos);
|
|
// read position packed into single short along with some extra flags
|
int atf_ReadPositionPacked (RsData *prs);
|
|
// reads hardware status of HwStatusFlagsEnm type (see description above)
|
// Note: in fw 7.1.41.19 and up hw status relates to ZAA not PZ device
|
int atf_ReadHwStat (int *HwStat);
|
|
// read status flags of StatusFlagsEnm type (see description above)
|
int atf_ReadStatus (short *pstatus);
|
|
// reads scanline.
|
// mode: one of the ...WINIDOW defined above
|
// h_scanline: points to a buffer of MAX_SCANLINE_LENGTH where horizontal scanline is to be copied to
|
// v_scanline: points to a buffer of MAX_SCANLINE_LENGTH where vertical scanline is to be copied to
|
// h_len: number of elements of h_scanline
|
// v_len: returns number of elements of v_scanline
|
// width: returns width of the v_scanline peak as detected by sensor
|
int atf_ReadScanline (u_short* mode, u_short* h_scanline, u_short* v_scanline, u_short* h_len, u_short* v_len, u_short* width);
|
|
// read individual dot.line segment position
|
int atf_Read7DotPosition (short *p7dots, int iLinearRange);
|
|
// read value reported on analog output
|
int atf_ReadAnalogOut (short &analog);
|
|
int atf_ReadErrorCode (AtfCodesEnm *pcode);
|
|
// laser control ------------------------------------------------------------------------------
|
// turns laser ON
|
int atf_EnableLaser ();
|
// turns laser OFF
|
int atf_DisableLaser ();
|
// enable automated laser power control
|
int atf_LaserTrackOn() ;
|
// enable manual laser power control
|
int atf_LaserTrackOff() ;
|
// read current laser power. Value from 0-1023.
|
// ATF5
|
// dotIdx: 0-2 - write laser power to current window
|
// 4 - far mode laser power (3,5 unused)
|
// 6-8 - near mode left window laser power
|
// 9-11 - near mode center window laser power (10 is central dot)
|
// 12-14 - near mode right window laser power
|
// ATF6
|
// dotIdx: 0 - write laser power to current window (1,2 - unused)
|
// 4 - far mode laser power (3,5 unused)
|
// 7-13 - near mode 7 dot laser power (typically they are the same, 10 is central dot)
|
// 6,14 - unused
|
int atf_ReadLaserPower(u_short *plaser, int iByteNumToRead = 1, int dotIdx = 0);
|
// set current laser power
|
int atf_WriteLaserPower(u_short laser, int iByteNumToRead = 1, int dotIdx = 0);
|
|
|
// equivalent to enabling sync signal on input DIO
|
int atf_EnableSync ();
|
// equivalent to disabling sync signal on input DIO
|
int atf_DisableSync ();
|
|
// >>> --------------- CM and Retardation Control -------------------------------------------------
|
// return true if CM is available and atf_...Cm... could be called
|
BOOL atf_IsCmAvailable();
|
// Glass thickness is expressed in microsteps. if >0 then cm is top, if <0 then cm is bottom. if 0 then cm is disabled
|
int atf_ReadCmGlassThickness (int* piThicknessUstep);
|
int atf_WriteCmGlassThickness (int iThicknessUstep);
|
// retarder status. Only if 2,3 other atf_...CmRetarder... could be called
|
CmRetarderEnum atf_ReadCmRetarderStatus ();
|
// read WASP retardation setting for a surface. Same retardation apply to all objectives
|
int atf_ReadCmRetarder (float *pfRetardation_percent, int iSurface);
|
// write WASP retardation
|
// check that atf_ReadCmRetarderStatus is 2 or 3
|
int atf_WriteCmRetarder (float fRetardation_percent, int iSurface);
|
// configuration setup saved with all parameters
|
// if bDoAutoDetectOnMake0 - runs autodetection before make0
|
// if bDoWaitAutoDetectToAf - runs autodetection before AF
|
// by default both are not used
|
int atf_ReadCmRetarderAutoDetectConfigOptions (bool &bDoAutoDetectOnMake0, bool &bDoWaitAutoDetectToAf);
|
int atf_WriteCmRetarderAutoDetectConfigOptions(bool bDoAutoDetectOnMake0, bool bDoWaitAutoDetectToAf);
|
// request to do autodetection before next AF cycle
|
int atf_ScheduleCmRetarderAutoDetectForAF();
|
// requests retardation autodetect
|
int atf_StartCmRetarderAutoDetect();
|
// interrupts ongoing retardation autodetect
|
int atf_StopCmRetarderAutoDetect();
|
// discovers current autodetection status
|
CmAutoDetectEnum atf_ReadCmRetarderAutoDetectStatus();
|
|
// <<< --------------- CM and Retardation Control ----------------------------------------------
|
|
// >>> --------------- Strobing -------------------------------------------------
|
// To set strobe pulse is length of strobe signal and needs only to be read from config file.
|
// Led is 1 or 2
|
int atf_ReadStrobePulseTime(int iLed, int *pStrobeTime);
|
int atf_WriteStrobePulseTime(int iLed, int iStrobeTime);
|
|
// To set strobe minimum timer :
|
int atf_ReadStrobeIntervalTime(int *pStrobeIntervalUs);
|
int atf_WriteStrobeIntervalTime(int iStrobeIntervalUs);
|
// This parameter specifies a minimum time between 2 strobes in microseconds. In case of multi
|
// image strobing this will be a delay between image frames
|
// To generate a frame, illuminator needs to be set in external trigger mode at current value of choice.
|
int atf_Strobe(int iLed, int iNum, int iMaxError);
|
// iLed is 1 or 2 or 3
|
// iNum is number of frames to be strobed. 0 to stop current illuminator strobing stream.
|
// -1 to request infinite strobing count
|
// iMaxError is maximum position error sensor should assure at the time of generating strobe.
|
// Set to 0 if ignored. If set it can be in the range of 1 to 511. Sensor is guarantee
|
// to wait and trigger strobe only if position error is within this range. Wait will terminate
|
// with either completing a triggered series, or when triggering is stopped with atf_Strobe(iLed,0,0)
|
// or new series is started with atf_Strobe(? command or when objective is changed.
|
// The atf_Strobe will return immediately.
|
// You can read number of strobes executed since last atf_Strobe command with
|
int atf_StrobeCount(int *pNumStb, int *pNumStbRequested, bool *pbStrobeActive);
|
// *pbStrobeActive is true is series is still ongoing or false if is terminated.
|
// <<< --------------- Strobing -------------------------------------------------
|
|
// >>> --------------- Hybrid hardware support -------------------------------------------------
|
// read or writes bitwise flag combination of ConfigExtEnum
|
int atf_ReadConfigExt (int iObj, int *pcfg);
|
// only: CeePZ1_Activate,CeePZ2_Activate,CeeZAA_Move,CeePZ_Move could be set. Other bits
|
// are going to be left intact. mask selects bits to change, cfg is the update
|
int atf_SetConfigExt (int iObj, int mask, int cfg);
|
|
// reads/writes objectives that governs system motion. It may be different then objective set with
|
// atf_WriteObjNum which determine data acquisition conditions.
|
int atf_ReadMoveObjNum (int *pObj, int *pMoveObj);
|
int atf_WriteMoveObjNum(int iObj, int iMoveObj);
|
|
// reads position in microsteps updated by the sensor with every z motion. Stage selection
|
// allows to read most recent ZAA or PZ position, even if this stage is deactivated
|
// pMoveObj if != 0 returns objective in context which abs z was calculated
|
int atf_ReadAbsZPosStage (enum StageSelectorEnum ess, int* pAbsZ, int *pMoveObj) ;
|
|
// There is going to be added mapping maintained by sensor to indicate iObjMove that needs to be
|
// use for the AOI AF stage that follows up after regular AF when atf_AFAoiTrack is issued.
|
//
|
int atf_ReadAoiFollowUp (int iObj, int *pObjFollowUp);
|
int atf_WriteAoiFollowUp (int iObj, int iObjFollowUp);
|
// <<< --------------- Hybrid hardware support -------------------------------------------------
|
|
// LED control ------------------------------------------------------------------------------
|
// there are up to 3 led (0,1,2)
|
int atf_ReadLedCurrent (int channel, u_short* pCurrent);
|
int atf_WriteLedCurrent (int channel, u_short uCurrent);
|
int atf_ReadLedPwm (int channel, u_short* pPWM);
|
int atf_WriteLedPwm (int channel, u_short uPWM);
|
int atf_ReadLedPwmStartupVal (int iChannel, u_short *puPWM);
|
int atf_WriteLedPwmStartupVal (int iChannel, u_short uPWM);
|
|
// MFC --------------------------------------------------------------------------------------
|
int atf_ReadMfcConfig (int* mfc_config);
|
// read 5 bytes used to configure motor.
|
int atf_ReadMfcMotorParm (u_char* motor_parm);
|
int atf_WriteMfcMotorParm (u_char* motor_parm);
|
|
// logger
|
bool atf_openLogFile(const char *pLogFilePath, const char *pMode);
|
bool atf_closeLogFile(void);
|
void atf_setLogLevel(int iLogLevel);
|
FILE *atf_getLogFileHandle();
|
void atf_saveToLog(char *pLogMsg, int iLogLevel);
|
void atf_saveToLog2( int iLogLevel, char *pFormat, ...);
|
|
// LLC --------------------------------------------------------------------------------------
|
bool atf_initializeLlc(char *pOffsetFileDir, int *piErrCode);
|
int atf_sendLlc(char *toSend, char *toRecv);
|
bool atf_getLlcStatus(int *piErrCode, const char **ppErrMsg, int *piStatReg, int *piMtrFailureReg);
|
bool atf_recoverLlc(int *piErrCode);
|
bool atf_recoverLlcSensorConnection(int *piErrCode);
|
bool atf_recoverLlcHdwr(int *piErrCode);
|
bool atf_resetLlcController(int *piErrCode);
|
bool atf_homeLlc(bool bWaitForEnd, int *piErrCode);
|
bool atf_isLlcInHomePos(int *piErrCode);
|
void atf_setObjectiveNum(int iObjNum);
|
int atf_getObjectiveNum();
|
int atf_getLlcForcerSerNum();
|
bool atf_saveLlcObjectivePositionOffset(int iObjectiveNumber, int iOffset);
|
bool atf_getLlcObjectivePositionOffset(int iObjectiveNumber, int *piPositionOffset);
|
bool atf_moveLlcToObjective(int iObjectiveNumber, bool bWaitForEnd, int *piErrCode);
|
bool atf_moveLlcToPosition(int iPosition, bool bWaitForEnd, int *piErrCode);
|
bool atf_moveLLcRelativeDistance(int iDistance, bool bWaitForEnd, int *piErrCode);
|
bool atf_isLlcInTargetPosition(int *piErrCode);
|
bool atf_enableLlcMotor(int *piErrCode);
|
bool atf_disableLlcMotor(int *piErrCode);
|
bool atf_stopLlcMotion(int *piErrCode);
|
bool atf_setLlcSpeed(int iLlcSpeed, int *piErrCode);
|
bool atf_getLlcSpeed(int *piLlcSpeed, int *piErrCode);
|
bool atf_setLlcAcceleration(int iLlcAcceleration, int *piErrCode);
|
bool atf_getLlcAcceleration(int *piLlcAcceleration, int *piErrCode);
|
bool atf_setLlcDeceleration(int iLlcDeceleration, int *piErrCode);
|
bool atf_getLlcDeceleration(int *piLlcDeceleration, int *piErrCode);
|
bool atf_setLlcSmoothFactor(int iLlcSmoothFactor, int *piErrCode);
|
bool atf_getLlcSmoothFactor(int *piLlcSmoothFactor, int *piErrCode);
|
bool atf_getLlcVelocity(float *pfLlcVelocity, int *piErrCode);
|
bool atf_getLlcPosition(float *pfLlcPosition, int *piErrCode);
|
bool atf_getLlcMotorCurrent(float *pfLlcMotorCurrent, int *piErrCode);
|
int atf_CommToLlc (char* to_send, char* to_read);
|
|
// Homing Z
|
int atf_ReadHomingZ_Parameters(int *pHomingZ_Parameters);
|
int atf_WriteHomingZ_Parameters(int *pHomingZ_Parameters);
|
int atf_RunHomingZ(int *pHomingZ_Parameters);
|
int atf_IsInHomePosition(bool *pbInHome);
|
|
// Jogging Z
|
int atf_StartJoggingZ(int iSpeed);
|
|
#ifdef __cplusplus
|
}
|
#endif
|
