cinosbits.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBITS_H
#define INC_CINOSBITS_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_PROCESS_IMAGE_DIGITAL_INPUTS_NUMBER  DF_INOS_PROCESSIMAGE_DIGITAL_INPUTS_NUMBER  // def. number of dig inputs
#define DF_PROCESS_IMAGE_DIGITAL_OUTPUTS_NUMBER DF_INOS_PROCESSIMAGE_DIGITAL_OUTPUTS_NUMBER // def. number of dig outputs
#define DF_PROCESS_IMAGE_DIGITAL_FLAGS_NUMBER   16384   // def. number of dig flags
//
#define DF_INOS_FLAG_DBT    "INOS-FLAG"     // INOS-FLAG db table name
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// Database structures
//------------------------------------------------------------------------------
//
struct SINOSFlag
{ 
    inosName32 m_cName; 
    uint16 m_uNumber;
    uint8 m_uOverwrite;
    uint8 m_uOverwriteValue;
};
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSBits : public CINOSProcessImage
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        ICACHE virtual void Set(uint16 auNumber, real64 arValue) override;
            //; set channel 'auNumber' to arValue
        ICACHE virtual real64 Get(uint16 auNumber) override;
            //; get value of channel 'auNumber'
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        bool Set(uint16 auNumber, bool abOverwrite = false);
            //; set bit 'auNumber' and return the value before ('Test and Set')
            //; (abOverwrite=true -> bit always set, abOverwrite=false -> bit set
            //; if channel is NOT in overwrite mode)
        bool Clear(uint16 auNumber, bool abOverwrite = false);
            //; clear bit 'auNumber' and return the value before
            //; (abOverwrite=true -> bit always cleared, abOverwrite=false ->
            //; bit cleared if channel is NOT in overwrite mode)
        #else
        bool Set(uint16 auNumber);
            //; set bit 'auNumber' and return the value before ('Test and Set')
        bool Clear(uint16 auNumber);
            //; clear bit 'auNumber' and return the value before
        #endif
        bool SetEx(uint16 auNumber, uint16 auIndex);
            //; set array based bit 'auNumber' and return the value before
        bool SetLatched(uint16 auNumber);
            //; set latched bit 'auNumber' and return the value before ('Test and Set')
        bool ClearEx(uint16 auNumber, uint16 auIndex);
            //; clear array based bit 'auNumber' and return the value before
        bool ClearLatched(uint16 auNumber);
            //; clear latched bit 'auNumber' and return the value before ('Test and Set')
        bool Test(uint16 auNumber);
            //; test bit 'auNumber'
        bool TestEx(uint16 auNumber, uint16 auIndex);
            //; test array based bit 'auNumber'
        bool TestLatched(uint16 auNumber);
            //; test latched bit 'auNumber'
        uint32 WaitForSet(uint16 auNumber, uint32 aTimeout=INOS_WAIT_FOREVER);
            //; wait max. aTimeout usec for bit 'auNumber' set
            //; return value == 0 -> timeout, != 0 -> time waited for bit (in usec)
        uint32 WaitForCleared(uint16 auNumber, uint32 aTimeout=INOS_WAIT_FOREVER);
            //; wait max. aTimeout usec for bit 'auNumber' cleared
            //; return value == 0 -> timeout, != 0 -> time waited for bit (in usec)
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        virtual void SetOverwrite(bool abValue) override;
            //; change the whole process image from real to overwrite mode if
            //; abValue = true or vice versa
        virtual bool GetOverwrite() override;
            //; get actual overwrite mode of the whole process image
        virtual void SetOverwrite(uint16 auNumber, bool abValue) override;
            //; change the bit 'auNumber' from real to overwrite mode if
            //; abValue = true or vice versa
        virtual bool GetOverwrite(uint16 auNumber) override;
            //; get actual overwrite mode of bit 'auNumber'
        #endif
        virtual void SetSimulated(uint16 auNumber, bool abValue) override;
            //; set bit simulated
        virtual bool GetSimulated(uint16 auNumber) override;
            //; get bit simulated
        void ConvertToReal(uint16 auOldNumber, uint16 auNewNumber);
            //; get bit simulated
        CINOSBit* Find(const char* apName,
            uint32 auSimulate = DF_INOS_IMAGE_CHN_SIM_DEF);
            //; return pointer to bit with apName or NULL if not found
        CINOSBit* Find(uint16 auNumber,
            uint32 auSimulate = DF_INOS_IMAGE_CHN_SIM_DEF);
            //; return pointer to bit with auNumber or NULL if not found
        virtual void SetConfig(uint16 auNumber, uint32 auConfig, uint32 auMask,
            uint32 auOffset=0) override;
            //; set config of channel 'auNumber' to auConfig (only bits set in 
            //; auMask are affected)
        virtual uint32 GetConfig(uint16 auNumber, uint32 auOffset=0) override;
            //; get config of channel 'auNumber'
 
        virtual void UpdateCycleId(uint16 auNumber, uint16 auCycleId) override;
            //; update cycle id the channel is updated (this method is usually called
            //; from axis controllers to inform about downsampled controlling and possible
            //; other cores)
 
        virtual void* GetRealAddress(uint16 auNumber) const;
            //; Get address to 'real image'
 
        virtual void* GetLatchedBaseAddress();
            //; get base address of latched process image
            
        // only digital inputs 
        
        void SetFilter(uint16 auNumber, uint16 auFilter);
            //; set filter value (ticks)
        uint16 GetFilter(uint16 auNumber);
            //; get filter value (ticks)
        void SetInverted(uint16 auNumber, bool abInverted);
            //; set bit inverted
        bool GetInverted(uint16 auNumber);
            //; get bit inverted      
        void* GetInvertedBaseAddress(); 
            //; get address of inverted-mask
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        void* GetOverwrite0BaseAddress(); 
            //; get address of overwrite0
        void* GetOverwrite1BaseAddress(); 
            //; get address of overwrite1
        #endif
 
        CINOSBit* CreateVirtual(const char* apName);
            //; creates a new digital Input/Output that does not directly translate to hardware
            //; useful to add custom channels to the process image
 
        virtual void Remove(uint32 auChannel) override;
            //; remove process image channel from image
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBit;
    friend class CINOSBitSetEvent;
    friend class CINOSBitClearedEvent;
    
    // constructor / destructor
    public :
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        CINOSBits (char* apName, uint32 auNumber, void* apImage,
            bool abSupportOverwrite = true);
    #else
        CINOSBits (char* apName, uint32 auNumber, void* apImage);
    #endif
 
    // public member functions but just for internal use
    public :
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        virtual void Set(uint16 auChannel, void* apValue, 
            bool abOverwrite = false) override;
            //; set channel to apValue 
            //; (abOverwrite=true -> value always set, abOverwrite=false -> value
            //; set if channel is NOT in overwrite mode)
        #else
        virtual void Set(uint16 auChannel, void* apValue) override;
            //; set channel to apValue
        #endif
        ICACHE virtual void Set(uint16 auChannel, void* apValue, uint32 auMask) override;
            //; set real channel to apValue (only bits set in auMask are 
            //; affected)
        ICACHE void Update(uint32 auChannel, uint32 auOldBits);
            //; update 'image' area according to actual overwrite state
            //; (image = real & overwrite_0 | overwrite_1)
        static CINOSBits* Create(uint32 auImageNumber);
            //; check if process image already exists, if no create one
        virtual void MoveChannel(uint16 auOldNumber, uint16 auNewNumber) override;
            //; move channel auOldNumber to auNewNumber
 
    // private members
    private :
        void CreateArray(uint16 auChannel, uint16 auArrayLength);
 
    // protected members
    protected:
        uint32 m_uLatchMode;
            //; 0 -> 0's are latched, 1 -> 1's are latched
        uint32 m_uNumberUnits;
            //; number of uint32 units this image occupies
        uint32* m_pReal;
            //; pointer to real part of process image
        uint32* m_pLatched;
            //; pointer to latched data (latched = latched &/| image
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        bool m_bSupportOverwrite;
            //; true/false -> overwrite mode supported/not supported
        uint32* m_pOverwrite_0;
            //; pointer to overwrite 0 data
        uint32* m_pOverwrite_1;
            //; pointer to overwrite 1 data
        #endif
        uint32* m_pSimulated;
            //; pointer to simulated data
        uint32* m_pFilter;
            //; pointer to filter bit field (bit=1 -> channel wants to be filtered)
            //; only valid for inputs
        uint32* m_pInverted;
            //; pointer to inverted bit field (bit=1 -> channel is inverted)
            //; only valid for inputs
    
        #ifndef INOS_NO_BIT_EVENT_SUPPORT
        uint32* m_pWaitSet;
            //; pointer to bit field of set events
        uint32* m_pWaitClr;
            //; pointer to bit field of clear events
        #endif
};
 
//
//------------------------------------------------------------------------------
// global variables
//------------------------------------------------------------------------------
//
#define g_pInputs ((CINOSBits *) g_pImage[DF_PROCESS_IMAGE_DIGITAL_INPUTS])
#define g_pOutputs ((CINOSBits *) g_pImage[DF_PROCESS_IMAGE_DIGITAL_OUTPUTS])
#define g_pFlags ((CINOSBits *) g_pImage[DF_PROCESS_IMAGE_DIGITAL_FLAGS])
 
// some defines for compatibility
#define pInputs g_pInputs
#define pOutputs g_pOutputs
#define pFlags g_pFlags
 
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBITS_H