ArduinoFilterWheel.cpp

 //////////////////////////////////////////////////////////////////////////////
// FILE:          ArduinoFilterWheel.cpp
// PROJECT:       Micro-Manager
// SUBSYSTEM:     DeviceAdapters
//-----------------------------------------------------------------------------
// DESCRIPTION:   Adapter for Arduino board
//                Needs accompanying firmware to be installed on the board
//
// AUTHOR:        Shirish Goyal, shirish.goyal@gmail.com 09/14/2016
//
// COPYRIGHT:     Shirish Goyal, BioCurious, Sunnyvale, 2016
//
// LICENSE:       This file is distributed under the BSD license.
//                License text is included with the source distribution.
//
//                This file is distributed in the hope that it will be useful,
//                but WITHOUT ANY WARRANTY; without even the implied warranty
//                of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//
//                IN NO EVENT SHALL THE COPYRIGHT OWNER OR
//                CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//                INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES.

#include "ArduinoFilterWheel.h"
#include "../../MMDevice/ModuleInterface.h"
#include <sstream>
#include <cstdio>

#ifdef WIN32
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>
	#define snprintf _snprintf
#endif

const char* g_DeviceNameArduinoFilterWheelHub = "ArduinoFilterWheel-Hub";
const char* g_DeviceNameArduinoFilterWheel = "ArduinoFilterWheel-FilterWheel";
const char* g_DeviceDescriptionArduinoFilterWheel="Arduino Filter Wheel Driver";
const char* g_versionProp = "Version";

const int g_Min_MMVersion = 0;
const int g_Max_MMVersion = 1;

const char* g_On = "On";
const char* g_Off = "Off";

// static lock
MMThreadLock CArduinoFilterWheelHub::lock_;

///////////////////////////////////////////////////////////////////////////////
// Exported MMDevice API
///////////////////////////////////////////////////////////////////////////////
MODULE_API void InitializeModuleData() {
    RegisterDevice(g_DeviceNameArduinoFilterWheelHub, MM::HubDevice, "Hub (required)");
    RegisterDevice(g_DeviceNameArduinoFilterWheel, MM::StateDevice, "Filter Wheel");
}

MODULE_API MM::Device *CreateDevice(const char *deviceName) {
    if (deviceName == 0)
        return 0;

    if (strcmp(deviceName, g_DeviceNameArduinoFilterWheelHub) == 0) {
        return new CArduinoFilterWheelHub;
    } else if (strcmp(deviceName, g_DeviceNameArduinoFilterWheel) == 0) {
        return new CArduinoFilterWheel;
    }

    return 0;
}

MODULE_API void DeleteDevice(MM::Device *pDevice) {
    delete pDevice;
}
///////////////////////////////////////////////////////////////////////////////

CArduinoFilterWheelHub::CArduinoFilterWheelHub() :
        initialized_(false),
        filterWheelState_(0) {
    portAvailable_ = false;

	InitializeDefaultErrorMessages();

    SetErrorText(ERR_PORT_OPEN_FAILED, "Failed opening Arduino USB device");
    SetErrorText(ERR_BOARD_NOT_FOUND,
                 "Did not find an Arduino board with the correct firmware.  Is the Arduino board connected to this serial port?");
    SetErrorText(ERR_NO_PORT_SET, "Hub Device not found.  The Arduino Hub device is needed to create this device");

    std::ostringstream errorText;
    errorText
            << "The firmware version on the Arduino is not compatible with this adapter.  Please use firmware version ";
    errorText << g_Min_MMVersion << " to " << g_Max_MMVersion;
    SetErrorText(ERR_VERSION_MISMATCH, errorText.str().c_str());

    CPropertyAction *pAct = new CPropertyAction(this, &CArduinoFilterWheelHub::OnPort);
    CreateProperty(MM::g_Keyword_Port, "Undefined", MM::String, false, pAct, true);
}

CArduinoFilterWheelHub::~CArduinoFilterWheelHub() {
    Shutdown();
}

void CArduinoFilterWheelHub::GetName(char *name) const {
	CDeviceUtils::CopyLimitedString(name, g_DeviceNameArduinoFilterWheelHub);
}

bool CArduinoFilterWheelHub::Busy() {
    return false;
}

int CArduinoFilterWheelHub::GetControllerVersion(int &version) {
    int ret = DEVICE_OK;
    //unsigned char command[1];
	std::string answer;

    //command[0] = 1;
    version = 0;

	if(!portAvailable_){
		return ERR_NO_PORT_SET;
	}

    //ret = SendSerialCommand(port_.c_str(), (const char *) command, 1);
    //if (ret != DEVICE_OK)
    //    return ret;

    ret = SendSerialCommand(port_.c_str(), "V", "\r");
	if (ret != DEVICE_OK)
	  return ret;

	ret = GetSerialAnswer(port_.c_str(), "\r", answer);
	if (ret != DEVICE_OK) {
	  return ret;
	}

	LogMessage("Found Board", false);
	LogMessage(answer, false);

    if (answer != "ArduinoFilterWheel" && answer != "\nArduinoFilterWheel") {
      return ERR_BOARD_NOT_FOUND;
    }
    
	version = 1; 
    return ret;
}

int CArduinoFilterWheelHub::WriteToComPortH(const char* command, size_t len)
    {
		int ret = DEVICE_OK;
	std::string answer;

	ret = SendSerialCommand(port_.c_str(), (const char *)command, "\r");
	return ret;
    }

bool CArduinoFilterWheelHub::SupportsDeviceDetection(void) {
    return true;
}

MM::DeviceDetectionStatus CArduinoFilterWheelHub::DetectDevice(void) {
    if (initialized_)
        return MM::CanCommunicate;

    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, g_Off);
            GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_BaudRate, "9600");
            GetCoreCallback()->SetDeviceProperty(port_.c_str(), MM::g_Keyword_StopBits, "1");
            // Arduino timed out in GetArduinoVersion even if AnswerTimeout  = 300 ms
            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 firmware upgrades.
            // Simply sleep 2 seconds.
            CDeviceUtils::SleepMs(2000);

            MMThreadGuard myLock(lock_);
            PurgeComPort(port_.c_str());

            int v = 0;
            int ret = GetControllerVersion(v);

            // later, Initialize will explicitly check the version #
            if (DEVICE_OK != ret) {
                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 Detect Device!", false);
    }

    return result;
}

int CArduinoFilterWheelHub::Initialize() {
    // Name
   int ret = CreateProperty(MM::g_Keyword_Name, g_DeviceNameArduinoFilterWheelHub, MM::String, true);
   if (DEVICE_OK != ret)
      return ret;

   LogMessage("Initializing Filter Wheel", false);

   // The first second or so after opening the serial port, the Arduino is waiting for firmwareupgrades.  Simply sleep 1 second.
   CDeviceUtils::SleepMs(2000);

   MMThreadGuard myLock(lock_);

   // Check that we have a controller:
   PurgeComPort(port_.c_str());

   ret = GetControllerVersion(version_);
   if( DEVICE_OK != ret)
      return ret;

   if (version_ < g_Min_MMVersion || version_ > g_Max_MMVersion)
       return ERR_VERSION_MISMATCH;

   CPropertyAction* pAct = new CPropertyAction(this, &CArduinoFilterWheelHub::OnVersion);
   std::ostringstream sversion;
   sversion << version_;
   CreateProperty(g_versionProp, sversion.str().c_str(), MM::Integer, true, pAct);
   ret = UpdateStatus();
   if (ret != DEVICE_OK)
      return ret;

   // turn on verbose serial debug messages
   GetCoreCallback()->SetDeviceProperty(port_.c_str(), "Verbose", "1");

   initialized_ = true;
   return DEVICE_OK;
}

int CArduinoFilterWheelHub::DetectInstalledDevices()
{
   if (MM::CanCommunicate == DetectDevice()) 
   {
      std::vector<std::string> peripherals; 

      peripherals.clear();
      peripherals.push_back(g_DeviceNameArduinoFilterWheel);

      for (size_t i=0; i < peripherals.size(); i++) 
      {
         MM::Device* pDev = ::CreateDevice(peripherals[i].c_str());
         if (pDev) 
         {
             AddInstalledDevice(pDev);
         }
      }
   }

   return DEVICE_OK;
}

int CArduinoFilterWheelHub::Shutdown() {
	LogMessage("Shutdown", false);
   initialized_ = false;
   return DEVICE_OK;
}

int CArduinoFilterWheelHub::OnPort(MM::PropertyBase *pProp, MM::ActionType eAct) {
	LogMessage("On Port", false);

    if (eAct == MM::BeforeGet) {
        pProp->Set(port_.c_str());
    } else if (eAct == MM::AfterSet) {
        pProp->Get(port_);
		portAvailable_ = true;
    }

    return DEVICE_OK;
}

int CArduinoFilterWheelHub::OnVersion(MM::PropertyBase* pProp, MM::ActionType pAct)
{
	LogMessage("On Version", false);
   if (pAct == MM::BeforeGet)
   {
      pProp->Set((long)version_);
   }
   return DEVICE_OK;
}

///////////////////////////////////////////////////////////////////////////////
// CArduinoFilterWheel implementation
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~

CArduinoFilterWheel::CArduinoFilterWheel() : 
	busy_(false),
	initialized_(false), 
	name_(g_DeviceNameArduinoFilterWheel),
	changedTime_(0.0),
    position_(6),
	numPos_(7)
{
   InitializeDefaultErrorMessages();
   EnableDelay();

   SetErrorText(ERR_NO_PORT_SET, "Hub Device not found.  The ArduinoFilterWheel Hub device is needed to create this device");

   // Name
   int ret = CreateProperty(MM::g_Keyword_Name, g_DeviceNameArduinoFilterWheel, MM::String, true);
   assert(DEVICE_OK == ret);

   // Description
   ret = CreateProperty(MM::g_Keyword_Description, g_DeviceDescriptionArduinoFilterWheel, MM::String, true);
   assert(DEVICE_OK == ret);

   // parent ID display
   CreateHubIDProperty();
}

CArduinoFilterWheel::~CArduinoFilterWheel() {
	LogMessage("Destructor", false);
    Shutdown();
}

void CArduinoFilterWheel::GetName(char *Name) const {
    CDeviceUtils::CopyLimitedString(Name, g_DeviceNameArduinoFilterWheel);
}

bool CArduinoFilterWheel::Busy() {
	LogMessage("Busy", false);
	return busy_;
    //MM::MMTime interval = GetCurrentMMTime() - changedTime_;
    //MM::MMTime delay(GetDelayMs() * 1000.0);
    //return (interval < delay);
}

int CArduinoFilterWheel::Initialize() {
	LogMessage("Initialize FW", false);
   CArduinoFilterWheelHub* hub = static_cast<CArduinoFilterWheelHub*>(GetParentHub());
   if (!hub || !hub->IsPortAvailable()) {
	  LogMessage("Port failed for Filter Wheel", true);
      return ERR_NO_PORT_SET;
   }
   char hubLabel[MM::MaxStrLength];
   hub->GetLabel(hubLabel);
   SetParentID(hubLabel); // for backward comp.

    // set property list
    // -----------------

    // Set timer for the Busy signal, or we'll get a time-out the first time we check the state of the shutter, for good measure, go back 'delay' time into the past
    //changedTime_ = GetCurrentMMTime();
   LogMessage("Set Positions FW", false);
    // create default positions and labels
    const int bufSize = 64;
    char buf[bufSize];

	snprintf(buf, bufSize, "Cy3");
    SetPositionLabel(1, buf);

	snprintf(buf, bufSize, "TxRed");
    SetPositionLabel(2, buf);

	snprintf(buf, bufSize, "Cy5");
    SetPositionLabel(3, buf);

	snprintf(buf, bufSize, "Mirror");
    SetPositionLabel(4, buf);

	snprintf(buf, bufSize, "Empty");
    SetPositionLabel(5, buf);

	snprintf(buf, bufSize, "Fitc");
    SetPositionLabel(6, buf);

	// add Stop Position
    snprintf(buf, bufSize, "Stop");
    SetPositionLabel(0, buf);

    // add Home Position   **&*&*&&*&*&*  TODO: HOME  position value *^^*^*^*^^
    //snprintf(buf, bufSize, "Home");
    //SetPositionLabel(5, buf);

    //for (unsigned long i = 1; i <= numPos_; i++) {
    //    snprintf(buf, bufSize, "Filter %d", i);
    //    SetPositionLabel(i, buf);
    //}

    // State
    // -----
	CPropertyAction *pAct = new CPropertyAction(this, &CArduinoFilterWheel::OnState);
    int ret = CreateProperty(MM::g_Keyword_State, "State", MM::Integer, false, pAct);
    if (ret != DEVICE_OK)
        return ret;
	SetPropertyLimits(MM::g_Keyword_State, 0, numPos_- 1);

    // Label
    // -----
    pAct = new CPropertyAction(this, &CStateBase::OnLabel);
    ret = CreateProperty(MM::g_Keyword_Label, "", MM::String, false, pAct);
    if (ret != DEVICE_OK)
        return ret;
    
    ret = UpdateStatus();
    if (ret != DEVICE_OK)
        return ret;

    initialized_ = true;
    return DEVICE_OK;
}

int CArduinoFilterWheel::Shutdown() {
    if (initialized_) {
        initialized_ = false;
    }

    return DEVICE_OK;
}

int CArduinoFilterWheel::OnState(MM::PropertyBase *pProp, MM::ActionType eAct) {
	const int bufSize = 128;
    char msg[bufSize];
	long pos;

	CArduinoFilterWheelHub* hub = static_cast<CArduinoFilterWheelHub*>(GetParentHub());
    if (!hub || !hub->IsPortAvailable())
      return ERR_NO_PORT_SET;

    if (eAct == MM::BeforeGet) {
        pProp->Set((long)position_);

        // nothing to do, let the caller to use cached property
    } else if (eAct == MM::AfterSet) {

        // Set timer for the Busy signal
        changedTime_ = GetCurrentMMTime();

        pProp->Get(pos);

        //char* deviceName;
        //GetName(deviceName);

        //if (pos >= numPos_ || pos < 0) {
		//	LogMessage("Invalid position - reverting",false);
        //    pProp->Set(pos); // revert
        //    //return ERR_UNKNOWN_POSITION;
        //}

		snprintf(msg, bufSize, "Moving to %d", pos);
        LogMessage(msg,false);

        const int bufSize = 16;
        char buf[bufSize];
        snprintf(buf, bufSize, "%d", pos);

        //SendSerialCommand(port_.c_str(), buf, "\r");
        position_ = pos;

		hub->SetFilterWheelState(pos);
		if (hub->GetFilterWheelState() >= 0){
			snprintf(msg, bufSize, "New %d", position_);
			LogMessage(msg,false);
			return hub->WriteToComPortH((const char*)buf, bufSize);
		}
		
    }

    return DEVICE_OK;
}