Пример #1
0
int MCL_NanoDrive_XYStage::Initialize()
{
// BEGIN LOCKING
HandleListLock();

   int err = DEVICE_OK;
   int possHandle = 0;
   bool valid = false; 
   
   ProductInformation pi;
   memset(&pi, 0, sizeof(ProductInformation));

   if (initialized_)
   { 
	  // If already initialized, no need to continue
	  goto INIT_ERROR;
   }

   if(!MCL_CorrectDriverVersion())
   {
	   err = MCL_INVALID_DRIVER;
	   goto INIT_ERROR;
   }

   int numHandles = MCL_GrabAllHandles();
   if (numHandles == 0)
   { 
	   // No handles, i.e. no devices currently attached
	   err = MCL_INVALID_HANDLE;
	   goto INIT_ERROR;
   }

   int* handlesToUseOrRelease = NULL;
   handlesToUseOrRelease = (int*) malloc(sizeof(int*) * numHandles);
   MCL_GetAllHandles(handlesToUseOrRelease, numHandles);

   HandleListType* device = (HandleListType*)GlobalHeapAllocate(sizeof(HandleListType));
   device->Initialize(possHandle, XY_TYPE);
   for (int i = 0; i < numHandles; i++)
   {   
		possHandle = handlesToUseOrRelease[i];
		device->setHandle(possHandle);

		MCL_GetProductInfo(&pi, possHandle);
		
		// check to see which axes are valid
		bool validXaxis = ((pi.axis_bitmap & VALIDX) == VALIDX);
		bool validYaxis = ((pi.axis_bitmap & VALIDY) == VALIDY);

		if ( (validXaxis && validYaxis) && 
			 (!HandleExistsOnLockedList(device)) &&
			 (possHandle > 0) )
		{	
			valid = true;

			HandleListAddToLockedList(device);
			MCLhandle_ = possHandle;

			// release handles not in use.
			for (int j = i+1; j < numHandles; j++)
			{
				possHandle = handlesToUseOrRelease[j];
				if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
				{ 	
					MCL_ReleaseHandle(possHandle);
				}
			}
			break; // found a valid handle, so no need to check any further
		}
		else
		{
			if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
			{
				MCL_ReleaseHandle(possHandle);
			}
		}
   }
   free (handlesToUseOrRelease);

   if (!valid)
   {
	   GlobalHeapFree(device);
	   err = MCL_INVALID_HANDLE;
	   goto INIT_ERROR;
   }

	xMin_ = 0;
	yMin_ = 0;

	xMax_ = MCL_GetCalibration(XAXIS, MCLhandle_);
	if (xMax_ < 0)
	{
		err = (int) xMax_;
		goto INIT_ERROR;
	}
	
	yMax_ = MCL_GetCalibration(YAXIS, MCLhandle_);
	if (yMax_ < 0)
	{
		err = (int) yMax_;
		goto INIT_ERROR;
	}

	if (pi.Product_id == 0x1230 || pi.Product_id == 0x1253 || pi.Product_id == 0x2201 || 
		pi.Product_id == 0x2203 || pi.Product_id == 0x2253)
	{
		stepSizeX_um_ = xMax_ / NUM_STEPS_20;
		stepSizeY_um_ = yMax_ / NUM_STEPS_20;
		is20Bit_ = true;
	}
	else 
	{
		stepSizeX_um_ = xMax_ / NUM_STEPS_16;
		stepSizeY_um_ = yMax_ / NUM_STEPS_16;
		is20Bit_ = false;
	}
	
	curXpos_ = MCL_SingleReadN(XAXIS, MCLhandle_);
	if ((int)curXpos_ < 0)
	{ 
		err = (int) curXpos_;
		goto INIT_ERROR;
	}

	curYpos_ = MCL_SingleReadN(YAXIS, MCLhandle_);
	if ((int)curYpos_ < 0)
	{  
		err = (int) curYpos_;
		goto INIT_ERROR;
	}

	serialNumber_ = MCL_GetSerialNumber(MCLhandle_);
	if (serialNumber_ < 0)
	{
		err = (int) serialNumber_;
		goto INIT_ERROR;
	}

	err = SetDeviceProperties();
	if (err != DEVICE_OK)
	{
		goto INIT_ERROR;
	}

	err = UpdateStatus();
	if (err != DEVICE_OK)
	{
		goto INIT_ERROR;
	}

	initialized_ = true;

INIT_ERROR:

// END LOCKING	
HandleListUnlock();

	return err;
}
Пример #2
0
int MCL_MicroDrive_ZStage::Initialize()
{
	// BEGIN LOCKING -> make sure to unlock before any return call
	HandleListLock(); 

	int err = DEVICE_OK;
	std::stringstream ss;
	bool valid = false;
	unsigned char axisBitmap;
	int possHandle = 0;

	if (initialized_)
	{
		err = DEVICE_OK;
		goto ZSTAGE_INIT_EXIT;
	}

	if(!MCL_CorrectDriverVersion())
	{
		err = MCL_INVALID_DRIVER;
		goto ZSTAGE_INIT_EXIT;
	}

	int numHandles = MCL_GrabAllHandles();
	if (numHandles == 0)
	{
		err = MCL_INVALID_HANDLE;
		goto ZSTAGE_INIT_EXIT;
	}

	int* handlesToUseOrRelease = NULL;
	handlesToUseOrRelease = (int*) malloc(sizeof(int*) * numHandles);
	MCL_GetAllHandles(handlesToUseOrRelease, numHandles);

	HandleListType* device = (HandleListType*)GlobalHeapAllocate(sizeof(HandleListType));
	device->Initialize(possHandle, Z_TYPE);

	for (int i = 0; i < numHandles; i++)
	{
		possHandle = handlesToUseOrRelease[i];
		device->setHandle(possHandle);

		MCL_GetAxisInfo(&axisBitmap, possHandle);
		
		// By default use the Z axis.
		bool validAxis = ((axisBitmap & VALIDZ) == VALIDZ);
		if (validAxis)
		{
			axis_  = ZAXIS;
		}
		// Otherwise use the X or Y axis of a single axis system.
		else if ( (axisBitmap & (VALIDX | VALIDY) ) != (VALIDX | VALIDY) )
		{
			if ( (axisBitmap & AXIS_MASK) == VALIDX )
			{
				axis_ = XAXIS;
				validAxis = true;
			}

			if ( (axisBitmap & AXIS_MASK) == VALIDY )
			{
				axis_ = YAXIS;
				validAxis = true;
			}
		}

		if ((validAxis) && (!HandleExistsOnLockedList(device)) && (possHandle > 0))
		{ 
			valid = true;

			HandleListAddToLockedList(device);
			MCLhandle_ = possHandle;

			unsigned short PID;
			MCL_GetProductID(&PID, MCLhandle_);

			if(PID == 0x2501)
				isMD1_ = true;
			else
				isMD1_ = false;

			// release handles not in use.
			for (int j = i+1; j < numHandles; j++)
			{
				possHandle = handlesToUseOrRelease[j];
				if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
				{	
					MCL_ReleaseHandle(possHandle);
				}
			}
			break; // done, no need to check further
		}
		else 
		{ 
			if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
			{
				MCL_ReleaseHandle(possHandle);
			}
		}
   }
   free (handlesToUseOrRelease);

   if (!valid)
   {
	   GlobalHeapFree(device);
	   err = MCL_INVALID_HANDLE;
	   goto ZSTAGE_INIT_EXIT;
   }

	if(isMD1_)
		MCL_MD1Information(&encoderResolution_, &stepSize_mm_, &maxVelocity_, &minVelocity_, MCLhandle_);
	else
	{
		double ignore1, ignore2;
		err = MCL_MicroDriveInformation(&encoderResolution_, &stepSize_mm_, &maxVelocity_, &ignore1, &ignore2, &minVelocity_, MCLhandle_);
	}
	ss << "Detected Encoder Resolution: " << encoderResolution_;
	this->LogMessage(ss.str());

	if (err != MCL_SUCCESS)
		goto ZSTAGE_INIT_EXIT;

	velocity_ = maxVelocity_;

	char velErrText[50];
	sprintf(velErrText, "Velocity must be between %f and %f", minVelocity_, maxVelocity_);
	SetErrorText(INVALID_VELOCITY, velErrText);

	CreateZStageProperties();

	err = UpdateStatus();
	if (err != DEVICE_OK)
		goto ZSTAGE_INIT_EXIT;

	initialized_ = true;

	ZSTAGE_INIT_EXIT:
		HandleListUnlock();
		return err;
}
Пример #3
0
int MicroDriveXYStage::Initialize()
{
	// BEGIN LOCKING
	HandleListLock();

   int err = DEVICE_OK;
   std::stringstream ss;
   bool valid = false;
   unsigned char axisBitmap;
   int possHandle = 0;

   if (initialized_)
   {
	   err = DEVICE_OK;
	   goto INIT_ERROR;
   }

   if(!MCL_CorrectDriverVersion())
   {
	   err=MCL_INVALID_DRIVER;
	   goto INIT_ERROR;
   }

   int numHandles = MCL_GrabAllHandles();
   if (numHandles == 0)
   { 
	   // No handles, i.e. no devices currently attached
	   err = MCL_INVALID_HANDLE;
	   goto INIT_ERROR;
   }

   int* handlesToUseOrRelease = NULL;
   handlesToUseOrRelease = (int*) malloc(sizeof(int*) * numHandles);
   MCL_GetAllHandles(handlesToUseOrRelease, numHandles);

   HandleListType* device = (HandleListType*)GlobalHeapAllocate(sizeof(HandleListType));
   device->Initialize(possHandle, XY_TYPE);
   for (int i = 0; i < numHandles; i++)
   {   
		possHandle = handlesToUseOrRelease[i];
		device->setHandle(possHandle);

		MCL_GetAxisInfo(&axisBitmap, possHandle);
		
		// check to see which axes are valid
		bool validXaxis = ((axisBitmap & VALIDX) == VALIDX);
		bool validYaxis = ((axisBitmap & VALIDY) == VALIDY);

		if ( (validXaxis && validYaxis) && 
			 (!HandleExistsOnLockedList(device)) &&
			 (possHandle > 0) )
		{	
			valid = true;

			HandleListAddToLockedList(device);
			MCLhandle_ = possHandle;

			// release handles not in use.
			for (int j = i+1; j < numHandles; j++)
			{
				possHandle = handlesToUseOrRelease[j];
				if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
				{ 	
					MCL_ReleaseHandle(possHandle);
				}
			}
			break; // found a valid handle, so no need to check any further
		}
		else
		{
			if (!HandleExistsOnLockedList(possHandle) && possHandle > 0)
			{
				MCL_ReleaseHandle(possHandle);
			}
		}
   }
   free (handlesToUseOrRelease);

   if (!valid)
   {
	   GlobalHeapFree(device);
	   err = MCL_INVALID_HANDLE;
	   goto INIT_ERROR;
   }

   err = MCL_MicroDriveInformation(&encoderResolution_, &stepSize_mm_, &maxVelocity_, &maxVelocityTwoAxis_, &maxVelocityThreeAxis_, &minVelocity_, MCLhandle_);
   ss << "Detected Encoder Resolution: " << encoderResolution_;
   this->LogMessage(ss.str());

   if (err != MCL_SUCCESS)
	   goto INIT_ERROR;

   velocity_ = maxVelocity_;

   char velErrText[50];
   sprintf(velErrText, "Velocity must be between %f and %f", minVelocity_, maxVelocity_);
   SetErrorText(INVALID_VELOCITY, velErrText);

   CreateMicroDriveXYProperties();

   err = UpdateStatus();
   if (err != DEVICE_OK)
      goto INIT_ERROR;

   initialized_ = true;

   INIT_ERROR:
	// END LOCKING	
	HandleListUnlock();
	return err;
}