include/FCam/F2/Lens.h

Go to the documentation of this file.

#ifndef EF232LENS_H
#define EF232LENS_H

#include "../Lens.h"
#include "../TSQueue.h"
#include "../CircularBuffer.h"

#include <string>

#include "EF232LensDatabase.h"

namespace FCam { namespace F2 {

    class Lens: public FCam::Lens {
 
      public:
    Lens(const std::string &tty_ = "/dev/ttyS2");
    ~Lens();
   
    void setFocus(float diopters, float speed = -1);
    float getFocus();
    float farFocus();
    float nearFocus();
    bool focusChanging();
    int focusLatency();

    float minFocusSpeed();
    float maxFocusSpeed();
    
    void setZoom(float focal_length_mm, float speed = -1);
    float getZoom();
    float minZoom();
    float maxZoom();
    bool zoomChanging();
    int zoomLatency();
    float minZoomSpeed();
    float maxZoomSpeed();
    
    void setAperture(float f_number, float speed = -1);
    float getAperture();
    float wideAperture(float focal_length_mm = -1);
    float narrowAperture(float focal_length_mm = -1);
    bool apertureChanging();
    int apertureLatency();
    float minApertureSpeed();
    float maxApertureSpeed();
    
    void tagFrame(FCam::Frame);

    enum LensState {
        NotInitialized,
        NoLens,
        Ready,
        MovingFocus,
        MovingAperture,
        Busy
    };

    LensState getState();
    void reset();

    // Lens errors
    struct LensError {
        enum e {
        None=0,
        UnrecognizedCommand=1,
        LensIsManualFocus=2,
        NoLensConnected=3,
        LensDistanceStopError=4,
        ApertureNotInitialized=5,
        InvalidBaudRate=6,
        Reserved1=7,
        Reserved2=8,
        BadParameter=9,
        XModemTimeout=10,
        XModemError=11,
        XModemUnlockCodeIncorrect=12,
        NotUsed1=13,
        InvalidPort=14,
        LicenseUnlockFailure=15,
        InvalidLicenseFile=16,
        InvalidLibraryFile=17,
        Reserved3=18,
        Reserved4=19,
        NotUsed2=20,
        LibraryNotReadyForLens=21,
        LibraryNotReadyForCmds=22,
        CommandNotLicensed=23,
        InvalidFocusRange=24,
        DistanceStopsNotSupported=25,
        UnknownError=99
        };
    };
    
      private:
    const std::string tty;
    int serial_fd;

    EF232LensDatabase lensDB;
    
    const EF232LensInfo *currentLens;
    
    // Current lens state
    pthread_mutex_t stateMutex;
    LensState state;
    void setState(LensState newState);

    struct LensParams {
        Time time;
        unsigned int focalLength; // mm
        unsigned int aperture;    // 10x f-number
        unsigned int focusDist;   // encoder counts
    };
    CircularBuffer<LensParams> lensHistory;

    int calcFocusDistance(const Time &t) const;
    int calcAperture(const Time &t) const;
    int calcFocalLength(const Time &t) const;

    // Encoder->diopter conversion
    unsigned int focusEncoderMax;
    float diopScaleFactor;

    float encToDiopter(unsigned int encoder);
    unsigned int diopToEncoder(float diopters);

    enum LensCmd {
        Initialize,
        Calibrate,
        SetAperture,
        SetFocus,
        Shutdown
    };

    struct LensOrder {
        LensCmd cmd;
        unsigned int val;
    };

    TSQueue<LensOrder> cmdQueue;

    // Lens control thread
    pthread_t controlThread;
    bool controlRunning;
    void launchControlThread();
    void runLensControlThread();

    static void *lensControlThread(void *arg);                  

    // High-level lens control functions

    void init();
    void calibrateLens();

    void idleProcessing();

    // Individual command methods

    // Shared buf for parsing
    std::string buf;

    std::string cmd_GetID();
    unsigned int cmd_GetFocalLength(std::string idStr="");
    unsigned int cmd_GetMinAperture(std::string idStr="");

    void cmd_GetZoomRange(unsigned int &min,
                  unsigned int &max);
    void cmd_GetFocusBracket(unsigned int &min,
                 unsigned int &max);
    unsigned int cmd_GetFocusEncoder();

    void cmd_SetFocusEncoder(unsigned int val);

    LensError::e cmd_DoInitialize();

    unsigned int cmd_DoApertureOpen();
    unsigned int cmd_DoAperture(unsigned int val);
    unsigned int cmd_DoApertureClose();

    void cmd_DoFocusAtZero();
    unsigned int cmd_DoFocus(unsigned int val);
    void cmd_DoFocusAtInf();

   
    // Basic communication functions
    void send(const std::string&);
    template<typename T>
    void read(T &val);
    void expect(const std::string& desired);
    void expect(const std::string& desired, std::string& remainder);
    LensError::e errorCheck(std::string &remainder);
    };

    }
}

#endif