detecmes.h

gehe zur Dokumentation dieser Datei

/*
$Header: /vol/baal-vol3/projekt98/quellen/XCTL_32/INCLUDE/DETECUSE/detecmes.h,v 1.12 2004/05/19 14:54:43 reinecke Exp $

Projekt   : XCTL
Subsystem : Detektoren
Autor     : Jan Picard <picard@informatik.hu-berlin.de> 2001-2002
          Institut fuer Informatik,
          Humboldt-Universitaet Berlin
Inhalt    : Interface-Deklaration fuer die Messadapterklassen
*/

#ifndef __M_DEVHW_H
#define __M_DEVHW_H

#include <fstream.h>
#include "detecuse\detecuse.h"
#include "detecuse\detectorcontroller.h"

//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--

//vormals in evrythng.h
#define  R_MeasInProcess   205
#define  R_HardOverflow    217

//liefert den der spezifizierten id entsprechenden Controller aus der spezifizierten
//Controllerliste -> instantiiert ggf. einen neuen Controller
Controller* GetController(EDeviceType DeviceID, LPTSTR HardwareID,
                                                                         ControllerList* Controllers, DeviceList* Drivers, DWORD* index= 0);

//#############################################################################
// 0-dimensionale Detektoren
//#############################################################################

class TGenericDetector : public TZeroDimDetector
{
public:
        TGenericDetector(int id);
        virtual  ~TGenericDetector();

        BOOL Initialize( void );
        EDetectorType GetDetectorType() const
        {
                return GenericDetector;
        };

        int MeasureStart( void );
        int MeasureStop( void );
        int PollDetector( void );

        void LookUp(LPCSTR Section);

protected:
        BOOL _SetParameters( void );

private:
        TGenericController* Hardware;
        int nBaseAddr;
        float fTimeCorrection;
};

class TRadicon : public TZeroDimDetector
{

public:
        TRadicon(int id);
        virtual  ~TRadicon( );

        BOOL Initialize( void );
        BOOL InitializeEvent( HWND, int );
        static void CALLBACK EventHandler( UINT, UINT, DWORD, DWORD, DWORD );
        EDetectorType GetDetectorType() const
        {
                return CounterDetector;
        };

        WORD GetHighVoltage() const
        {
                return wHighVoltage;
        };

        void SetHighVoltage(WORD);

        //JP?
        void SetDacThresh(WORD, WORD);

        //JP?
        const TRange<WORD>& GetDacThresh() const
        {
                return DacThresh;
        };

        int MeasureStart( void );
        int MeasureStop( void );
        int PollDetector( void );
        BOOL RunSpecificParametersDlg( void );
        BOOL HasSpecificParametersDlg( void ) const
        {
                return TRUE;
        };

private:
        BOOL _SetParameters( void );
        BOOL SetSound( void );
        void LoadDetectorSettings();
        void SaveDetectorSettings() const;

        double dRealTime;

        int Rdd;

        int Rcc;

        //JP? Intervall fuer gultige Werte fuer
        TRange<WORD> DacThresh;
        static const TRange<WORD> DacThreshLimits;

        static const TRange<WORD> VoltageLimits;

        WORD wHighVoltage;

        TRadiconController* Hardware;

        static TRadiconController* TheEventHardware;
};

//#############################################################################
// Test-Detektoren
//#############################################################################

class Testdev : public TZeroDimDetector
{
        class TestdevData
        {
        public:
                TestdevData();
                virtual  ~TestdevData();

                long value(int x, int y, int z) const;

        private:
                BOOL parseCC(ifstream& file);

                long** parseTL(ifstream& file);

                long* parseDF(ifstream& file);

                static int instanceCounter;

                static long ***data;

                BOOL initData();
        };

public:
        Testdev(int id);
        virtual  ~Testdev();

        int PollDetector( void );
        EDetectorType GetDetectorType() const
        {
                return CounterDetector;
        };

private:
        TestdevData* data;

        double CalculateIntensity() const;

        double InterPolate( int ccI, int tlI, int dfI, int tlB ) const;
};

class TZeroDimSimpleTestDetector : public TZeroDimDetector
{
public:
        TZeroDimSimpleTestDetector(int id);
        virtual  ~TZeroDimSimpleTestDetector() {}

        int PollDetector( void );
};

class TOneDimTestDetector : public TOneDimDetector
{
public:
        TOneDimTestDetector(int id);
        virtual  ~TOneDimTestDetector() {}

        int PsdReadOut( EHowReadOutPsd eReadType);
};

//#############################################################################
// 1-dimensionale Detektoren
//#############################################################################

class TStoePsd : public TOneDimDetector
{
public:
        TStoePsd(int id);
        virtual  ~TStoePsd( void );

        int PollDetector( void );

        EDetectorType GetDetectorType() const
        {
                return PsdDetector;
        };

protected:
        void LoadDetectorSettings();
        void SaveDetectorSettings() const;

private:
        int nBaseAddr;
        BOOL bLong;
        BOOL Initialize( void );
        int PsdReadOut( EHowReadOutPsd );
        int PsdRead( int, LPWORD );
        int PsdInit( void );
        int PsdStart( void );
        int PsdStop( void );


        // 30.02.2004 MEMCORRECT (verwende hStoeBuf) HGLOBAL hReadBuf;
        LPWORD hStoeBuf;


        int nReadBufItems;

        BOOL bReadyForRead;

        HardwareIo Hardware;
};

class TBraunPsd : public TOneDimDetector
{
public:
        TBraunPsd(int id);
        virtual  ~TBraunPsd( void );

        BOOL Initialize( void );
        //int PollDetector( void );
        int PsdInit( void );
        int PsdStart( void );

        int PsdReadOut( EHowReadOutPsd );
        virtual int GetBufferSize( void ) const;
        BOOL SetEnergyRange( UINT, UINT );
        void GetEnergyRange( UINT& ler, UINT& her ) const
        {
                her= uEnergyHigh;
                ler= uEnergyLow;
        };

        int PsdStop( void );

        int GetChannelNumber() const;

        int nErrorCode;
        BOOL bSetError;
        int nHVRegelung_OK;
        EDetectorType GetDetectorType() const
        {
                return PsdDetector;
        };

protected:
        int BuildOperation( BYTE*, BYTE*, int );
        int LoadHexFile( void );
        void ResetDelayTime( void );
        BYTE konvert( char );
        int SynchronHexFile( BYTE&, BYTE& );
        int Look_till_BaseAddr1( int );
        void LoadDetectorSettings();
        void SaveDetectorSettings() const;

private:
        int nBaseAddr;

        static BYTE echo[ 30 ][ 16 ];
        static BYTE befehl[ 30 ][ 16 ];
        UINT uMuxTimeDet1;
        LONG PositionsDatenHeader[ 16 ];
        UINT uEnergyScale; // moeglich sind 00, 01, 02, 03 hex
        UINT uPositionScale; // moeglich sind 00, 01, 02, 03 hex
        UINT uEnergyHigh;
        UINT uEnergyLow;
        LONG lPositionStop; // Countstop fuer Positionskanaele
        // 0..EFFFFFFFFFFF hex
        BOOL bAbbruchmitShutter; // boolscher Wert
        int nDeathTime; // min. Impulsabstand 0..99 dec [0..99 *E-6 sec]
        BOOL bRatemeter; // computed=00, total=01
        BOOL bRealLifeTime; // Realtime=00, Lifetime=01
        LONG lMeasTime; // Messzeit 1..9999999 dec [sec]

        // 31.06.2004 MEMCORRECT HGLOBAL hReadBuf;

        int nDelayFast;
        int nDelaySlow;
        //27.07.2003(Jan Picard) UINT uCBufferLength;
        int nReadBufItems;
        int nHVControl_OK;

        TBraunPsdController* Hardware;
};
#endif // __M_DEVHW_H

---