WPScanController.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <atomic>
#include <vector>
#include <iostream>
#include <fstream>
#include <mutex>
//#include <OCTTypeDefs.h>
 
#include "IWPOCTController.h"
#include "Serial.h"
 
// Forward class declarations.
class SimpleTimer;
class ShutterDevice;
class CallbackInfo;
 
using namespace std;
 
class WPScanController : public IWPOCTController
{
public:
    WPScanController();
 
    virtual ~WPScanController();
 
    // Events
 
    // Getters
 
    bool    IsPortOpen      () const override               { return _portOpen; }
 
    bool    IsLightOn       (int index) override;
    bool    IsScanning      () const override               { return _isScanning; }
 
    int     GetBaudRate     () const override               { return _baudRate; }
    int     GetNumStopBits  () const override               { return _numStopBits; }
    int     GetPortTimeout  () const override               { return _portTimeout; }
    bool    GetMonitorPort  () const override               { return _monitorConnection; }
    bool    GetReadResponse () const override               { return _readResponse; }
    const char* GetVersion  () const override               { return _version.c_str(); }
 
    int     GetAScans       () const override               { return _aScans; }
    int     GetBScans       () const override               { return _bScans; }
    int     GetFoci         () const override               { return _foci; }
    int     GetDelay        () const override               { return _delay; }
    int     GetPulse        () const override               { return _pulse; }
    int     GetPhase        () const override               { return _phase; }
    int     GetArmPosition  () const override               { return _pathMotorPos; }
    void    GetScanArea     (int* xStart, int* xStop, int* yStart, int* yStop) const override;
    void    GetMirror       (int* major, int* minor) const override;
    bool    GetSwapXY       () const override               { return _swapXY; }
 
    const char* GetPortName () override;
 
    const char* GetLastCommandSent  () const override;
    const char* GetLastResponse     () const override;
 
    // Get the min max ramp values.
    int     GetXRampMinPos() const override { return _minXRampPos; }
    int     GetXRampMaxPos() const override { return _maxXRampPos; }
    int     GetYRampMinPos() const override { return _minYRampPos; }
    int     GetYRampMaxPos() const override { return _maxYRampPos; }
 
    int     GetXRampStartPos() const override { return _xRampStartPos; }
    int     GetXRampStopPos () const override { return _xRampStopPos; }
    int     GetYRampStartPos() const override { return _yRampStartPos; }
    int     GetYRampStopPos () const override { return _yRampStopPos; }
 
    // Get max values.
    int     GetPathMotorPosMax      () const override { return _pathMotorPosMax; }
    int     GetQuarterHalfWavePosMax() const override { return _quarterHalfWavePosMax; }
 
    // Setters
    bool    SetAScans   (int value) override;
    bool    SetBScans   (int value) override;
    bool    SetFoci     (int value) override;
    bool    SetDelay    (int value) override;
    bool    SetPulse    (int value) override;
    bool    SetPhase    (int value) override;
    
    // Set the min max ramp values.
    bool    SetXRampMinPos(int value) override;
    bool    SetXRampMaxPos(int value) override;
    bool    SetYRampMinPos(int value) override;
    bool    SetYRampMaxPos(int value) override;
 
    // Position the reference arm at the specified location.
    bool    SetArmPosition  (int position) override;
    bool    SetScanArea     (int xStart, int xStop, int yStart, int yStop) override;
    bool    SetScanArea     (int xStart, int xStop, int yStart, int yStop, int numPasses) override;
    bool    SetMirror       (int major, int minor) override;
    bool    SetSwapXY       (bool value) override           { _swapXY = value; return true; }
    bool    SetReadResponse (bool value) override           { _readResponse = value; return true; }
 
    // Set max values.
    bool    SetPathMotorPosMax      (int value) override { _pathMotorPosMax = value; return true; }
    bool    SetQuarterHalfWavePosMax(int value) override { _quarterHalfWavePosMax = value; return true; }
 
    // Serial port commands.
    
    bool    OpenPort    (const char* portName, int baudRate, int numStopBits,
                            int timeout, bool monitorConnection) override;
    bool    OpenPort    (int baudRate, int numStopBits, int timeout, bool monitorConnection) override;
    bool    OpenPort    () override;
 
    void ReadControllerVersion(bool &result);
 
    bool    ClosePort   () override;
 
    bool    SendCommand (const char* command, char* response, int maxResponseSize) override;
    bool    SendCommand (const char* command) override;
 
    // Scanner commands.
 
    // Light commands.
    bool    TurnLightOn     (int num) override;
    bool    TurnLightOff    (int num) override;
    bool    TurnLightsOff   () override;
 
    bool    StartScan       () override;
    bool    StopScan        () override;
 
    bool    ParkArm         () override;
 
    bool    SendMotorsHome  () override;
 
    // Optical switch commands.
    int     GetActiveOpticalPort    () override;
    bool    SetActiveOpticalPort    (int port) override;
    bool    ToggleOpticalSwitch     () override;
 
    // Shutter commands.
    bool    IsShutterOpen   (int ID, bool* open) override;
    bool    OpenShutter     (int ID) override;
    bool    CloseShutter    (int ID) override;
 
    // Status
    virtual IWPOCTController::ErrorCode     GetLastError    () const override   { return _lastError; }
    virtual IWPOCTController::CurrentStates GetCurrentStatus() const override   { return _currentStatus; }
 
    virtual void    SetSerialPortLostCallback   (NotifyErrorCallback notifyError) override;
    virtual void    SetSerialPortLostCallback2  (SendNoParams serialPortLost, void* context) override;
 
    void    CheckPingResponse   ();
 
protected:
    const int PathMotorSpeedMax         = 2900;
    const int QuarterHalfWaveSpeedMax   = 10000;
    const int PathMotorAccelMax         = 10000;
    const int QuarterHalfWaveAccelMax   = 10000;
 
    bool    SendStringToWasatchPort (std::string rawCommand);
    bool    SendStringToCameraPort  (std::string rawCommand);
    bool    SendCommandToPort       (std::string command);
    bool    SendShutterCommand      (std::string& inCommand);
 
    void    ReadResponse            (std::string &finalCommand);
 
    bool    CheckWasatchCommandValid(std::string& inCommand, std::string& outCommand);
    bool    CheckCameraCommandValid (std::string& inCommand, std::string& outCommand);
 
    bool    ChangePortMonitoring    (bool isOn);
    bool    ReestablishConnection   ();
    void    FormatVersionString     ();
 
    bool    FormAScansCmd       (vector<std::string>& words, string& outCommand);
    bool    FormBScansCmd       (vector<std::string>& words, string& outCommand);
 
    bool    FormDelayCmd        (vector<std::string>& words, string& outCommand);
    bool    FormPulseCmd        (vector<std::string>& words, string& outCommand);
    bool    FormPhaseCmd        (vector<std::string>& words, string& outCommand);
    bool    FormFociCmd         (vector<std::string>& words, string& outCommand);
    bool    FormFocusCmd        (vector<std::string>& words, string& outCommand);
    bool    FormScanCmd         (vector<std::string>& words, string& outCommand);
    bool    FormMirrorCmd       (vector<std::string>& words, string& outCommand);
    bool    FormVerboseCmd      (vector<std::string>& words, string& outCommand);
    bool    FormPauseTimeoutCmd (vector<std::string>& words, string& outCommand);
    bool    FormSetOpticalPortCmd(vector<std::string>& words, string& outCommand);
 
    bool    FormMghCmd      (vector<std::string>& words, string& outCommand);
    bool    FormMstopCmd    (vector<std::string>& words, string& outCommand);
    bool    FormMgrCmd      (vector<std::string>& words, string& outCommand);
    bool    FormMg2Cmd      (vector<std::string>& words, string& outCommand);
    bool    FormMihCmd      (vector<std::string>& words, string& outCommand);
    bool    FormMasetCmd    (vector<std::string>& words, string& outCommand);
    bool    FormMssetCmd    (vector<std::string>& words, string& outCommand);
    bool    FormCameraCommand(vector<std::string>& words, string& outCommand);
 
    bool    RunSetShutterCmd(vector<std::string>& words);
    bool    RunGetShutterCmd(vector<std::string>& words, bool& open);
 
    int     CheckMotorPosLimits     (vector<std::string>& words);
    int     CheckRelativeMotorPosLimits(vector<std::string>& words);
    int     CheckMotorAccelLimits   (vector<std::string>& words);
    int     CheckMotorSpeedLimits   (vector<std::string>& words);
    void    RecordMotorPos          (std::vector<std::string> & words, int pos);
    void    RecordRelativeMotorPos  (std::vector<std::string> & words, int relativePos);            
 
    bool    FormPrampCmd    (vector<std::string>& words, string& outCommand);
    bool    FormXYRampCmd   (vector<std::string>& words, string& outCommand);
    bool    FormXRampCmd    (vector<std::string>& words, string& outCommand);
    bool    FormYRampCmd    (vector<std::string>& words, string& outCommand);
 
    bool    FormOut1Cmd     (vector<std::string>& words, string& outCommand);
    bool    FormOut2Cmd     (vector<std::string>& words, string& outCommand);
 
    bool    FormTRetCmd         (vector<std::string>& words, string& outCommand);
    bool    FormTriggerCmd      (vector<std::string>& words, string& outCommand);
    bool    FormTrigDelayModeCmd(vector<std::string>& words, string& outCommand);
    bool    FormTrigDelayCmd    (vector<std::string>& words, string& outCommand);
    bool    FormADivCmd         (vector<std::string>& words, string& outCommand);
    bool    FormAHoldCmd        (vector<std::string>& words, string& outCommand);
    bool    FormBHoldCmd        (vector<std::string>& words, string& outCommand);
    bool    FormRRampCmd        (vector<std::string>& words, string& outCommand);
    bool    FormRotCrossCmd     (vector<std::string>& words, string& outCommand);
 
private:
    const        int MinRadialScanRadius = 10;
    static const int MaxShutterDevices = 4;
 
    std::atomic<IWPOCTController::ErrorCode>        _lastError;
    std::atomic<IWPOCTController::CurrentStates>    _currentStatus;
 
    CSerial*                    _serialPort;
    std::string                 _portName; 
    std::string                 _version; 
    std::string                 _finalCommand;
    std::string                 _commandResponse;
    std::string                 _pingCommandResponse;
    std::vector<std::string>    _commandsToIssue;
    std::mutex                  _serialPortMutex;
    SimpleTimer*                _monitorTimer;
    ShutterDevice*              _shutterDevices[MaxShutterDevices];
 
    bool        _portOpen;
    bool        _openPortIfNeeded;
    bool        _isInitializing;
    bool        _isExiting;
 
    std::atomic<bool>   _swapXY;
    std::atomic<bool>   _isScanning;
    std::atomic<bool>   _readResponse;
 
    int         _portReadDelay;
    int         _baudRate;
    int         _numStopBits;
    int         _portTimeout;
    bool        _monitorConnection;
 
    // Default limits of sweep.
    int         _minXRampPos;
    int         _maxXRampPos;
    int         _minYRampPos;
    int         _maxYRampPos;
 
    // Actual sweep values.
    int         _xRampStartPos;
    int         _xRampStopPos;
    int         _yRampStartPos;
    int         _yRampStopPos;
 
    int         _numScans;
    int         _opticalPort;
    int         _aScans;
    int         _bScans;
    int         _delay;
    int         _verbose;
    int         _pulse;
    int         _phase;
    int         _ptimeout;
    int         _foci;
    int         _focus;
    int         _mirrorMajor;
    int         _mirrorMinor;
    int         _tRet;
    int         _trigger;
    int         _trdMode;
    int         _trDelay;
    int         _aDiv;
    int         _aHold;
    int         _bHold;
    int         _shutterSerialNum;
    int         _shutterOpenClose;
 
    // Motor positions.
    int         _pathMotorPos;
    int         _quarterMotorPos;
    int         _halfMotorPos;
 
    // Max values set by user.
    int         _pathMotorPosMax;
    int         _quarterHalfWavePosMax;
 
    SendNoParams                _serialPortLostNotify;
    void*                       _serialPortLostNotifyContext;
    NotifyErrorCallback         _notifyErrorCallback;
 
    void    Init                ();
    void    InitShutters        ();
 
    void    Sleep               (int ms);
    bool    InitMotors          ();
    void    SendCommandsToGalvo ();
    void    AddCommand          (std::string command);
    bool    WordIsMotorRef      (string& input);
    bool    WordStandsForAll    (string& input);
    void    SetStatusFlags      (string& command);
    bool    SendCommand         (string& command);
 
    int     SetWithinMinMax             (string& input, int minValue, int maxValue);
    int     SetWithinMinMax             (int input, int minValue, int maxValue);
    int     SetWithinPathMotorMinMax    (string& input, int minValue, int maxValue);
    int     SetWithinQuarterMotorMinMax (string& input, int minValue, int maxValue);
    int     SetWithinHalfMotorMinMax    (string& input, int minValue, int maxValue);
    int     SetRRampRadius              (string& radius, int centerX, int centerY);
 
    int     SetXRampStart       (int value);
    int     SetXRampStop        (int value);
    int     SetYRampStart       (int value);
    int     SetYRampStop        (int value);
 
    bool    ParseBool           (string& input);
    int     ParseInteger        (string& input);
    double  ParseDouble         (string& input);
 
    ShutterDevice*  GetOrCreateShutterDevice(int serialNum);
    void            DeleteShutterDevices();
 
    void            OutputDebugMsg          (const char* str)
    {
#ifdef _DEBUG
        // Only call OutputDebugString when in debug as this call has some overhead.
        OutputDebugStringA( str );
#endif
    }
 
};
 
static void MonitorTimer_Tick(CallbackInfo *pInfo);