cinosprocessimage.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSPROCESSIMAGE_H
#define INC_CINOSPROCESSIMAGE_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_PROCESS_IMAGE_NUMBER         8   // number supported of process images
//
// --- process image numbers ---------------------------------------------------
//
#define DF_PROCESS_IMAGE_DIGITAL_INPUTS     0   // nr proc image 'digital input'
#define DF_PROCESS_IMAGE_DIGITAL_OUTPUTS    1   // nr proc image 'digital output'
#define DF_PROCESS_IMAGE_ANALOG_INPUTS      2   // nr proc image 'analog input'
#define DF_PROCESS_IMAGE_ANALOG_OUTPUTS     3   // nr proc image 'analog output'
#define DF_PROCESS_IMAGE_DIGITAL_FLAGS      4   // nr proc image 'digital flags'
#define DF_PROCESS_IMAGE_POSITIONS          5   // nr proc image 'position'
#define DF_PROCESS_IMAGE_AXES               6   // nr proc image 'axes'
#define DF_PROCESS_IMAGE_SIO_CHANNELS       7   // nr proc image 'sio channels'
//
#define DF_INOS_IMAGE_CHN_SIM_NO    0           // simulate channel -> no
#define DF_INOS_IMAGE_CHN_SIM_YES   1           // simulate channel -> yes
#define DF_INOS_IMAGE_CHN_SIM_DEF   2           // simulate channel -> default
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosbus.h>
 
// C++
//
// project
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSProcessImageChannel;
class CINOSBusJob;
class CINOSProcessImage
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        char* GetName();
            //; return name of process image
        uint32 GetNumber();
            //; return number of process image channels
 
        virtual void Set(uint16 auNumber, real64 arValue)
            { };
            //; set channel 'auNumber' to arValue
        virtual real64 Get(uint16 auNumber)
            { return REAL64(0.0);};
            //; get value of channel 'auNumber'
 
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        virtual void SetOverwrite(bool abValue)=0;
            //; change the whole process image from real to overwrite mode if
            //; abValue = true or vice versa
        virtual bool GetOverwrite()=0;
            //; get actual overwrite mode of the whole process image
        virtual void SetOverwrite(uint16 auNumber, bool abValue)=0;
            //; change the channel 'auNumber' from real to overwrite mode if
            //; abValue = true or vice versa
        virtual bool GetOverwrite(uint16 auNumber)=0;
            //; get actual overwrite mode of channel 'auNumber'
        #endif
 
        virtual void SetEnabled(bool abValue);
            //; enable whole process image if abValue = true or vice versa
        virtual bool GetEnabled();
            //; return true if the whole process image is enabled
        virtual void SetEnabled(uint16 auNumber, bool abValue);
            //; enable the channel 'auNumber' if abValue = true or vice versa
        virtual bool GetEnabled(uint16 auNumber);
            //; return true if channel 'auNumber' is enabled
 
        virtual void SetSimulated(uint16 auNumber, bool abValue)=0;
            //; set simulated state of channel auNumber
        virtual bool GetSimulated(uint16 auNumber)=0;
            //; get simulated state of channel auNumber
 
        virtual void SetConfig(uint16 auNumber, uint32 auConfig, uint32 auMask,
            uint32 auOffset=0);
            //; set config of channel 'auNumber' to auConfig (only bits set in 
            //; auMask are affected)
        virtual uint32 GetConfig(uint16 auNumber, uint32 auOffset=0);
            //; get config of channel 'auNumber'
        virtual void* GetConfigAdr(uint16 auNumber, uint32 auOffset=0);
            //; get config address of channel 'auNumber'
 
        virtual void* GetBaseAddress();
            //; get base address of process image (ATTENTION : only need this
            //; address for READING purposes, NEVER write direct to the process
            //; image)
        virtual void* GetConfigBaseAddress();
            //; get base address of process image config 
        INOS_INLINE void* GetAddress(uint16 auNumber)
        {
            // array based ?
            if (m_pDesc[auNumber]<=1){
                // no
                return &m_pImage[auNumber];
            } // end if
            else {
                #if defined(INOS_64)
                return (void*) ((uint64(m_pUpper[auNumber])<<32) + m_pImage[auNumber]);
                #else
                // yes
                return (void*)m_pImage[auNumber];
                #endif
            } // end else
        }
            //; get address of channel auNumber
        virtual uint16 GetArrayLength(uint16 auNumber);
            //; get array length of channel auNumber
        
        virtual void Add(CINOSProcessImageChannel* apChannel);
            //; add process image channel to the image
        virtual void Remove(CINOSProcessImageChannel* apChannel);
            //; remove process image channel from image
        virtual void Remove(uint32 auChannel);
            //; remove process image channel from image
        CINOSProcessImageChannel* Find(const char* apName);
            //; return pointer to channel with apName or NULL if not found
        CINOSProcessImageChannel* FindExact(const char* apName);
            //; return pointer to channel with exact apName or NULL if not found
        CINOSProcessImageChannel* Find(uint16 auNumber);
            //; return pointer to channel with auNumber or NULL if not found
        static CINOSProcessImageChannel* FindInp(const char* apName);
            //; return pointer to input channel (bit,adc,pos) with apName or NULL
            //; if not found
        static CINOSProcessImageChannel* FindInp(uint16 auNumber);
            //; return pointer to input channel (bit,adc,pos) with auNumber or NULL
            //; if not found
        static CINOSProcessImageChannel* FindOut(const char* apName);
            //; return pointer to output channel (bit,dac) with apName or NULL
            //; if not found
        static CINOSProcessImageChannel* FindOut(uint16 auNumber);
            //; return pointer to output channel (bit,dac) with auNumber or NULL
            //; if not found
 
        virtual uint16 GetCycleNumber(uint16 auNumber)
            { return 0;};
            //; return bus subcycle number the channel is updated (needed to be
            //; able to register bus hook in the correct subcycle)
        virtual void SetCycleNumber(uint16 auNumber, uint16 auCycleNumber,
            uint8 auBusId = CINOSBus::GetFirstBus()->GetId(), CINOSBusJob* apBusJob = 0){};
            //; set bus id and subcycle number the channel is updated (the field bus 
            //; driver has to set this number to inform all others who are 
            //; interested in)
        virtual uint16 GetCycleId(uint16 auNumber)
            { return 0;};
            //; return bus cycle id the channel is updated (needed to be
            //; able to register bus hook in the correct cycle/core)
        virtual void SetCycleId(uint16 auNumber, uint16 auCycleId, uint8 auBusId,
            class CINOSBusPortHandler* apBusPortHandler){};
            //; set bus id and cycle id the channel is updated (the field bus 
            //; driver has to set this number to inform all others who are 
            //; interested in)
        virtual void UpdateCycleId(uint16 auNumber, uint16 auCycleId){};
            //; 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 uint8 GetBusId(uint16 auNumber)
            { return 0;};
            //; return bus id the channel belongs to (needed to be
            //; able to register bus hook)
        virtual CINOSBusJob* GetBusJob(uint16 auNumber)
            { return 0;};
            //; return pointer to the according bus job (or 0 if not available)
        virtual class CINOSBusPortHandler* GetBusPortHandler(uint16 auNumber)
            { return 0;};
            //; return pointer to the according bus port (or 0 if not available)
        virtual CINCOObject* GetRegister()
            { return m_pRegister;};
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSProcessImageChannel;
    friend class CINOSProcessImageValue;
    
    // constructor / destructor
    public :
        CINOSProcessImage (char* apName, uint32 auNumber, void* apImage=0);
            //; object constructor
        virtual ~CINOSProcessImage() {}
 
    // public member functions but just for internal use
    public :
        ICACHE virtual void Get(uint16 auChannel, void* apValue);
            //; get actual channel value to apValue
        ICACHE virtual void Get64(uint16 auChannel, void* apValue);
            //; get actual channel value to apValue
        #if defined(INOS_PROCESSIMAGE_OVERWRITE)
        virtual void Set(uint16 auChannel, void* apValue, 
            bool abOverwrite = false)=0;
            //; 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)=0;
            //; set channel to apValue
        #endif
        virtual void Set(uint16 auChannel, void* apValue, uint32 auMask);
            //; set real channel to apValue (only bits set in auMask are 
            //; affected)
        static bool SimulationRequested(uint32 auSimulate = DF_INOS_IMAGE_CHN_SIM_DEF);
            //; return true, if simulation of image requested
        virtual uint32 FindFreeNumber(bool ab32BitBased = false, bool abFromEnd = false);
            //; return first (or last, if abFromEnd is set) free process image channel number or 0xffffffff if
            //; no free numbers
        static char* CreateUniqueName(uint16 auNumber);
            //; create unique channel name for channel auNumber and return pointer
            //; to it
        virtual void MoveChannel(uint16 auOldNumber, uint16 auNewNumber);
            //; move channel auOldNumber to auNewNumber
        virtual CINCOObject* GetChannelParent(CINOSProcessImageChannel* apChannel, bool abCreate);
            //; returns the parent INCO object of the given channel, creating the objects
            //; along the path if requested
        virtual bool RenameInco(CINOSProcessImageChannel* apChannel, const char* apNewName);
            //; renames the given channel in the INCO tree
 
    // public member functions (but just for internal use
    public:
        static CINCOObject* Register(char* apName, void* apAddress=0);
            //; create registration for apName and return pointer to it
 
        static bool MatchName(const char* apName, const char* apPattern);
 
    // protected members
    protected:
        char* m_pName{};
            //; name of process image
        uint32 m_uNumber{};
            //; number of channels
        CINCOObject* m_pRegister{};
            //; pointer to inco registration object
        CINOSProcessImageChannel** m_pChannel{};
            //; array of channel pointers
        uint32* m_pImage{};
            //; pointer to process image
        uint32* m_pDesc{};
            //; pointer to process image channel descriptors
        #if defined(INOS_64)
        uint32* m_pUpper{};
            //; upper 32 bit of 64 bit address
        #endif
 
        #if defined(INOS_PROCESSIMAGE_CHANNELNUMBER_FREE)
        uint32 RequestChn(const char* apName, uint16 auBase, uint8 auChannels, uint16& aoChannel);
 
        uint32 ReleaseChn(uint16 auChannel);
 
        friend class CINOSBusChannelHandler;
 
        CINOSMutex m_ChnMutex;
        std::map<std::string, uint16> m_mChnMap;
        uint32 m_uChannelsActive{};
        uint32* m_pChannelsActive{};
        #endif
};                           
              
#if defined(INOS_PROCESSIMAGE_OVERWRITE)
//------------------------------------------------------------------------------
// class CINCOoverwriteImage
//------------------------------------------------------------------------------
 
class CINCOoverwriteImage : public CINCObit
{
    // constructor
    public:
        CINCOoverwriteImage(
            CINOSProcessImage* apImage
            );
 
    // public member functions
    public:
        // item address = (long) pData + aIndex*sizeof(item) + aOffset
        virtual long Put(void* aSource, long aIndex=0, long aOffset=0);
        // item address = (long) pData + aIndex*sizeof(item) + aOffset
        virtual long Get(void* aSource, long& aMaxLength, long aIndex=0, long aOffset=0);
 
    // protected members
    protected :
        CINOSProcessImage* m_pImage;
            //; pointer to according image
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINCOoverwriteImage);
};
#endif
 
//------------------------------------------------------------------------------
 
class CINOSLVDT
{
    friend class CINOSBusPortHandlerTdc;
 
    public :
        static bool IsValid(class CINOSAdcChannel* apChannel);
        static bool IsValid(const char* apChannel);
 
        static uint32 Calibrate(class CINOSAdcChannel* apChannel);
        static uint32 Calibrate(const char* apChannel);
 
    protected :
        // protection mutex
        static CINOSMutex m_Mutex;
        static TSafeArray<class CINOSAdcChannel*> m_AdcChannel;
        static TSafeArray<class CINOSBusPortHandlerTdc*> m_Lvdt;
        static CINOSLVDT m_Instance;
 
    public:
        static CINOSLVDT& Instance()
        {
            // return our singleton instance
            return m_Instance;
        }
};
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// --- process images channels -------------------------------------------------
//
#include <cinosprocessimagechannel.h>
#include <cinosbit.h>
#include <cinosprocessimagevalue.h>
#include <cinosadcchannel.h>
#include <cinosdacchannel.h>
#include <cinosposchannel.h>
//
// --- more process images -----------------------------------------------------
//
#include <cinosprocessimagevalues.h>
#include <cinosbits.h>
#include <cinosadcchannels.h>
#include <cinosdacchannels.h>
#include <cinosposchannels.h>
//
//------------------------------------------------------------------------------
// global variables
//------------------------------------------------------------------------------
//
extern CINOSProcessImage* g_pImage[DF_PROCESS_IMAGE_NUMBER];
 
extern CINOSMutex g_ImageLock[DF_PROCESS_IMAGE_NUMBER];
//
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSPROCESSIMAGE_H