SensorBoard.h

Go to the documentation of this file.

#ifndef SENSORBOARD_H
#define SENSORBOARD_H
 
#include <cstdlib>
#include <string>
#include <map>
#include <list>
#include <vector>
#include <unordered_map>
#include <chrono>
// support for libsensors
#include <sensors/sensors.h>
 
 
#include "CameraTypes.h"
#include "Utility/Mutex.h"
#include "libdaq/gpio.h"
#include "libdaq/ad741x.h"
#include "Utility/PeekPokeTypes.h"
#include "Utility/Types.h"
#include "Utility/RAMStreamer.h"
#include "Utility/SIMRAMStreamer.h"
#include "libfpga/timestamp.h"
#include "Utility/PollingInterruptThread.h"
#include "Utility/Observer.h"
#include "Utility/Observable.h"
 
#include "StatusReporter/StatusReporter.h"
#include "IOChannel/IOCallback.h"
#include "IOChannel/Image.h"
 
namespace SocCamera
{
 
class tcVoltageSensor;
class tcTemperatureSensor;
 
class tcAbstractHandler;
 
class tcSensorBoard: public tcObserver, public MityDSP::tcGpio::Observer
{
public:
    tcSensorBoard(int aeType, uint32 anStreamAddr, int32 length, int32 *aaGpioNum);
 
    tcSensorBoard(int aeType, uint32_t anFpgaBaseAddr, uint32_t anRamStreamAddr, int32 length, int32 *aaGpioNum);
 
    virtual ~tcSensorBoard();
 
    int id();
 
    int32 init();
 
    virtual tcAbstractHandler* getCustomHandlers(tcAbstractHandler* apTailHandler, std::map<std::string, tcAbstractHandler*> *apStringMap);
 
    virtual void resetFpga();
 
    virtual uint64_t fpgaVersion();
 
    virtual int GetCameraInfo(tsCameraInfo* apInfo) = 0;
 
    virtual void update(tsUpdate asMessage);
 
    virtual teNackCode calibrate();
 
    virtual teNackCode whiteLevelCalibrate();
 
    virtual teNackCode setClockSetting(int32 anSetting);
 
    virtual teNackCode getClockSetting(int32 &arSetting);
 
    virtual void snap(tsCaptureRequest asSnapRequest);
 
    virtual int32 initialize() = 0;
 
    virtual teNackCode setExposure(int32 anMicroseconds, uint32_t anExpIndex = 0) = 0;
    teNackCode setExposure(std::chrono::microseconds anMicroseconds, uint32_t anExpIndex = 0) { return setExposure(static_cast<int32>(anMicroseconds.count()), anExpIndex); }
 
    virtual int32 getExposure(uint32_t anExpIndex = 0) = 0;
 
    virtual uint32 getMinFrameIntervalMicroS() { return 1000; }
    std::chrono::microseconds getMinFrameInterval() { return std::chrono::microseconds{ getMinFrameIntervalMicroS() }; }
 
    virtual teNackCode setFrameInterval(int32 anMicroseconds) = 0;
    teNackCode setFrameInterval(std::chrono::microseconds anMicroseconds) { return setFrameInterval(static_cast<int32>(anMicroseconds.count())); }
 
    virtual int32 getFrameInterval() = 0;
 
    virtual teNackCode setROI(ROI region) = 0;
 
    virtual ROI getROI() = 0;
 
    virtual ROI getImageROI() { return this->getROI(); }
 
    virtual teNackCode setVerticalBin(int32 anPixels) = 0;
 
    virtual int32 getVerticalBin() = 0;
 
    virtual teNackCode setHorizontalBin(int32 anPixels) = 0;
 
    virtual int32 getHorizontalBin() = 0;
 
    virtual teNackCode setShutterMode(teShutterMode eeMode) = 0;
 
    virtual int32 getShutterMode() = 0;
 
    virtual teNackCode setBPP(teBPPMode eeMode) = 0;
 
    virtual teNackCode setColor(bool /*abColor*/) { return eeNoError; }
 
    virtual teNackCode setTestPattern(teTestPattern eeSelection) = 0;
 
    virtual int32 getTestPattern() = 0;
 
    virtual teNackCode setTrigger(teTriggerMode eeTrigger) = 0;
 
    virtual int32 getTrigger() = 0;
 
    virtual teNackCode peek(int32 anRegister, int* apValue);
 
    virtual teNackCode poke(int32 anRegister, int32 anValue);
 
    virtual int32 validate() = 0;
 
    virtual bool isCapturing() = 0;
 
    virtual teNackCode start() = 0;
 
    virtual teNackCode stop() = 0;
 
    virtual std::string getTemperature(int32 anSensor = 0) = 0;
 
    virtual float getTempCelsius();
 
    virtual float getBoardTempCelsius();
 
    virtual std::string getVersion() = 0;
 
    virtual teNackCode save(int32 anConfiguration) = 0;
 
    virtual teNackCode recall(int32 anConfiguration) = 0;
 
    // GPIO functions can be handled abstractly from the rest of the sensor board...
    //     If they are done in sysfs.
 
    virtual teNackCode setIODirection(int32 anPin, int32 anDirection);
 
    virtual teNackCode setIOValue(int32 anPinNum, int32 anValue);
 
    virtual teNackCode setIOInverter(int32 anPinNum, int32 anInvertEnable);
 
    virtual teNackCode power(bool abOn);
 
    virtual int32 getIODirection();
 
    virtual int32 getIOValue();
 
    virtual int32 getNumPins();
 
    virtual teNackCode setMirroring(bool isX, bool Enabled) { return eeOperationNotSupported; }
 
    virtual teNackCode getMirroring(bool isX, bool* Enabled) { return eeOperationNotSupported; }
 
    virtual teNackCode setNoiseReduct(bool enHi, uint16_t threshhi,
                      bool enLo, uint16_t threshlo)
    {
        return eeOperationNotSupported;
    }
    
    virtual teNackCode getNoiseReduct(bool & enHi, uint16_t & threshhi,
                      bool & enLo, uint16_t & threshlo)
    {
        return eeOperationNotSupported;
    }
 
    virtual teNackCode setSqrtCompression(bool enable) { return eeOperationNotSupported; }
 
    virtual teNackCode getSqrtCompression(bool & enable) { return eeOperationNotSupported; }
 
    virtual teNackCode setDemoMode(int32 anMode) { return eeOperationNotSupported; }
 
    virtual teNackCode getDemoMode(int32 &arMode) { return eeOperationNotSupported; }
 
    virtual teNackCode loadColumnBias(const char *asFilename) { return eeOperationNotSupported; }
 
    virtual teNackCode loadColumnGain(const char *asFilename) { return eeOperationNotSupported; }
 
    virtual teNackCode loadPixelCal(const char *asFilename) { return eeOperationNotSupported; }
 
    // Constant variables:
    static const std::string NO_TEMPERATURE_SENSOR;
    static const std::string TEMPERATURE_SENSOR_ERROR;
 
    virtual tcRAMStreamer *getStreamer();
 
    virtual tcTimestamp *getTimestamper();
 
    virtual void setTimestamper(tcTimestamp *apStamper);
 
    virtual tcSensorBoard* self();
 
    uint32 getFrameSizeBytes();
 
    int getSysIdNumber(unsigned short &major, unsigned short &minor);
 
    uint32 getMaxImgCount();
 
    uint32 getNumSnapFramesLeft();
 
    virtual void Handler(unsigned int gpionum, unsigned int val);
 
    virtual uint32 getPixelFormat(void);
 
    virtual tcVoltageSensor *getVoltageSensor() { return nullptr;}
    virtual tcTemperatureSensor *getTempSensor() { return nullptr;}
 
    virtual void runPeriodic() {}
 
    virtual int32_t getSensorWidth() {return 0;}
 
    virtual int32_t getSensorHeight() {return 0;}
 
protected:
    void nextRequest();
 
    void initGpios(int32 length, int32 *aaGpioNum);
 
    virtual uint32 GetSkipFrames(bool &reload) { reload = false; return 0; }
 
    uint32 ConvertPixelFormat(uint32 anFormat, bool abFlipX, bool abFlipY);
 
    teNackCode GetA10BoardTemp(uint32 anIndex, float& anTemp);
 
    bool mbIsPowered;
 
    // Mutex to use for thread safety when multiple command handlers may be present.
    //    Just put at the top of the function tcMutexLocker locker(&mhMutex);
    tcMutex mhMutex;
 
    MityDSP::tcGpio *mpCamIO;
    MityDSP::tcGpio::PinConfig *maPinConfigs;
    int32 mnPinCount;
 
    tcRAMStreamer *mpStreamer;
 
    std::map<int, std::pair<tcIntAccessor*, IntAccessorFunction> > mhPeekMap;
    std::map<int, std::pair<tcIntSetter*, IntSetterFunction> > mhPokeMap;
 
    tcPollingInterruptThread mcInterruptThread;
 
    MityDSP::tcAD741x *mpTempSensor;
 
    uint32 mnMaxImgCount;
 
    const sensors_chip_name* mpChipnameAD7414;  
    const sensors_chip_name* mpChipnameLM95235; 
    int mnAD7414_sf;  
    int mnLM95235_die_sf;  
    int mnLM95235_board_sf; 
 
private:
 
    int meType;
 
    std::unordered_map<tcIOCallback *, tsCaptureRequest> mcRequests;
 
    uint64 mnAddressOffset;
 
    tcTimestamp *mpTimestamp;
 
    std::string mcSearchLoc;
 
    uint32 mnSkipFrames; 
    bool   mbReloadSkipFrames; 
};
 
}
 
#endif // SENSORBOARD_H