/*
* Do actual capturing
* Called from inside the thread
*/
int CIDS_uEye::ThreadRun (void)
{
int ret=DEVICE_ERR;
// Trigger
if (triggerDevice_.length() > 0) {
MM::Device* triggerDev = GetDevice(triggerDevice_.c_str());
if (triggerDev != 0) {
LogMessage("trigger requested");
triggerDev->SetProperty("Trigger","+");
}
}
ret = SnapImage();
if (ret != DEVICE_OK)
{
return ret;
}
ret = InsertImage();
if (ret != DEVICE_OK)
{
return ret;
}
return ret;
};
int PIZStage::Initialize()
{
MM::Device* device = GetDevice(controllerName_.c_str());
if (device == NULL)
return ERR_GCS_PI_NO_CONTROLLER_FOUND;
int ret = device->Initialize();
if (ret != DEVICE_OK)
return ret;
ctrl_ = PIController::GetByLabel(controllerName_);
if (ctrl_ == NULL)
return ERR_GCS_PI_NO_CONTROLLER_FOUND;
std::string sBuffer;
ctrl_->qIDN(sBuffer);
LogMessage(std::string("Connected to: ") + sBuffer);
ret = ctrl_->InitStage(axisName_, stageType_);
if (ret != DEVICE_OK)
{
LogMessage("Cannot init axis");
return ret;
}
// axis limits (assumed symmetrical)
CPropertyAction* pAct = new CPropertyAction (this, &PIZStage::OnHoming);
CreateProperty("HOMING", "", MM::String, false, pAct);
pAct = new CPropertyAction (this, &PIZStage::OnVelocity);
CreateProperty("Velocity", "", MM::Float, false, pAct);
initialized_ = true;
return DEVICE_OK;
}
MM::DeviceDetectionStatus DiskoveryHub::DetectDevice(void )
{
char answerTO[MM::MaxStrLength];
if (initialized_)
return MM::CanCommunicate;
MM::DeviceDetectionStatus result = MM::Misconfigured;
try
{
std::string portLowerCase = port_;
for( std::string::iterator its = portLowerCase.begin(); its != portLowerCase.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< portLowerCase.length() && 0 != portLowerCase.compare("undefined") && 0 != portLowerCase.compare("unknown") )
{
result = MM::CanNotCommunicate;
// record the default answer time out
GetCoreCallback()->GetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
// device specific default communication parameters
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Hardware");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, "115200" );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", "100.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "DelayBetweenCharsMs", "0");
// Attempt to communicate through the port
MM::Device* pS = GetCoreCallback()->GetDevice(this, port_.c_str());
pS->Initialize();
PurgeComPort(port_.c_str());
bool present = false;
int ret = IsControllerPresent(port_, present);
if (ret != DEVICE_OK)
return result;
if (present)
{
result = MM::CanCommunicate;
// set the timeout to a value higher than the heartbeat frequency
// so that the logs will not overflow with errors
GetCoreCallback()->SetDeviceProperty(port_.c_str(),
"AnswerTimeout", "6000");
} else
{
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
}
pS->Shutdown();
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!",false);
}
return result;
}
MM::DeviceDetectionStatus CTigerCommHub::DetectDevice() // looks for hub, not child devices
{
if (initialized_)
return MM::CanCommunicate;
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
char answerTO[MM::MaxStrLength];
try
{
std::string portLowerCase = port_;
for( std::string::iterator its = portLowerCase.begin(); its != portLowerCase.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< portLowerCase.length() && 0 != portLowerCase.compare("undefined") && 0 != portLowerCase.compare("unknown") )
{
result = MM::CanNotCommunicate;
// record the default answer time out
GetCoreCallback()->GetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
// device specific default communication parameters for ASI Tiger controller
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Off");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, "115200" );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", "500.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "DelayBetweenCharsMs", "0");
MM::Device* pS = GetCoreCallback()->GetDevice(this, port_.c_str());
pS->Initialize();
PurgeComPort(port_.c_str());
int ret = TalkToTiger(); // this line unique to this hub, most of rest is copied from existing code
if( DEVICE_OK != ret )
{
LogMessageCode(ret,true);
}
else
{
// to succeed must reach here....
result = MM::CanCommunicate;
}
pS->Shutdown();
// restore the AnswerTimeout to the default
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!");
}
return result;
}
MM::Device* Hub::CreatePeripheralDevice(const char* adapterName)
{
for(unsigned i = 0; i < GetNumberOfInstalledDevices(); i++)
{
MM::Device* d = GetInstalledDevice(i);
char name[MM::MaxStrLength];
d->GetName(name);
if(strcmp(adapterName, name) == 0)
return CreateDevice(adapterName);
}
return 0;
}
MM::DeviceDetectionStatus Stage::DetectDevice(void)
{
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
try
{
std::string transformed = port_;
for( std::string::iterator its = transformed.begin(); its != transformed.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< transformed.length() && 0 != transformed.compare("undefined") && 0 != transformed.compare("unknown") )
{
// the port property seems correct, so give it a try
result = MM::CanNotCommunicate;
// device specific default communication parameters
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, "9600" );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_DataBits, "8");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Parity, "None");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Off" );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_AnswerTimeout, "500.0");
MM::Device* pS = GetCoreCallback()->GetDevice(this, port_.c_str());
pS->Initialize();
std::string v;
int qvStatus = this->GetVersion(v);
//LogMessage(std::string("version : ")+v, true);
ver_=v;
if( DEVICE_OK != qvStatus )
{
LogMessageCode(qvStatus,true);
}
else
{
// to succeed must reach here....
result = MM::CanCommunicate;
}
pS->Shutdown();
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!",false);
}
return result;
}
/*
* Do actual capturing
* Called from inside the thread
*/
int COpenCVgrabber::ThreadRun (void)
{
int ret=DEVICE_ERR;
// Trigger
if (triggerDevice_.length() > 0) {
MM::Device* triggerDev = GetDevice(triggerDevice_.c_str());
if (triggerDev != 0) {
//char label[256];
//triggerDev->GetLabel(label);
LogMessage("trigger requested");
triggerDev->SetProperty("Trigger","+");
}
}
ret = SnapImage();
if (ret != DEVICE_OK) return ret;
ret = InsertImage();
if (ret != DEVICE_OK) return ret;
return ret;
};
MM::DeviceDetectionStatus Hub::DetectDevice(void)
{
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
char answerTO[MM::MaxStrLength];
try
{
std::string portLowerCase = port_;
for( std::string::iterator its = portLowerCase.begin(); its != portLowerCase.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< portLowerCase.length() && 0 != portLowerCase.compare("undefined") && 0 != portLowerCase.compare("unknown") )
{
result = MM::CanNotCommunicate;
// record the default answer time out
GetCoreCallback()->GetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
// device specific default communication parameters
// for ASI FW
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Off");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", "500.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "DelayBetweenCharsMs", "0");
MM::Device* pS = GetCoreCallback()->GetDevice(this, port_.c_str());
std::vector< std::string> possibleBauds;
possibleBauds.push_back("115200");
possibleBauds.push_back("28800");
possibleBauds.push_back("19200");
possibleBauds.push_back("9600");
for( std::vector< std::string>::iterator bit = possibleBauds.begin(); bit!= possibleBauds.end(); ++bit )
{
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, (*bit).c_str() );
pS->Initialize();
PurgeComPort(port_.c_str());
// Version
char version[256];
int ret = g_hub.GetVersion(*this, *GetCoreCallback(), version);
if( DEVICE_OK != ret )
{
LogMessageCode(ret,true);
}
else
{
// to succeed must reach here....
result = MM::CanCommunicate;
}
pS->Shutdown();
CDeviceUtils::SleepMs(300);
if( MM::CanCommunicate == result)
break;
}
// always restore the AnswerTimeout to the default
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!",false);
}
return result;
}
MM::DeviceDetectionStatus RAMPSHub::DetectDevice(void)
{
LogMessage("RAMPS DetectDevice");
if (initialized_)
return MM::CanCommunicate;
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
char answerTO[MM::MaxStrLength];
try
{
std::string portLowerCase = port_;
for( std::string::iterator its = portLowerCase.begin(); its != portLowerCase.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< portLowerCase.length() && 0 != portLowerCase.compare("undefined") && 0 != portLowerCase.compare("unknown") )
{
result = MM::CanNotCommunicate;
// record the default answer time out
GetCoreCallback()->GetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
// device specific default communication parameters
// for Arduino Duemilanova
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Off");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, "115200" );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", "500.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "DelayBetweenCharsMs", "0");
MM::Device* pS = GetCoreCallback()->GetDevice(this, port_.c_str());
pS->Initialize();
// The first second or so after opening the serial port, the Arduino is waiting for firmwareupgrades. Simply sleep 2 seconds.
CDeviceUtils::SleepMs(2000);
MMThreadGuard myLock(executeLock_);
string an;
while (true) {
int ret = ReadResponse(an);
if (ret != DEVICE_OK)
{
LogMessage("Got timeout:");
LogMessageCode(ret,true);
break;
}
}
LogMessage("Checking for status.");
PurgeComPort(port_.c_str());
int ret = GetStatus();
// later, Initialize will explicitly check the version #
if( DEVICE_OK != ret )
{
LogMessage("Got:");
LogMessageCode(ret,true);
}
else
{
// to succeed must reach here....
result = MM::CanCommunicate;
}
pS->Shutdown();
// always restore the AnswerTimeout to the default
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "AnswerTimeout", answerTO);
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!",false);
}
return result;
}
MM::DeviceDetectionStatus VariLC::DetectDevice(void)
{
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
try
{
long baud;
GetProperty(g_BaudRate_key, baud);
std::string transformed = port_;
for( std::string::iterator its = transformed.begin(); its != transformed.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< transformed.length() && 0 != transformed.compare("undefined") && 0 != transformed.compare("unknown") )
{
int ret = 0;
MM::Device* pS;
// the port property seems correct, so give it a try
result = MM::CanNotCommunicate;
// device specific default communication parameters
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_AnswerTimeout, "2000.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, baud_.c_str() );
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_DelayBetweenCharsMs, "0.0");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Handshaking, "Off");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_Parity, "None");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
GetCoreCallback()->SetDeviceProperty(port_.c_str(), "Verbose", "1");
pS = GetCoreCallback()->GetDevice(this, port_.c_str());
pS->Initialize();
ClearPort(*this, *GetCoreCallback(), port_);
ret = SendSerialCommand(port_.c_str(), "V?", "\r");
GetSerialAnswer (port_.c_str(), "\r", serialnum_);
GetSerialAnswer (port_.c_str(), "\r", serialnum_);
if (ret!=DEVICE_OK || serialnum_.length() < 5)
{
LogMessageCode(ret,true);
LogMessage(std::string("VariLC not found on ")+port_.c_str(), true);
LogMessage(std::string("VariLC serial no:")+serialnum_, true);
ret = 1;
serialnum_ = "0";
pS->Shutdown();
} else
{
// to succeed must reach here....
LogMessage(std::string("VariLC found on ")+port_.c_str(), true);
LogMessage(std::string("VariLC serial no:")+serialnum_, true);
result = MM::CanCommunicate;
GetCoreCallback()->SetSerialProperties(port_.c_str(),
"600.0",
baud_.c_str(),
"0.0",
"Off",
"None",
"1");
serialnum_ = "0";
pS->Initialize();
ret = SendSerialCommand(port_.c_str(), "R 1", "\r");
ret = SendSerialCommand(port_.c_str(), "C 0", "\r");
pS->Shutdown();
}
}
}
catch(...)
{
LogMessage("Exception in DetectDevice!",false);
}
return result;
}
boost::shared_ptr<DeviceInstance>
LoadedDeviceAdapter::LoadDevice(CMMCore* core, const std::string& name,
const std::string& label,
mm::logging::Logger deviceLogger,
mm::logging::Logger coreLogger)
{
MM::Device* pDevice = CreateDevice(name.c_str());
if (!pDevice)
throw CMMError("Device adapter " + ToQuotedString(GetName()) +
" failed to instantiate device " + ToQuotedString(name));
MM::DeviceType expectedType;
try
{
expectedType = GetAdvertisedDeviceType(name);
}
catch (const CMMError&)
{
// The type of a device that was not explictily registered (e.g. a
// peripheral device or a device provided only for backward
// compatibility) will not be available.
expectedType = MM::UnknownType;
}
MM::DeviceType actualType = pDevice->GetType();
if (expectedType == MM::UnknownType)
expectedType = actualType;
boost::shared_ptr<LoadedDeviceAdapter> shared_this(shared_from_this());
DeleteDeviceFunction deleter = boost::bind<void>(&LoadedDeviceAdapter::DeleteDevice, this, _1);
switch (expectedType)
{
case MM::CameraDevice:
return boost::make_shared<CameraInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::ShutterDevice:
return boost::make_shared<ShutterInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::StageDevice:
return boost::make_shared<StageInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::XYStageDevice:
return boost::make_shared<XYStageInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::StateDevice:
return boost::make_shared<StateInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::SerialDevice:
return boost::make_shared<SerialInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::GenericDevice:
return boost::make_shared<GenericInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::AutoFocusDevice:
return boost::make_shared<AutoFocusInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::ImageProcessorDevice:
return boost::make_shared<ImageProcessorInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::SignalIODevice:
return boost::make_shared<SignalIOInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::MagnifierDevice:
return boost::make_shared<MagnifierInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::SLMDevice:
return boost::make_shared<SLMInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::GalvoDevice:
return boost::make_shared<GalvoInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
case MM::HubDevice:
return boost::make_shared<HubInstance>(core, shared_this, name, pDevice, deleter, label, deviceLogger, coreLogger);
default:
deleter(pDevice);
throw CMMError("Device " + ToQuotedString(name) +
" of device adapter " + ToQuotedString(GetName()) +
" has invalid or unknown type (" + ToQuotedString(actualType) + ")");
}
}
MM::DeviceDetectionStatus FocalPointCheckSerialPort(MM::Device& device, MM::Core& core, std::string portToCheck, double answerTimeoutMs)
{
// all conditions must be satisfied...
MM::DeviceDetectionStatus result = MM::Misconfigured;
char answerTO[MM::MaxStrLength];
try
{
std::string portLowerCase = portToCheck;
for( std::string::iterator its = portLowerCase.begin(); its != portLowerCase.end(); ++its)
{
*its = (char)tolower(*its);
}
if( 0< portLowerCase.length() && 0 != portLowerCase.compare("undefined") && 0 != portLowerCase.compare("unknown") )
{
result = MM::CanNotCommunicate;
core.GetDeviceProperty(portToCheck.c_str(), "AnswerTimeout", answerTO);
// device specific default communication parameters
// for ASI Stage
core.SetDeviceProperty(portToCheck.c_str(), MM::g_Keyword_Handshaking, "Off");
core.SetDeviceProperty(portToCheck.c_str(), MM::g_Keyword_StopBits, "1");
std::ostringstream too;
too << answerTimeoutMs;
core.SetDeviceProperty(portToCheck.c_str(), "AnswerTimeout", too.str().c_str());
core.SetDeviceProperty(portToCheck.c_str(), "DelayBetweenCharsMs", "0");
MM::Device* pS = core.GetDevice(&device, portToCheck.c_str());
std::vector< std::string> possibleBauds;
possibleBauds.push_back("9600");
for( std::vector< std::string>::iterator bit = possibleBauds.begin(); bit!= possibleBauds.end(); ++bit )
{
core.SetDeviceProperty(portToCheck.c_str(), MM::g_Keyword_BaudRate, (*bit).c_str() );
pS->Initialize();
core.PurgeSerial(&device, portToCheck.c_str());
// check status
const char* command = "/";
int ret = core.SetSerialCommand( &device, portToCheck.c_str(), command, "\r");
if( DEVICE_OK == ret)
{
char answer[MM::MaxStrLength];
ret = core.GetSerialAnswer(&device, portToCheck.c_str(), MM::MaxStrLength, answer, "\r\n");
if( DEVICE_OK != ret )
{
char text[MM::MaxStrLength];
device.GetErrorText(ret, text);
core.LogMessage(&device, text, true);
}
else
{
// to succeed must reach here....
result = MM::CanCommunicate;
}
}
else
{
char text[MM::MaxStrLength];
device.GetErrorText(ret, text);
core.LogMessage(&device, text, true);
}
pS->Shutdown();
if( MM::CanCommunicate == result)
break;
else
// try to yield to GUI
CDeviceUtils::SleepMs(10);
}
// always restore the AnswerTimeout to the default
core.SetDeviceProperty(portToCheck.c_str(), "AnswerTimeout", answerTO);
}
}
catch(...)
{
core.LogMessage(&device, "Exception in DetectDevice!",false);
}
return result;
}