Subversion Repositories f9daq

// This example uses the Kinesis C++ API to move and control Thorlabs integrated stepper motor, LTS, K10CR1, and MLJ stages.

/* Default parameters

HS LTS300C 300mm Stage

General

Name = HS LTS300C 300mm Stage

Stage ID = Unknown

Axis ID = SingleAxis

Home Settings

HomeDir = MOT_Reverse

HomeLimitSwitch = MOT_ReverseLimitSwitch

HomeVel = 2

HomeZeroOffset = 0,5

Jog Settings

JogMode = MOT_ExtSingleStep

JogStopMode = MOT_Profiled

JogStepSize = 5,0

JogMinVel = 0,0

JogAccn = 10,0

JogMaxVel = 10,0

Control Settings

DefMinVel = 0,0

DefAccn = 20,0

DefMaxVel = 20,0

Limit Settings

CWHardLimit = MOT_LimitSwitchMakeOnContact

CCWHardLimit = MOT_LimitSwitchMakeOnContact

CWSoftLimit = 3,0

CCWSoftLimit = 1,0

SoftLimitMode = MOT_LimitSwitchIgnored

LimitsSoftwareApproachPolicy = DisallowIllegalMoves

Physical Settings

Pitch = 1,0

StepsPerRev = 200

GearboxRatio = 1

TST101 Stage ID = 0

UseDeviceUnits = False

Units = MOT_Linear

DirSense = MOT_Backwards

MinPos = 0,00

MaxPos = 300,00

MaxAccn = 50,0

MaxVel = 50,0

MaxContinuousVel = 40,0

Factor = 1,0

UnitsTxt = mm

DisplayDP = -1

Misc. Settings

BacklashDist = 0,05

MoveFactor = 30

RestFactor = 5

Stepper Motor Settings

Pitch = 1,0

StepsPerRev = 200

GearboxRatio = 1

TST101 Stage ID = 0

UseDeviceUnits = False

Units = MOT_Linear

DirSense = MOT_Backwards

MinPos = 0,00

MaxPos = 300,00

MaxAccn = 50,0

MaxVel = 50,0

MaxContinuousVel = 40,0

Factor = 1,0

UnitsTxt = mm

DisplayDP = -1

Velocity Profile Settings

BowIndex = 0

Button Settings

ButtonMode = MOT_JogMode

ButtonPos1 = 10,0

ButtonPos2 = 20,0

Potentiometer Settings

FPControls = True

PotZeroWnd = 1

PotVel1 = 5,0

PotWnd1 = 50

PotVel2 = 10,0

PotWnd2 = 80

PotVel3 = 15,0

PotWnd3 = 100

PotVel4 = 20,0

*/

//CVI Add dll path to: Options>Environment>Include Path> C:\Program Files\Thorlabs\Kinesis

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <windows.h> 

#include <userint.h>

#include <utility.h>

#include "ThorlabsLTS_ui.h" 

#include "ThorlabsMotionControlIntegratedStepperMotors.h"

void LTS_waitMove(int i, int timeout);

void LTS_waitHome(int i, int timeout);

char serialNumbers[][9] = {"45388004", "45387934","45388034"};  

// Set number of microsteps, found in APT communications protocol. Should be changed to 136533 if using K10CR1

int StepsPerMm = 409600;

double SingleMove=1; // in mm

int LTSTimerOut=0;

int p1_h;

int CVICALLBACK LTS_Timeout (int panel, int control, int event,

                             void *callbackData, int eventData1, int eventData2) {

  switch (event) {

    case EVENT_TIMER_TICK:

      LTSTimerOut = 1;

      printf("LTS timeout\n");

      break;

  }

  return 0;

}

/*

void LTS_Timerast (int signumber) {

  LTSTimerOut = 1;

  printf("TIMEOUT !!!\n");

  SetCtrlAttribute (p1_h, P1_TIMEOUT, ATTR_ENABLED, 0);

}

*/

void LTS_Tmlnk (int tout) {

  LTSTimerOut = 0;

  SetCtrlAttribute (p1_h, P1_TIMEOUT, ATTR_INTERVAL, (float)tout/1000.);

  SetCtrlAttribute (p1_h, P1_TIMEOUT, ATTR_ENABLED, 1);

}

void LTS_Tmulk ( void ) {

  SetCtrlAttribute (p1_h, P1_TIMEOUT, ATTR_ENABLED, 0);

  LTSTimerOut = 0;

}

void LTS_Home(int i,int wait){

//Set up homing parameters. 

                MOT_HomingParameters homingParams;

                ISC_GetHomingParamsBlock(serialNumbers[i], &homingParams);

                homingParams.direction = MOT_Reverse;

                ISC_SetHomingParamsBlock(serialNumbers[i], &homingParams);

                //Clear existing messages in the hardware buffer.

                ISC_ClearMessageQueue(serialNumbers[i]);

                //Home the stage and wait for the return message before continuing.

                ISC_Home(serialNumbers[i]);

                printf( "Start Homing...\n");

                if (wait) LTS_waitHome(i, wait);

                // printf( "Homed...\n");

}

int LTS_Init(int i){

  int errorReturn = ISC_Open(serialNumbers[i]);

  /*

  double stepsPerRev = 200;

  double gearBoxRatio = 1;

  double pitch = 1;

  int err = ISC_SetMotorParamsExt(serialNumbers[i], stepsPerRev, gearBoxRatio, pitch);

  err = ISC_GetMotorParamsExt(serialNumbers[i], &stepsPerRev, &gearBoxRatio, &pitch);

  // No effect

  */

  Sleep(1000);

  if (errorReturn == 0){

          printf( "Device %d (serial %s) Connected... \n",i, serialNumbers[i]);

          //Settings are loaded based on Stage Name. The integrated stepper class holds LTS and K10CR1 Information.

          ISC_SetLEDswitches(serialNumbers[i], 0); // disable LED 

          ISC_StartPolling(serialNumbers[i], 50);

          Sleep(1000);

  } else {

          printf( "Error connecting device %d (%s)\n",i, serialNumbers[i] );  

  }

  return errorReturn;

}

void LTS_Close(int i){

//Close the stage

        ISC_StopPolling(serialNumbers[i]);

        ISC_Close(serialNumbers[i]);

        printf( "Device Disconnected...\n");

}

void LTS_StopProfiled(int i){

  ISC_StopProfiled(serialNumbers[i]);

}  

void LTS_MoveAbsolute(int i, double position, int wait){

        ISC_SetMoveAbsolutePosition(serialNumbers[i], (position*StepsPerMm));

    ISC_MoveAbsolute(serialNumbers[i]);

        if (wait) LTS_waitMove(i, wait);

}

void LTS_MoveRelative(int i, double distance, int wait){

        ISC_SetMoveRelativeDistance(serialNumbers[i], (distance*StepsPerMm));

    ISC_MoveRelativeDistance(serialNumbers[i]);

        if (wait) LTS_waitMove(i, wait);

}

double LTS_GetPosition(int i){

  int device_unit = ISC_GetPosition(serialNumbers[i]); ;

  double real_unit = 1.0*device_unit / StepsPerMm;

  //const int unitType = 0 ;// 0 .. distance , 1 .. velocity, 2 .. acceleration

  // does not work int err = ISC_GetRealValueFromDeviceUnit(serialNumbers[i], device_unit,&real_unit, unitType);

  // printf("err = 0x%x pos %d %f\n", err ,device_unit, real_unit);

  return real_unit;

}

unsigned int LTS_GetStatus(int i){

  return ISC_GetStatusBits(serialNumbers[i]);

}  

int LTS_Enable(int i){

  return ISC_EnableChannel(serialNumbers[i]);

}

int LTS_Disable(int i){

  return ISC_DisableChannel(serialNumbers[i]);

}

int LTS_GetNumberPositions(int i){

  return ISC_GetNumberPositions(serialNumbers[i]);

}

int LTS_Open(){

  TLI_BuildDeviceList();

  TLI_DeviceInfo info;

  int err=0;

  for (int i=0;i<3;i++){

        TLI_GetDeviceInfo(serialNumbers[i], &info);

        Sleep(100);

        err = LTS_Init(i);

        printf("%s err=%x\n", info.description, err);

        if (err) return err;

  }

  return 0;

}

void LTS_RegisterMessageCallback(int i, void (* functionPointer)()){

  ISC_RegisterMessageCallback(serialNumbers[i], functionPointer );

}

void LTS_GetRealValueFromDeviceUnit(int i, int device_unit, double *real_unit, int unitType){

  ISC_GetRealValueFromDeviceUnit(serialNumbers[i], device_unit, real_unit, unitType);

}

void LTS_GetDeviceUnitFromRealValue(int i, double real_unit, int *device_unit, int unitType){

  ISC_GetDeviceUnitFromRealValue(serialNumbers[i], real_unit, device_unit, unitType);

}

//Waits should only be used for Home commands. The home command has a different status return.

void LTS_waitHome(int i, int tout)// Waits until a single axis is homed.

{

        WORD messageType=0;

        WORD messageId=0;

        DWORD messageData=0;

        int condition=0;

        LTS_Tmlnk (tout);

        do {

                while (!ISC_MessageQueueSize(serialNumbers[i])){

                  Sleep(250);

                  if (LTSTimerOut) break;

                }

                if (LTSTimerOut){

                        printf( "Timeout in axis [%d] pos: %f messageType %d, messageId %d\n",i,LTS_GetPosition(i), messageType, messageId);

                        break;

                }

                ISC_GetNextMessage(serialNumbers[i], &messageType, &messageId, &messageData);

                condition = (messageType == 2) && (messageId == 0);

        } while (!condition || !LTSTimerOut);

        LTS_Tmulk();

}

void LTS_waitMove(int i, int tout)// Waits until axis is stopped.

{

        WORD  messageType=0;

        WORD  messageId=0;

        DWORD messageData=0;

        int condition=0;  

        LTS_Tmlnk (tout);

        do {

                while (!ISC_MessageQueueSize(serialNumbers[i])){

                  Sleep(250);

                  if (LTSTimerOut) break;

                }

                if (LTSTimerOut){

                        printf( "Timeout in axis [%d] pos: %f messageType %d, messageId %d\n",i,LTS_GetPosition(i), messageType, messageId);

                        break;

                }

                ISC_GetNextMessage(serialNumbers[i], &messageType, &messageId, &messageData);

                condition = (messageType == 2) && (messageId == 1);

        } while (!condition);      

        LTS_Tmulk();

}

//*******************************************************************

#ifdef LTS_MAIN

int rID, tfID;

#define MAX_THREADS 10

static CmtThreadPoolHandle poolHandle = 0;

int lid[][14]= {

          {P1_L1,P1_L2,P1_L3,P1_L4,P1_L5,P1_L6,P1_L7,P1_L8,P1_L9,P1_L10,P1_L11,P1_L12,P1_L13,P1_L14},

          {P1_L1_2,P1_L2_2,P1_L3_2,P1_L4_2,P1_L5_2,P1_L6_2,P1_L7_2,P1_L8_2,P1_L9_2,P1_L10_2,P1_L11_2,P1_L12_2,P1_L13_2,P1_L14_2},

          {P1_L1_3,P1_L2_3,P1_L3_3,P1_L4_3,P1_L5_3,P1_L6_3,P1_L7_3,P1_L8_3,P1_L9_3,P1_L10_3,P1_L11_3,P1_L12_3,P1_L13_3,P1_L14_3}};

int dstat[3]={P1_N2,P1_N2_2,P1_N2_3};

int dpos[3]={P1_XP,P1_YP,P1_ZP};

int ctrl_c=0;

void LTS_SetStatus(int nid){

        int status=LTS_GetStatus(nid);

        SetCtrlVal (p1_h, dstat[nid], status);

        SetCtrlVal (p1_h, lid[nid][12], (status & 0x20000000)>0);

        SetCtrlVal (p1_h, lid[nid][13], (status & 0x80000000)>0);

        for (int i=0; i<12; i++) {

          SetCtrlVal (p1_h, lid[nid][i], status & 1);

          status>>=1;

        }

}

void CVICALLBACK EndOfThread ( CmtThreadPoolHandle poolhandle,

                               CmtThreadFunctionID functionID, unsigned int event,

                               int value, void *callbackData  ) {

  SetCtrlVal (p1_h, P1_SCANLED, 0);

  ctrl_c=0;

  return ;

}

int CVICALLBACK daq(void *functionData) {

        ctrl_c =0;

        SetCtrlVal (p1_h, P1_SCANLED, 1);

        int nx,ny,nz;

        GetCtrlVal(p1_h,P1_NX, &nx);

        GetCtrlVal(p1_h,P1_NY, &ny);

        GetCtrlVal(p1_h,P1_NZ, &nz);

        double dx,dy,dz;

        GetCtrlVal(p1_h,P1_DX, &dx);

        GetCtrlVal(p1_h,P1_DY, &dy);

        GetCtrlVal(p1_h,P1_DZ, &dz);

        double x0,y0,z0;

        GetCtrlVal(p1_h,P1_X0, &x0);

        GetCtrlVal(p1_h,P1_Y0, &y0);

        GetCtrlVal(p1_h,P1_Z0, &z0);

        int cbx,cby,cbz;

        int timeout=10000; // timeout in ms 

        GetCtrlVal(p1_h,P1_CBX, &cbx);

        GetCtrlVal(p1_h,P1_CBY, &cby);

        GetCtrlVal(p1_h,P1_CBZ, &cbz);

    if (!cbx) nx=1;

        if (!cby) ny=1;

        if (!cbz) nz=1;

        int  nstep=0;

        double totalSteps=nx*ny*nz;

        for (int iz=0;iz<nz;iz++){

          double zposition= z0+ iz*dz;

          SetCtrlVal(p1_h,P1_IZ, iz);

          SetCtrlVal(p1_h,P1_DAQLED, 1);

          LTS_MoveAbsolute(2,zposition,timeout);

          SetCtrlVal(p1_h,P1_DAQLED, 0);

          for (int iy=0;iy<ny;iy++){

                double yposition= y0+ iy*dy;

                SetCtrlVal(p1_h,P1_IY, iy);

                SetCtrlVal(p1_h,P1_DAQLED, 1);

                LTS_MoveAbsolute(1,yposition,timeout);

                SetCtrlVal(p1_h,P1_DAQLED, 0);

            for (int ix=0;ix<nx;ix++){

                   double xposition= x0+ ix*dx;

                   SetCtrlVal(p1_h,P1_IX, ix);

                   SetCtrlVal(p1_h,P1_DAQLED, 1);

                   LTS_MoveAbsolute(0,xposition,timeout);

                   SetCtrlVal(p1_h,P1_DAQLED, 0);

                   for (int k=0;k<3;k++){  

             double n2 = LTS_GetPosition(k);

             SetCtrlVal (p1_h, dpos[k], n2);

                     LTS_SetStatus(k);

                   }

                   //printf("[%d]\n",nstep++);

                   nstep++;

                   double ratio = nstep/totalSteps;

                   SetCtrlVal(p1_h,P1_PROGRESS, 100.*ratio);

                   Delay(0.1);

                   if (ctrl_c) break;

            }

                if (ctrl_c) break;

          }

          if (ctrl_c) break;

        }

        return 0;

}

void MessageCB(){

        //printf("Message %d\n",d[0]);

        return;

}

int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,

                       LPSTR lpszCmdLine, int nCmdShow) {

  int evcontrl,evpanel,ierr;

  double n2;

  int comled;

  int enabled=0;

  SetSleepPolicy(VAL_SLEEP_MORE);

  CmtNewThreadPool (MAX_THREADS,  &poolHandle);

  SetStdioPort (CVI_STDIO_WINDOW);

  if (InitCVIRTE (hInstance, 0, 0) == 0) return -1; /* out of memory */

  p1_h = LoadPanel (0,"ThorlabsLTS_ui.uir", P1);

  //p1_h = BuildP1 (0);

  ierr = DisplayPanel (p1_h);

  ierr = SetActiveCtrl (p1_h,P1_B1);

  ierr = SetActiveCtrl (p1_h,P1_B3);

  GetCtrlVal (p1_h, P1_COMLED, &comled);

  if (!comled) {

      //GetCtrlVal (p1_h, P1_PORT, &port);

      //if (MIKRO_Open (port)) continue;

      LTS_Open();

      SetCtrlVal (p1_h, P1_COMLED, 1);

          for (int i=0;i<3;i++) LTS_RegisterMessageCallback(i, &MessageCB );

  }

  int scanled=0;

  while (1) {

    ierr = GetUserEvent (1, &evpanel, &evcontrl);

        //printf("GetUserEvent %d %d\n", evpanel, evcontrl);

        if (evcontrl == P1_STOPSCAN) ctrl_c=1;

        GetCtrlVal (p1_h, P1_SCANLED, &scanled);

        if (scanled) continue;

        if (evcontrl == P1_B1) break;

    switch (evcontrl) {

      case P1_BL:

        LTS_MoveRelative(0,-SingleMove, 0);

        break;

      case P1_BR:

        LTS_MoveRelative(0,+SingleMove, 0);

        break;

      case P1_BU:

        LTS_MoveRelative(1,+SingleMove, 0);

        break;

      case P1_BD:

        LTS_MoveRelative(1,-SingleMove, 0);

        break;

      case P1_BF:

        LTS_MoveRelative(2,+SingleMove, 0);

        break;

      case P1_BB:

        LTS_MoveRelative(2,-SingleMove, 0);

        break;

      case P1_HO:

        LTS_Home(0,0);

        break;

          case P1_HO_2:

        LTS_Home(1,0);

        break;

          case P1_HO_3:

        LTS_Home(2,0);

        break;

      case P1_GX:

        GetCtrlVal (p1_h, P1_XG, &n2);

                LTS_MoveAbsolute(0,n2,0);

        break;

      case P1_GY:

        GetCtrlVal (p1_h, P1_YG, &n2);

        LTS_MoveAbsolute(1,n2,0);

        break;

      case P1_GZ:

        GetCtrlVal (p1_h, P1_ZG, &n2);

        LTS_MoveAbsolute(2,n2,0);

        break;

      case P1_G:

        GetCtrlVal (p1_h, P1_XG, &n2);

        LTS_MoveAbsolute(0,n2,0);

        GetCtrlVal (p1_h, P1_YG, &n2);

        LTS_MoveAbsolute(1,n2,0);

        GetCtrlVal (p1_h, P1_ZG, &n2);

        LTS_MoveAbsolute(2,n2,0);

                break;

      case P1_B3: // reset

      case P1_B3_2: // reset

          case P1_B3_3: // reset

                printf("RST Not yet implemented\n");

        break;

          case P1_STOP:

        LTS_StopProfiled(0);

        break;

          case P1_STOP_2:

        LTS_StopProfiled(1);

        break;

          case P1_STOP_3:

        LTS_StopProfiled(2);

        break; 

      case P1_EN:

        LTS_Enable(0);

        break;

          case P1_EN_2:

        LTS_Enable(1);

        break;

          case P1_EN_3:

        LTS_Enable(2);

        break;

          case P1_DIS:

        LTS_Disable(0);

        break;

          case P1_DIS_2:

        LTS_Disable(1);

        break;

          case P1_DIS_3:

        LTS_Disable(2);

        break;

          case P1_TIMER:

                for (int k=0;k<3;k++){  

          double position = LTS_GetPosition(k);

          SetCtrlVal (p1_h, dpos[k], position);

                  LTS_SetStatus(k);

                }

        break;

          case P1_SCAN:

                enabled=1;

                const int LTS_Enabled = 0x80000000;

                for (int i=0;i<3;i++) if (!(LTS_GetStatus(i)& LTS_Enabled)) enabled =0;

                if (enabled){  

                  SetCtrlVal(p1_h,P1_DAQLED, 0);

                  CmtScheduleThreadPoolFunctionAdv (poolHandle, daq, &rID,

                                        DEFAULT_THREAD_PRIORITY,

                                        EndOfThread,

                                        EVENT_TP_THREAD_FUNCTION_END,

                                        NULL, RUN_IN_SCHEDULED_THREAD,

                                        &tfID);

                } else {

                  MessagePopup ("Error", "Enable LTS Stages First");

                }        

                break;

      default:

        break;

    }

    Delay(0.001);

  }

  GetCtrlVal (p1_h, P1_COMLED, &comled);

  if (comled) for (int i=0;i<3;i++) LTS_Close (i);

  return 0;

}

int CVICALLBACK TimerCB (int panel, int control, int event,

                                                 void *callbackData, int eventData1, int eventData2)

{

        int isrunning;

        switch (event)

        {

                case EVENT_TIMER_TICK:

                        GetCtrlVal (p1_h, P1_SCANLED, &isrunning);

                        if (!isrunning) QueueUserEvent (1, p1_h, P1_TIMER);

                        break;

        }

        return 0;

}

#else

// *************************************

int main(int argc, char ** argv)

{

        //Sets up simulations. Comment in if running on physical hardware. 

        //TLI_InitializeSimulations();

        //Input serial number. Change for your specific device. 

        //serials = ["45388004", "45387934","45388034"] 

        //Build Device List and open device.

        TLI_BuildDeviceList();

        TLI_DeviceInfo info;

        int err=0;

        for (int i=0;i<3;i++){

          TLI_GetDeviceInfo(serialNumbers[i], &info);

          printf("%s\n", info.description);

          Sleep(1000);

          err |= LTS_Init(i);

        }  

        for (int i=0;i<3;i++){

                //Move the stage and wait for the return message before continuing.

                for (int k=0;k<10;k++){

                  LTS_MoveAbsolute(i,k);

                  printf( "Moving ...\n");

                  waitMove(i);

                  printf( "Move Complete...\n");

                }

        }

        for (int i=0;i<3;i++){

           LTS_Close(i);

        }

        //Closes simulations. Comment if running on physical hardware. 

        //TLI_UninitializeSimulations();

        Delay(10);

        return 0;

}

#endif