MityCAM-SDK/html/MityViewerApp_8h_source.html

/*

 *   o  0

 *   | /       Copyright (c) 2012

 *  (CL)---o   Critical Link, LLC

 *    \

*      O

 */

#ifndef SCMOSAPP_H

#define SCMOSAPP_H


#define MAX_NUM_FRAMES_IN_QUEUE         (3)


#include <pthread.h>


#include "CCDspMessages.h"

#include "arm_dsp_msgs.h"

#include "CamParser.h"

#include "Sensors/SensorBoard.h"

#include "Utility/Mutex.h"

#include "CommandHandlers/AllHandlers.h"

#include "IOChannel/IOChannel.h"

#include "CommandInterface/CommandInterface.h"


// forward declarations

class CrcCalc;

namespace SocCamera {

    class tcLegacyCCD;

}


class tcMityViewerApp: public tcIOChannel

{


public:

    tcMityViewerApp(tcSensorBoard *apSensor, tcIOChannel *apChannel,

            uint64 anMaxFramesInQueue = MAX_NUM_FRAMES_IN_QUEUE);

    virtual ~tcMityViewerApp(void);


    int Initialize(tcCommandInterface* apInterface);

    int Shutdown(void);


    virtual void Report(const char* fmt, ...);

    virtual void ReportError(const char* buffer);


    virtual void sendUpdate(tsNewFrameMsg *apMsg);


    void setTECHandler(SocCamera::tcTECHandler *apHandler);


    virtual SocCamera::teNackCode setBpp(

        SocCamera::teBPPMode aeBppMode);


    virtual SocCamera::teNackCode capture(tsCaptureRequest asRequest);


protected:


    static void* DispatchNetworkPoll(void* apThis);

    void NetworkPoll(void);


    static void* DispatchNetworkServer(void* apThis);

    void NetworkServer(void);


    static void* DispatchMainLoop(void* apThis);

    void MainLoop(void);


    static bool DispatchMessageHandler(int anStatus, void* apData,

        int anLength, unsigned int anInfo,

        void* apThis);


    bool MessageHandler(int anStatus, void* apData,

        int anLength, unsigned int anInfo);


    int SendNetworkData(char* data, int len);

    int SendMessage(tsMsgHeader* Msg, int len, void* apPayload = NULL,

        int payload_len = 0);


    const char* MsgToText(unsigned int MsgId);


    typedef void (tcMityViewerApp::*MsgHandler)(tuCameraMessages* apMsg);

    MsgHandler maHandlers[256];


    void WriteConfig(void);


    void Send16BitFrame(tsNewFrameMsg* apMsg);


    void Send32BitFrame(tsNewFrameMsg* apMsg);


        tcImage *mkImage(tsNewFrameMsg* apMsg);


    void SetExposure(tuCameraMessages* msg);

    void SetExposureEx(tuCameraMessages* msg);

    void GetExposure(tuCameraMessages* msg);

    void GetExposureEx(tuCameraMessages* msg);

    void SetCooling(tuCameraMessages* msg);

    void Reset(tuCameraMessages* msg);

    void Clear(tuCameraMessages* msg);

    void ReadArea(tuCameraMessages* msg);

    void SetOffset(tuCameraMessages* msg);

    void SetImageInterval(tuCameraMessages* msg);

    void Loopback(tuCameraMessages* msg);

    void GetHardwareParams(tuCameraMessages* msg);

    void SetHardwareParams(tuCameraMessages* msg);

    void GetCooling(tuCameraMessages* msg);

    void GetSetPoint(tuCameraMessages* msg);

    void SetSetPoint(tuCameraMessages* msg);

    void SetGPIO(tuCameraMessages* msg);

    void GetGPIO(tuCameraMessages* msg);

    void SetTrigger(tuCameraMessages* msg);

    void GetTrigger(tuCameraMessages* msg);

    void SetTriggerMode(tuCameraMessages* msg);

    void GetTriggerMode(tuCameraMessages* msg);

    void SetImageMirrorCfg(tuCameraMessages* msg);

    void GetImageMirrorCfg(tuCameraMessages* msg);

    void GetNetConfig(tuCameraMessages* msg);

    void GetImageIntervals(tuCameraMessages* msg);

    void GetPID(tuCameraMessages* msg);

    void SetPID(tuCameraMessages* msg);

    void GetTimingFileData(tuCameraMessages* msg);

    void AbortRead(tuCameraMessages* msg);

    void CISSetShutterMode(tuCameraMessages* msg);

    void CISCalibrate(tuCameraMessages* msg);

    void CISSetChannelSelect(tuCameraMessages* msg);

    void SetRecordParams(tuCameraMessages* msg);

    void SetFanCtrl(tuCameraMessages* msg);

    void CISGetCalibrationState(tuCameraMessages* msg);

    void SetAreaParam(tuCameraMessages* msg);

    void NoOpCtrl(tuCameraMessages* msg);

    void GetBinParam(tuCameraMessages* msg);

    void SetBinParam(tuCameraMessages* msg);

    void SetSimulationMode(tuCameraMessages* msg);

    void GetSimulationMode(tuCameraMessages* msg);

    void Read32(tuCameraMessages* msg);

    void Write32(tuCameraMessages* msg);

    void GetMultipleROIState(tuCameraMessages* msg);

    void SetMultipleROIState(tuCameraMessages* msg);

    void SetSimpleBinning(tuCameraMessages* msg);

    void GetSimpleBinning(tuCameraMessages* msg);

    void SetParameter(tuCameraMessages* msg);

    void GetParameter(tuCameraMessages* msg);

    void SetHorBinParam(tuCameraMessages* msg);

    void GetHorBinParam(tuCameraMessages* msg);

    void OpComplete(tuCameraMessages* msg);

    void WriteDAC(tuCameraMessages* msg);

    void GetCCDTemp(tuCameraMessages* msg);

    void ReadCCDBin(tuCameraMessages* msg);

    void GetBoardTemp(tuCameraMessages* msg);

    void GetReadoutNoise(tuCameraMessages* msg);

    void WriteNetConfig(tuCameraMessages* msg);

    void SetShutterCloseDel(tuCameraMessages* msg);

    void GetShutterDel(tuCameraMessages* msg);

    void SetBinningSeq(tuCameraMessages* msg);

    void GetBinningSeq(tuCameraMessages* msg);

    void SetGain(tuCameraMessages* msg);

    void GetGain(tuCameraMessages* msg);

    void SetFilter(tuCameraMessages* msg);

    void GetFilter(tuCameraMessages* msg);

    void SetShearCtrl(tuCameraMessages* msg);


    void SendCaptureConfig(void);


    void SendNackCode(teNackCode aeCode, const char *asMessage);


    void Shear(uint16_t* apData, unsigned int rows, unsigned int cols);


    SocCamera::tcTECHandler *mpTECHandler;


    bool mbHasChannel;

    bool mbUseChannel;

        tcSensorBoard *mpSensor;

        tcLegacyCCD   *mpCCD;

        tcIOChannel *mpChannel;

    tcCommandInterface *mpInterface;


    bool mbCalibrated;


    volatile bool mbNetworkActive;

    tcCamParser* mpNetworkParser;

    bool mbConfigChange;

    float mnMean;

    float mnStdDev;

    unsigned int mnAreaIntervalms;

    unsigned int mnDesiredIntervalms;

    unsigned int mnNumAreaRows;

    unsigned int mnNumAreaCols;

    unsigned int mnLoopBackErrorCnt;

    int mnMessageInCount;

    int mnMessageOutCount;

    unsigned short mnFPGARev;

    unsigned short mnDSPRev;

    bool mbConfigValid;

    tsSimulationModeMsg msSimMode;

    volatile bool mbSendHeartBeats;

    int mnSocket;

    CrcCalc* mpCRC;

    tcMutex mhOutputMutex;

    pthread_t mhNetworkSrvThread;

    pthread_t mhNetworkPollThread;

    pthread_t mhMainThread;

    volatile int maShutdownPipes[3 * 2];

    volatile bool mbShutdown;

    tsHdwrParamMsg msHdwrParamMsg;

    tsCaptureConfigMsg msCaptureConfigMsg;

    volatile unsigned int mnMillisecsToGo;

    unsigned int mnFanEnable;

    unsigned int mnTECEnable;

    float mnTargetTemp;

    volatile float mnPID[3];

    float mnCoolingDuty;

    unsigned int mnGpioPinState;

    volatile bool mbDSPShutdown;

    volatile bool mbSendNoOps;

    volatile int mnNoOpCounter;

    volatile int mnMsPerNoOp;


    uint64 mnMaxFramesInQueue;

    bool mbCancelUpdate;


        unsigned int* mp32BitBuffer;

        uint32_t      mn32BitBufferWords;


    static const int gnPacketsPerWrite = 64;

    char** mp16BitHeaders;

    char** mp32BitHeaders;

        struct iovec* mpIOV;

        uint32_t* mpOutputBinning;


    bool mbShear;

    unsigned int mnShearThresh;

    unsigned int mnShearWinX;

    unsigned int mnShearWinY;

        bool mbFlipY;   // Flip image vertically

#ifdef ARM_TEST_PATTERNS

        teTestPattern meTestPattern;

        void buildTestPattern(uint16 *lpData, uint16_t numrows, uint16_t numcols);

#endif

};


#endif