#pragma once #include "Result.h" #include "sls_detector_defs.h" #include #include #include class multiSlsDetector; namespace sls { using ns = std::chrono::nanoseconds; using Positions = const std::vector &; using defs = slsDetectorDefs; /** * \class Detector */ class Detector { std::unique_ptr pimpl; public: /** * @param multi_id multi detector shared memory id */ Detector(int multi_id = 0); ~Detector(); // Acquisition /** * Blocking call, starts the receiver and detector. Acquired * the number of frames set. */ void acquire(); void startReceiver(Positions pos = {}); void stopReceiver(Positions pos = {}); /** * Get the acquiring flag. When true the detector blocks * any attempt to start a new acquisition. */ bool getAcquiringFlag() const; /** * Set the acquiring flag. This might have to done manually * after an acquisition was aborted. */ void setAcquiringFlag(bool value); /** Read back the run status of the receiver */ Result getReceiverStatus(Positions pos = {}); // Configuration /** * Frees the shared memory of this detector and all modules * belonging to it. */ void freeSharedMemory(); void setConfig(const std::string &fname); Result getHostname(Positions pos = {}) const; // void setHostname(Positions pos = {}); Result getStartingFrameNumber(Positions pos = {}) const; void setStartingFrameNumber(uint64_t value, Positions pos); // Bits and registers /** * Clears (sets to 0) bit number bitnr in register at addr. * @param addr address of the register * @param bitnr bit number to clear * @param pos detector position */ void clearBit(uint32_t addr, int bitnr, Positions pos = {}); /** * Sets bit number bitnr in register at addr to 1 * @param addr address of the register * @param bitnr bit number to clear * @param pos detector position */ void setBit(uint32_t addr, int bitnr, Positions pos = {}); /** * Reads 32 bit register from detector * @param addr address of the register * @returns value read from register */ Result getRegister(uint32_t addr, Positions pos = {}); /************************************************** * * * FILE, anything concerning file writing or * * reading goes here * * * * ************************************************/ /** * Returns receiver file name prefix. The actual file name * contains module id and file index as well. * @param pos detector positions * @returns file name prefix */ Result getFileName(Positions pos = {}) const; /** * Sets the receiver file name prefix * @param fname file name prefix */ void setFileName(const std::string &fname, Positions pos = {}); Result getFilePath(Positions pos = {}) const; void setFilePath(const std::string &fname, Positions pos = {}); Result getFileWrite(Positions pos = {}) const; void setFileWrite(bool value, Positions pos = {}); Result getFileOverWrite(Positions pos = {}) const; void setFileOverWrite(bool value, Positions pos = {}); // Time Result getExptime(Positions pos = {}) const; void setExptime(ns t, Positions pos = {}); Result getSubExptime(Positions pos = {}) const; void setSubExptime(ns t, Positions pos = {}); Result getPeriod(Positions pos = {}) const; void setPeriod(ns t, Positions pos = {}); // dhanya /** * Get multidetector Id * @returns multidetector Id */ int getMultiId() const; /** * Check version compatibility with detector software * @param pos detector position */ void checkDetectorVersionCompatibility(Positions pos = {}) const; /** * Check version compatibility with receiver software * @param pos detector position */ void checkReceiverVersionCompatibility(Positions pos = {}) const; /** * Get detector firmware version * @param pos detector position * @returns detector firmware version */ Result getDetectorFirmwareVersion(Positions pos = {}) const; /** * Get detector server version * @param pos detector position * @returns detector server version */ Result getDetectorServerVersion(Positions pos = {}) const; /** * Get detector serial number * @param pos detector position * @returns detector serial number */ Result getDetectorSerialNumber(Positions pos = {}) const; /** * Get Client Software version * @returns client software version */ int64_t getClientSoftwareVersion() const; /** * Get Receiver software version * @param pos detector position * @return receiver software version */ Result getReceiverSoftwareVersion(Positions pos = {}) const; /** * Get user details of shared memory * @returns string with user details */ std::string getUserDetails() const; /** * Frees shared memory and adds detectors to the list * Also updates local detector cache * @param name hostnames for the positions given */ void setHostname(const std::vector &value); /** * Get Detector type as an enum * @returns detector type */ defs::detectorType getDetectorTypeAsEnum() const; /** * Get Detector type as an enum * @param pos detector position * @returns detector type */ Result getDetectorTypeAsEnum(Positions pos = {}) const; /** * Returns detector type as a string * @param pos detector position * @returns detector type as string */ Result getDetectorTypeAsString(Positions pos = {}) const; /** * Returns the total number of detectors in the multidetector structure * @returns total number of detectors in the multidetector structure */ int getTotalNumberOfDetectors() const; /** * Returns the number of detectors in the multidetector structure * @returns number of detectors in the multidetector structure */ defs::coordinates getNumberOfDetectors() const; /** * Returns the number of channels * @param pos detector position * @returns the number of channels */ Result getNumberOfChannels(Positions pos = {}) const; /** * Returns the number of channels including gap pixels * @param pos detector position * @returns the number of channels including gap pixels */ Result getNumberOfChannelsInclGapPixels(Positions pos = {}) const; /** * Returns the maximum number of channels of complete detector in both * dimensions. -1 means no limit in this dimension. This value is used to * calculate row and column offsets for each module. * @returns the maximum number of channels of complete detector */ defs::coordinates getMaxNumberOfChannels() const; /** * Sets the maximum number of channels of complete detector in both * dimensions. -1 means no limit in this dimension. This value is used to * calculate row and column offsets for each module. * @param value the maximum number of channels of complete detector */ void setMaxNumberOfChannels(const defs::coordinates value); /** * Get Detector offset from shared memory (Gotthard only) * @param pos detector position * @returns offset in both dimensions */ Result getDetectorOffsets(Positions pos = {}) const; /** * Set Detector offset in shared memory for each module * @param value offset for detector in both dimensions * @param pos detector position */ void setDetectorOffsets(defs::coordinates value, Positions pos = {}); /** * Get Quad Type (Only for Eiger Quad detector hardware) * @param pos detector position * @returns quad type */ Result getQuad(Positions pos = {}) const; /** * Set Quad Type (Only for Eiger Quad detector hardware) * @param enable true if quad type set, else false * @param pos detector position */ void setQuad(const bool enable, Positions pos = {}); /** * Get number of rows to read out (Only for Eiger) * @param pos detector position * @returns number of lines */ Result getReadNLines(Positions pos = {}) const; /** * Set number of rows to read out (Only for Eiger) * @param value number of lines * @param pos detector position */ void setReadNLines(const int value, Positions pos = {}); /** * Get Receiver TCP port (for client communication with Receiver) * @param pos detector position * @returns receiver port */ //int getControlort(Positions pos = {}) const; /** * Set TCP Port of the detector (for client communication with Receiver) * @param value port number * @param pos detector position */ //void setControlPort(int port_number, Positions pos = {}); /** * Get Receiver TCP port (for client communication with Receiver) * @param pos detector position * @returns receiver port */ //int getStopPort(Positions pos = {}) const; /** * Set TCP Port of the detector (for client communication with Receiver) * @param value port number * @param pos detector position */ //void setStopPort(int port_number, Positions pos = {}); /** * Get Receiver TCP port (for client communication with Receiver) * @param pos detector position * @returns receiver port */ //int getReceiverPort(Positions pos = {}) const; /** * Set TCP Port of the detector (for client communication with Receiver) * @param value port number * @param pos detector position */ //void setReceiverPort(int port_number, Positions pos = {}); // Erik Result getFramesCaughtByReceiver(Positions pos = {}) const; Result getReceiverCurrentFrameIndex(Positions pos = {}) const; void resetFramesCaught(Positions pos = {}); // TODO! // int createReceivingDataSockets(const bool destroy = false); // void readFrameFromReceiver(); void setMasterFileWrite(bool value, Positions pos = {}); Result getMasterFileWrite(Positions pos = {}) const; void setReceiverStreamingFrequency(int freq = -1, int detPos = -1); /** * [All] If receiver streaming frequency is 0, then this timer between each * data stream is set. Default is 500 ms. */ void setReceiverStreamingTimer(int time_in_ms = 500, Positions pos = {}); /** [All] */ Result getReceiverStreamingTimer(Positions pos = {}) const; // TODO! // int enableDataStreamingToClient(int enable = -1); // int enableDataStreamingFromReceiver(int enable = -1, int detPos = -1) /** [TODO! All?] */ void setTenGigaEnabled(bool value, Positions pos = {}); /** [TODO! All?] */ Result getTenGigaEnabled(Positions pos = {}) const; /** [All] */ void setReceiverFifoDepth(int nframes, Positions pos = {}); /** [All] */ Result getReceiverFifoDepth(Positions pos = {}) const; /** [All] */ void setReceiverSilentMode(bool value, Positions pos = {}); /** [All] */ Result getReceiverSilentMode(Positions pos = {}) const; /** [CTB] */ void setPattern(const std::string &fname, Positions pos = {}); /** [CTB] */ void setPatternIOControl(uint64_t word, Positions pos = {}); /** [CTB] */ Result getPatternIOControl(Positions pos = {}) const; /** [CTB] */ void setPatternClockControl(uint64_t word, Positions pos = {}); /** [CTB] */ Result getPatternClockControl(Positions pos = {}) const; /** * [CTB] Writes a pattern word * @param addr address of the word * @param word word to be written, -1 reads the addr (same as * executing the pattern) * @param pos detector position * @returns actual value */ void setPatternWord(int addr, uint64_t word, Positions pos = {}); // TODO! Does this have side effects? // uint64_t getPatternWord()... /** * [CTB] Sets the pattern or loop limits. * @param level -1 complete pattern, 0,1,2, loop level * @param start start address for level 0-2 * @param stop stop address for level 0-2 * @param n number of loops for level 0-2 * @param pos detector position */ void setPatternLoops(int level, int start, int stop, int n, Positions pos = {}); /** * [CTB] Gets the pattern loop limits * @param level -1 complete pattern, 0,1,2, loop level * @param pos detector positions * @returns array of start address, stop address and number of loops */ Result> getPatternLoops(int level, Positions pos = {}) const; /** * [CTB] Sets the wait address * @param level 0,1,2, wait level * @param addr wait address * @param pos detector position * @returns actual value */ void setPatternWaitAddr(int level, int addr, Positions pos = {}); /* [CTB] */ Result getPatternWaitAddr(int level, Positions pos = {}) const; /** * [CTB] Sets the wait time * @param level 0,1,2, wait level * @param t wait time * @param pos detector position */ void setPatternWaitTime(int level, uint64_t t, Positions pos = {}); /** [CTB] */ Result getPatternWaitTime(int level, Positions pos = {}) const; /** [CTB] Sets the mask applied to every pattern. */ void setPatternMask(uint64_t mask, Positions pos = {}); /** [CTB] Gets the mask applied to every pattern. */ Result getPatternMask(Positions pos = {}); /** * [CTB] Sets the bitmask that the mask will be applied to for every * pattern. * @param mask mask to select bits */ void setPatternBitMask(uint64_t mask, Positions pos = {}); /** * [CTB] Gets the bits that the mask will be applied to for every * pattern */ Result getPatternBitMask(Positions pos = {}) const; /** [CTB] Enable or disable the LED */ void setLEDEnable(bool enable, Positions pos = {}); /** [CTB] Get LED enable. */ Result getLEDEnable(Positions pos = {}) const; /** * [CTB] Set Digital IO Delay * @param digital IO mask to select the pins * @param delay delay in ps(1 bit=25ps, max of 775 ps) */ void setDigitalIODelay(uint64_t pinMask, int delay, Positions pos = {}); Result getFileIndex(Positions pos = {}) const; void setFileIndex(int i, Positions pos = {}); Result getFileFormat(Positions pos = {}) const; void setFileFormat(defs::fileFormat f, Positions pos = {}); Result getPartialFramesPadding(Positions pos = {}) const; void setPartialFramesPadding(bool value, Positions pos = {}); void setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f, Positions pos = {}); Result getReceiverFrameDiscardPolicy(Positions pos = {}) const; void setFramesPerFile(int n, Positions pos = {}); Result getFramesPerFile(Positions pos = {}) const; // void execReceiverCommand(const std::string &cmd, int detPos = -1); // void exitReceiver(int detPos = -1); Result getReceiverLastClientIP(Positions pos = {}) const; }; } // namespace sls