cinosbus.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBUS_H
#define INC_CINOSBUS_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_INOS_BUS_DBT "INOS-BUS"      // INOS-BUS db table name 
//
#define DF_INOS_BUS_MAX_NUMBER          4   // max. number of inos buses on one target
#define DF_INOS_BUS_MAX_DMY_JOBS        4   // max. number of dummy jobs
#define DF_INOS_BUS_MAX_CATEGORY        4   // max. number of cycletime categories
#define DF_INOS_BUS_MAX_CYCLE_NUMBER    32  // max. number of bus cycles supported (32 kHz)
//
#define DF_INOS_BUS_CATEGORY_INVALID    255 // invalid category number
#define DF_INOS_BUS_CATEGORY_1000_US    3   // category number 1ms
#define DF_INOS_BUS_CATEGORY_250_US     2   // category number 250us
#define DF_INOS_BUS_CATEGORY_125_US     1   // category number 125us
#define DF_INOS_BUS_CATEGORY_FASTEST    0   // category number 'fastest' (16, 32 or 64 kHz)
//
#define DF_INOS_BUS_CORE_0              0   // running on core 0
#define DF_INOS_BUS_CORE_1              1   // running on core 1
#define DF_INOS_BUS_CORE_2              2   // running on core 2
#define DF_INOS_BUS_CORE_3              3   // running on core 3
//
#define DF_INOS_BUS_JOB_CTM_RES 0x8000  // job in 2 dim array is CTM reserved
#define DF_INOS_BUS_JOB_CLD_RES 0x4000  // job in 2 dim array is CLD reserved
#define DF_INOS_BUS_JOB_WTG_RES 0x2000  // job in 2 dim array is WTG reserved
#define DF_INOS_BUS_JOB_TIM_RES 0x1000  // job in 2 dim array is TIM reserved
#define DF_INOS_BUS_JOB_IRQ_REQ 0x0800  // job in 2 dim array has IRQ request
#define DF_INOS_BUS_JOB_NDY_MSK 0xE000  // job 'not a dummy' mask in 2 dim array
#define DF_INOS_BUS_JOB_IND_MSK 0x07FF  // job index/time mask in 2 dim array
//
#define DF_INOS_BUS_STACKSIZE_MIN 32768 // minimum stack size required for bus task
//
// --- inos bus states ---------------------------------------------------------  
//
#define DF_INOS_BUS_STAT_IDLE       0   // state IDLE
#define DF_INOS_BUS_STAT_SCAN       1   // state SCAN
#define DF_INOS_BUS_STAT_INIT       2   // state INIT
#define DF_INOS_BUS_STAT_RUN        3   // state RUN
#define DF_INOS_BUS_STAT_RUN_DIAG   4   // state RUN DIAGNOSIS
#define DF_INOS_BUS_STAT_DOWN       5   // state DOWN
#define DF_INOS_BUS_STAT_STOPPED    6   // state STOPPED
//
// --- inos bus options --------------------------------------------------------  
//
#define DF_INOS_BUS_OPTION_FLOAT            0x00000001  // option 'floating point support'
#define DF_INOS_BUS_OPTION_NO_1MS           0x00000002  // option 'has no 1ms handler'
#define DF_INOS_BUS_OPTION_SPLIT_SC         0x00000004  // option 'split sub cycle'
#define DF_INOS_BUS_OPTION_STOP_ON_OVERRUN  0x00000008  // option 'stop in case of overrun'
#define DF_INOS_BUS_OPTION_IGNORE_MAC       0x00000010  // option 'ignore slave mac address'
#define DF_INOS_BUS_OPTION_NO_IRQ           0x00000020  // option 'run with disabled irq's'
#define DF_INOS_BUS_OPTION_NO_INCO          0x00000040  // option 'no inco communication support
#define DF_INOS_BUS_OPTION_CYCLE_CAT        0x00000080  // option 'cycle categories'
#define DF_INOS_BUS_OPTION_NO_POST_HANDLER  0x00000100  // option 'do not create posthandler task'
#define DF_INOS_BUS_OPTION_FAKE             0x00000200  // option 'fake bus'
#define DF_INOS_BUS_OPTION_EXTENDED_PAUSE   0x00000400  // option 'extended pause bits (InfoLink)'
#define DF_INOS_BUS_OPTION_SIMULATED        0x00000800  // option 'fieldbus is simulated'
#define DF_INOS_BUS_OPTION_SLOT_IRQTIME     0x00001000  // option 'slot irq time always required'
//
#define DF_INOS_BUS_OPTIONEX_OPT_PORT_HANDLING      0x00000001  // option 'optimized port handling'
#define DF_INOS_BUS_OPTIONEX_RINGMODE               0x00000002  // option 'ginlink in ring mode'
#define DF_INOS_BUS_OPTIONEX_AUTO_CLOSE             0x00000004  // option 'ginlink in auto close mode'
#define DF_INOS_BUS_OPTIONEX_LATE_STATE_RUNNING     0x00000008  // option that sets bus state to 'running' *after* LinkUp() has been called
#define DF_INOS_BUS_OPTIONEX_DO_NOT_CREATE_PORTS    0x00000010  // option 'do not create ports of scanned modules'
#define DF_INOS_BUS_OPTIONEX_SETUP_OFFLINE_MODULE   0x00000020  // option 'setup bus module even if the module is offline'
#define DF_INOS_BUS_OPTIONEX_USE_ALL_CORES          0x00000040  // option 'use all available cores'
#define DF_INOS_BUS_OPTIONEX_PORTS_PUBLIC           0x00000080  // option 'all ports are public' (used on 3 ported ram slaves)
#define DF_INOS_BUS_OPTIONEX_MODULES_MULTICORE      0x00000100  // option 'restrict supported modules on multicore systems'
#define DF_INOS_BUS_OPTIONEX_ONLY_SETUP_KNOWN_MODULES 0x00000200// option 'only configure/safe/operational known modules'
#define DF_INOS_BUS_OPTIONEX_DO_NOT_STOP_ON_TRAP    0x00000400  // option 'do not stop bus in case of a trap'
#define DF_INOS_BUS_OPTIONEX_DMA_TRANSFER           0x00000800  // option 'use DMA if available'
#define DF_INOS_BUS_OPTIONEX_PORT_REC_OVERWRITE_OFFLINE 0x00001000  // option 'set ports to receive overwrite if slave is offline'
#define DF_INOS_BUS_OPTIONEX_OPT_CHANNEL_NUMBERING  0x00002000  // option 'optimized channel numbering'
#define DF_INOS_BUS_OPTIONEX_NO_RECEIVE_DATA        0x00004000  // option 'do not handle receive data'
#define DF_INOS_BUS_OPTIONEX_CLEANUP_AT_RESCAN      0x00008000  // option 'cleanup processimage at rescan'
#define DF_INOS_BUS_OPTIONEX_TRADATA_COPY_IN_RAM    0x00010000  // option 'transmit data copy in ram'
#define DF_INOS_BUS_OPTIONEX_LOOPBACK               0x00020000  // option 'ginlink in loopback mode'
#define DF_INOS_BUS_OPTIONEX_HARDWARE_SLOTCOUNT     0x00040000  // option 'ginlink in hardware slot count mode'
#define DF_INOS_BUS_OPTIONEX_MULTIPLE_INSTANCE_SUPPORT  0x00080000  // option 'multiple bus type instances supported'
//
#define DF_INOS_BUS_SYNCTOLERANCE_DEFAULT       2000        // default sync tolerance [ns]
#define DF_INOS_BUS_WATCHDOGLEVEL_DEFAULT       4           // default watchdog level
//
// --- inos bus errors ---------------------------------------------------------  
//
#define ER_INOS_BUS_ERRORCOUNTER    0x00000001  // error counter
#define ER_INOS_BUS_OVERRUNCOUNTER  0x00000002  // overrun counter
#define ER_INOS_BUS_DOWN            0x00000004  // bus down
#define ER_INOS_BUS_POSTOVERRUNCOUNTER 0x00000008// post overrun counter
#define ER_INOS_BUS_SYNCCORES_TIMEOUT  0x00000010// SyncCores with timeout waiting for the other core(s)
#define ER_INOS_BUS_RESCAN          0x00000020// bus rescan was performed
#define ER_INOS_BUS_MAINTENANCE     0x00000040// maintenance overrun counter
//
// --- inos bus hook flags -----------------------------------------------------  
//
#define DF_INOS_BUS_HOOK_FLAG_ENB   0x0001      // bus hook enabled
#define DF_INOS_BUS_HOOK_FLAG_REM   0x0002      // bus hook has to be removed
//
// --- inos bus hook priorities ------------------------------------------------  
//
#define DF_INOS_BUS_HOOK_ORDER_PRE_AXIS -20     
#define DF_INOS_BUS_HOOK_ORDER_AXIS_PRE_MAP -10 
#define DF_INOS_BUS_HOOK_ORDER_AXIS_MAP     0   
#define DF_INOS_BUS_HOOK_ORDER_CONTROL      0   
#define DF_INOS_BUS_HOOK_ORDER_AXIS_PST_MAP 10  
#define DF_INOS_BUS_HOOK_ORDER_PST_AXIS 20      
#define DF_INOS_BUS_HOOK_ORDER_DEFAULT  20      
//
// --- inos bus page types -----------------------------------------------------
//
#define DF_INOS_BUS_PAGE_ANALOG     1           // bus page analog
#define DF_INOS_BUS_PAGE_DIGITAL    2           // bus page digital
#define DF_INOS_BUS_PAGE_AXIS       3           // bus page axis
//
//------------------------------------------------------------------------------
// macros
//------------------------------------------------------------------------------
//  
/*  CycleId :
 
     15        10 9 8 7             0
     --------------------------------
     |           |   |              |
     --------------------------------
           |       |         |
           |       |         cycle number (0..255)
           |       category (0..3)
         core id (0..63)
*/
 
#define INOS_CYCLEID(auCoreId, auCategory, auCycleNumber) (((uint16)auCoreId<<10)+((uint16)auCategory<<8)+(auCycleNumber&0xff))
#define INOS_CORE_FROM_CATEGORY(aCategory) ((aCategory>>2)&0x3F)    
#define INOS_CATEGORY_FROM_CATEGORY(aCategory) (aCategory&0x03)     
#define INOS_CORE_FROM_CYCLEID(aCycleId) ((uint8)((aCycleId>>10)&0x3F))     
#define INOS_CATEGORY_FROM_CYCLEID(aCycleId) ((uint8)((aCycleId>>8)&0x03))      
#define INOS_CYCLENUMBER_FROM_CYCLEID(aCycleId) ((uint8)(aCycleId&0xFF))        
 
#define INOS_CYCLEID_DONT_CARE (0xffff) 
#define INOS_CORE_ID_DONT_CARE (0x3f)   
 
#define INOS_CYCLEID_ANY_CAT_AND_NUM  ((uint16)0x03ff)   
 
#define INOS_CYCLEID_ANY_ON_CORE(auCoreId) (((uint16)auCoreId<<10) | INOS_CYCLEID_ANY_CAT_AND_NUM)
 
 
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//  
// system
#include <inos.h>
#include <cinosbushooks.h>
#include <cinosbusjob.h>
#include <cinosbusmodule.h>
//  
// C++
#include <atomic>
#include <xmlparser.h>
//  
// project
//  
//------------------------------------------------------------------------------
//--- structures ---------------------------------------------------------------
//------------------------------------------------------------------------------
//
struct SINOSBus
    //; structure of INOS-BUS database table
{
    inosName32 m_cName;
        //; bus name
    inosName m_cType;
        //; inos bus type name
    uint32 m_uOffset;
        //; bus offset in process image
    uint16 m_uMainCycleTime;
        //; bus main cycle time in us (0-don't care)
    uint16 m_uWaitAfterReset;
        //; time [us] to wait after reset
    uint16 m_uScanMaxWaitForBus;
        //; max. waiting time [ms] until bus comes up (e.g. link closed)
    uint16 m_uScanMaxWaitForModules;
        //; max. waiting time [ms] until modules ready (e.g. IMP-MAS)
    uint16 m_uStackSize;
        //; stack size of bus task
    uint16 m_uMaxEepromSize;
        //; max. size of module eeproms [bytes]
    uint32 m_uOptions;
        //; Bit 0 : 0-no floatingpoint support, 1-floatingpoint support
        //; Bit 1 : 0-has 1ms handler, 1-no 1ms handler
        //; Bit 2 : 0-standard sub cycle, 1-splitted subcycle (for heavy loads)
        //; Bit 3 : 1-stop bus in case of overrun
        //; Bit 4 : 1-ignore slave mac address
        //; Bit 5 : 1-run with disabled irq's
        //; Bit 6 : 1-no inco communication support
        //; Bit 7 : 1-has cycle categories
        //; Bit 8 : 1-no post handler task requested
    uint8 m_uPriority;
        //; bus task priority
    uint8 m_uId;
        //; bus id (0, 1, ...)
    uint8 m_uInstance;
        //; bus type instance (GinLink0, Ginlink1, ...)
    uint8 m_uCores;
        //; number of cores used by the bus
    uint8 m_uCoreId;
        //; base core id (virtual core id of first core)
    uint32 m_uMaxHooks;
        //; max. number of hooks supported
    uint8 m_uScanIncludeModuleName;
        //; include module name in process image channel name (0-no, 1-yes)
    uint32 m_uOptionsEx;
        //; Bit 0 : 1-optimized port handling
    uint32 m_uMaxChannelsPerModule;
        //; max. number of 32 bit channels per bus module
    uint32 m_uMaxBitsPerModule;
        //; max. number of bit channels per bus module (e.g. digital inputs/outputs)
    uint32 m_uCycleTimeCat[DF_INOS_BUS_MAX_CATEGORY];
        //; requested categoy cycle times
    uint8 m_uCycleTimePage[DF_INOS_BUS_MAX_CATEGORY];
        //; requested page number per category
    uint8 m_uCycleTimeOversampling[DF_INOS_BUS_MAX_CATEGORY];
        //; requested oversampling per category
    uint32 m_uErrorMask;
        //; error mask: defines which errors shall be reported and which shall
        //; be ignored.
    uint8 m_uSyncType;
        //; syncing type(0-none, 1-master, 2-sync to master, 3- sync to time)
    uint32 m_uSyncOffset;
        //; syncing offset [ns] within a 1ms cycle (0xffffffff -> don't care)
    uint32 m_uSyncTolerance;
        //; syncing tolerance [ns] within a 1ms cycle (default = 2000)
    uint32 m_uWatchdogLevel;
        //; number of missing frames till category watchdog (default = 4)
    uint32 m_uHookFreeze;
        //; hook freeze trigger time [ns] (default = 0)
};
//  
struct SINOSBusHandler
{
    uint8 m_uCommand;
    uint8 m_uReserved[sizeof(uintptr)-1];
};
//
struct SINOSBusHandlerPort : public SINOSBusHandler
{
    uintptr m_uAddress;
};
//
struct SINOSBusHandlerCall : public SINOSBusHandler
{
    void* m_pObject;
    void* m_pMethod;
    uint32 m_uParam;
};
//
struct SINOSBusHandlerBuffer
{
    enum {
        eSize16 = 0x00000001,
        eSize32 = 0x00000000,
        eSizeMask = 0x00000001
    };
    enum {
        eCmdPort = 0x00,
        eCmdCall = 0x01
    };
    // add port read 16
    void AddPort16(volatile void* apAddress)
    {
        // avoid buffer overflows
        ASSERT_ALWAYS((m_uWriteIndex+sizeof(SINOSBusHandlerPort))<=sizeof(m_cData));
        // ensure no address conflict
        ASSERT_ALWAYS(((uintptr)apAddress & eSizeMask) == 0);
        // set values
        SINOSBusHandlerPort* p = (SINOSBusHandlerPort*)&m_cData[m_uWriteIndex];
        p->m_uCommand = eCmdPort;
        p->m_uAddress = (uintptr) apAddress + eSize16;
        // adjust write index
        m_uWriteIndex += sizeof(SINOSBusHandlerPort);
    }
    // add port read 32
    void AddPort32(volatile void* apAddress)
    {
        // avoid buffer overflows
        ASSERT_ALWAYS((m_uWriteIndex+sizeof(SINOSBusHandlerPort))<=sizeof(m_cData));
        // ensure no address conflict
        ASSERT_ALWAYS(((uintptr)apAddress & eSizeMask) == 0);
        // set values
        SINOSBusHandlerPort* p = (SINOSBusHandlerPort*)&m_cData[m_uWriteIndex];
        p->m_uCommand = eCmdPort;
        p->m_uAddress = (uintptr) apAddress + eSize32;
        // adjust write index
        m_uWriteIndex += sizeof(SINOSBusHandlerPort);
    }
    #if defined(INOS_PORTS_64BIT)
    // add port read 64
    void AddPort64(volatile void* apAddress)
    {
        // avoid buffer overflows
        ASSERT_ALWAYS((m_uWriteIndex+sizeof(SINOSBusHandlerPort))<=sizeof(m_cData));
        // ensure no address conflict
        ASSERT_ALWAYS(((uintptr)apAddress & eSizeMask) == 0);
        // set values
        SINOSBusHandlerPort* p = (SINOSBusHandlerPort*)&m_cData[m_uWriteIndex];
        p->m_uCommand = eCmdPort;
        // not yet supported
        ASSERT_ALWAYS(0);
        // adjust write index
        m_uWriteIndex += sizeof(SINOSBusHandlerPort);
    }
    #endif
    // add call
    void AddCall(void* apObject, void* apMethod, uint32 auParam = 0)
    {
        // avoid buffer overflows
        ASSERT_ALWAYS((m_uWriteIndex+sizeof(SINOSBusHandlerCall))<=sizeof(m_cData));
        // method pointer needs to be valid
        ASSERT_ALWAYS(apMethod != nullptr);
        // set values
        SINOSBusHandlerCall* p = (SINOSBusHandlerCall*)&m_cData[m_uWriteIndex];
        p->m_uCommand = eCmdCall;
        p->m_pObject = apObject;
        p->m_pMethod = apMethod;
        p->m_uParam = auParam;
        // adjust write index
        m_uWriteIndex += sizeof(SINOSBusHandlerCall);
    }
    // return true if buffer is empty
    bool IsEmpty()
    {
        // check write index
        return m_uWriteIndex==0;
    }
    // return true if buffer is empty
    void Reset()
    {
        // reset write index
        m_uWriteIndex = 0;
        // temporary data
        memset(m_uTemporary, 0, sizeof(m_uTemporary));
        // and the whole buffer
        memset(m_cData, 0, sizeof(m_cData));
    }
 
    // constructor
    SINOSBusHandlerBuffer()
    {
        // reset buffer
        Reset();
    }
    uint32 m_uWriteIndex;
    uint32 m_uTemporary[2];
    #if defined(INOS_64)
    char m_cData[0x8000-3*sizeof(uint32)];
    #else
    char m_cData[0x4000-3*sizeof(uint32)];
    #endif
    // allow dynamic handling
    DECLARE_DYNAMIC(SINOSBusHandlerBuffer);
};
struct SINOSBusInfoHook {
    void* m_pHandler;
        //; pointer to hook handler
    void* m_pObject;
        //; pointer to hook object
    uint32 m_uTimeBase;
        //; global time base
 
    // allow dynamic handling
    DECLARE_DYNAMIC(SINOSBusInfoHook);
};
struct SINOSBusTiming {
    uint16 m_uCatActCycle{};
    uint32 m_uOverrunCounter{};
 
    uint32 m_uAct{};
    uint32 m_uMin{};
    uint32 m_uMax{};
    uint32 m_uAllowed{};
    uint32 m_uOverrunCounterDisabled{};
    bool m_bOverrunDetectedByIrq{};
 
    std::atomic<uint32> m_uHooks{};
 
    #ifdef INOS_ADDITIONAL_BUS_TIME_MEASUREMENTS
    bool m_bWtgLastTicksValid{};
    uint32 m_uWtgLastTicks{};
    uint32 m_uWtgDeltaAct{};
    uint32 m_uWtgDeltaMin{};
    uint32 m_uWtgDeltaMax{};
 
    SINOSBusInfoHook m_Hook[DF_INOS_BUS_INFO_MAX_HOOKS]{};
    #endif
    
    // allow dynamic handling
    DECLARE_DYNAMIC(SINOSBusTiming);
};
struct SINOSBusPostTiming {
    uint32 m_uPostOverrunCounter;
    bool m_bValid;
    uint32 m_uSuspendTicks;
    int32 m_uAct;
    uint32 m_uMax;
    uint32 m_uAllowed;
 
    uint32 m_uPostHooks;
 
    #ifdef INOS_ADDITIONAL_BUS_TIME_MEASUREMENTS
    SINOSBusInfoHook m_PostHook[DF_INOS_BUS_INFO_MAX_HOOKS];
    #endif
 
    // allow dynamic handling
    DECLARE_DYNAMIC(SINOSBusPostTiming);
};
//
struct SINOSCatInfo {
    uint32 m_uCycleTimeCat;
    uint32 m_uWatchdogCount;
    uint32 m_uWatchdogCountMax;
    uint32 m_uWatchdogLevel;
 
    SINOSBusTiming m_CycleTiming[DF_INOS_MAX_CORES];          // array of bus timing
    SINOSBusPostTiming m_CyclePostTiming[DF_INOS_MAX_CORES];  // array of bus 'post' timing
};
//
struct SINOSBusInfo {
    
    std::atomic<uint32> m_uOverrunCounter;
        //; overrun counter
    uint32 m_uOverrunCounterReported;
        //; overrun counter as reported by calling SetError. It's required to
        //; avoid that "the same overrun count" is reported multiple times when
        //; the according error is being accepted.
        //; This member is currently not used by the "category specific info"
        //; instances, but it has been added here non the less (as adding new
        //; members to CINOSBus is always a bit risky due to INFOLink.s)
    std::atomic<uint32> m_uPostOverrunCounter;
 
    SINOSBusTiming      m_CycleTiming;
        //; Used to store the "bus timing"
    SINOSBusPostTiming  m_CyclePostTiming;
        //; Used to store the "bus post timing"
 
    // allow dynamic handling
    DECLARE_DYNAMIC(SINOSBusInfo);
};
struct SBusSleeper {
    enum EReservedCounts {
        eAlreadySignaled = 0
    };
    SBusSleeper(uint32 auBusTicks, bool abClocked = false);
    CINOSSync m_pSync;
    uint32 m_uBusTicks;
    bool m_bClocked;
    SBusSleeper* m_pNext;
    static uint64 s_uClockedTickCount;
    static void AddSleeper(SBusSleeper& aNewSleeper, SBusSleeper*& apFirstSleeper);
    static void RemoveSleeper(SBusSleeper& aNewSleeper, SBusSleeper*& apFirstSleeper);
    static void HandleSleepers(SBusSleeper*& apFirstSleeper);
};
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//  
struct SINOSBusPort;
class CINOSBusPort;
class CINOSBusModule;
class CINOSBus : public CINOSTask
{
    friend void _INI_0299_CINOSBus();
    
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        virtual uint32 ContactModule(uint32 auAddress, uint32 auData);
            //; contact module with 'aAddress' 
        virtual CINOSBusModule* Find(char* apName);
            //; return pointer to module with name 'apName'
        virtual CINOSBusModule* Find(uint32 auNumber);
            //; return pointer to module 'auNumber' (if pointer = 0 -> last reached)
        virtual CINOSBusModule* FindFromAddress(uint32 auAddress);
            //; return pointer to module with given address
        virtual CINOSBusModule* FindFromBusNr(uint32 auBusNr);
            //; return pointer to module with given address
        virtual uint8 GetBusNr(uint32 auVirtualAddress)
            { return (uint8) auVirtualAddress;};
        virtual bool IsBusTask(CINOSTask* apTask)
            { return apTask == this; };
            //; return true if given task is a bus relevant task
        inline bool IsSimulated()
            { return m_pDesc && (m_pDesc->m_uOptions & DF_INOS_BUS_OPTION_SIMULATED); };
            //; return true if given task is a bus relevant task
        CINOSBusModule* FindFromDigInp(const char* apName);
            //; return pointer to module handling the digital input 'apName'
        CINOSBusModule* FindFromDigOut(const char* apName);
            //; return pointer to module handling the digital output 'apName'
        CINOSBusJob* FindJob(uint32 auTraAddress);
            //; find job with trans address auTraAddress
        static CINOSBus* FindBus(char* apName);
            //; return pointer to inos bus with name 'apName'
        static CINOSBus* FindBus(uint32 auId);
            //; return pointer to inos bus with id 'auId'
        static CINOSBusPort* FindPortFromInp(uint32 auNumber);
            //; get bus port handling digital input 'auNumber
        static CINOSBusPort* FindPortFromOut(uint32 auNumber);
            //; get bus port handling digital output 'auNumber
        inline static CINOSBus* GetFirstBus() {
            return s_pFirstBus;
        }
        static uint8 GetFirstBusId();
        static void AddBus(uint32 auId, CINOSBus* apBus);
        static void SetTargetError();
            //; will be called on a target error (e.g. trap, assert, etc.). will stop
            //; the bus if ActualTak() is a bus task and the failure is 'assert'.
        virtual void Start(uint32 auState = DF_INOS_BUS_STAT_RUN){};
            //; start up field bus  
        virtual void Stop(){};
            //; stop field bus  
        virtual void Reset(){};
            //; reset field bus 
        virtual void RegisterOversampling(uint32 auCycleTimeNs, uint8 auOversampling);
            //; register oversampling factor for auCycleTime
            //; NOTE: Generally, auCycleTime must be provided in microseconds,
            //;       but some subclasses (Like GinLink, but not COPBus) may
            //;       support nanoseconds as well.
 
        virtual uint32 RegisterHook(uintid& auHookId, void* apHandler, void* apObject = 0,
            uint32 auCycleTime = 0, uint16 auCycleId = INOS_CYCLEID_DONT_CARE,
            int32 aiOrder = DF_INOS_BUS_HOOK_ORDER_DEFAULT,
            uint32 auFlags = CINOSBusHook::eFlgEnabled);
 
        virtual uint32 RegisterPostHook(uintid& auHookId, void* apHandler, void* apObject = 0,
            uint32 auCycleTime = 0, uint16 auCycleId = INOS_CYCLEID_DONT_CARE,
            int32 aiOrder = DF_INOS_BUS_HOOK_ORDER_DEFAULT,
            uint32 auFlags = CINOSBusHook::eFlgEnabled);
 
        uint32 RegisterErrorHook(uintid& auHookId, void* apHandler, void* apObject = 0);
 
        virtual uint32 UnRegisterHook(uintid auHookId);
 
        virtual uint32 UnRegisterPostHook(uintid auHookId);
 
        uint32 UnRegisterErrorHook(uintid auHookId);
 
        uint32 EnableHook(uintid auHookId);
 
        uint32 DisableHook(uintid auHookId);
 
        void* GetHookHandler(uintid auHookId);
 
        uint32 SetHookHandler(uintid auHookId, void* apHandler);
 
        uint8 GetHookCycleNumber(uintid auHookId);
 
        uint32 GetHookCycleTime(uintid auHookId);
 
        virtual const char* GetCategoryName(
            const uint32 auCategory) const;
            //; \return The name of the task for the category. The returned 
            //;  pointer is guaranteed to be valid, as long as the bus exists
            //;  (and can therefore directly be used to be registered in the
            //;  INCOtree)
        virtual const CINOSTask* GetCategoryTask(
            const uint32 auCategory) const;
            //; \return The pointer to the task handling the category
        uint32 GetState()
            { return m_uState;};
            //; get bus state
        uint32 GetActCycle()
            { return m_iActCycle; };
            //; return actual sub cycle
        virtual uint16* GetActCycleAdr(uint8 auCategory)
            { return (uint16*) &m_iActCycle; };
            //; return sub cycle address
        virtual uint16 GetActCycleId()
            { return 0xffff; };
            //; return actual cycle id (this method only delivers correct
            //; results if called from within a bus hook)
        uint32 GetHeartBeat()
            { return m_uHeartBeat;};
            //; get bus heart beat
        uint32 GetSubCycles()
            { return m_uSubCycles;};
            //; get bus heart beat
        virtual void SetErrorCounter(uint32 auErrorCounter)
            { m_uErrorCounter = auErrorCounter;};
            //; set bus error counter
        virtual uint32 GetErrorCounter()
            { return m_uErrorCounter;};
            //; get bus error counter
        void SetOverrunCounter(uint32 auOverrunCounter)
            { m_Info.m_uOverrunCounterReported = m_Info.m_uOverrunCounter = auOverrunCounter;};
            //; set overrun counter. also sets "overrun counter reported" to
            //; the same value. this avoids that an error will be reported,
            //; when the counter is e.g. reset to 0.
        uint32 GetOverrunCounter()
            { return m_Info.m_uOverrunCounter;};
            //; get overrun counter
        void SetPostOverrunCounter(uint32 auPostOverrunCounter)
            { m_Info.m_uPostOverrunCounter = auPostOverrunCounter;};
            //; set post overrun counter
        uint32 GetPostOverrunCounter()
            { return m_Info.m_uPostOverrunCounter;};
            //; get post overrun counter
        virtual void DiagnosticOn();
            //; switch to diagnostic mode
        virtual void DiagnosticOff();
            //; switch back to run mode   
        const char* GetType() {
            if (m_pDesc) return m_pDesc->m_cType; else return nullptr;
        }
        virtual uint16 GetOffset(bool abReal = true) { if (m_pDesc) return (uint16)m_pDesc->m_uOffset; else return 0; }
            //; return bus offset
        uint8 GetId() { if (m_pDesc) return m_pDesc->m_uId; else return 0; }
            //; return bus id
        uint32 GetOptions() { if (m_pDesc) return m_pDesc->m_uOptions; else return 0; }
            //; return bus options
        uint16 GetOptionsEx() { if (m_pDesc) return m_pDesc->m_uOptionsEx; else return 0; }
            //; return bus extended options
        void SetOptionsEx(uint16 auOptions)
            { if (m_pDesc) m_pDesc->m_uOptionsEx |= auOptions; }
            //; set extended options
        void ClrOptionsEx(uint16 auOptions)
            { if (m_pDesc) m_pDesc->m_uOptionsEx &= (uint16) ~auOptions; }
            //; clear extended options
        uint64 GetTickCount();
            //; return actual bus tick counter
        uint64* GetTickCountAdr()
            //; return bus tick counter address
            { return &m_uTickCount; };
        void SetTickCount(uint64 auTicks);
            //; set actual bus tick counter
        virtual uint32 GetTickTime() { return m_uSubCycleTime; }
            //; return number of us one bus tick takes
        virtual uint32 GetTickTimeNs() 
            { 
                if (m_uSubCycleTimeNs)
                    return m_uSubCycleTimeNs;
                else
                    return m_uSubCycleTime*1000;
            }
            //; return number of ns one bus tick takes
        uint32 GetMainCycleTime() { return m_uMainCycleTime; }
            //; return number of us a main cycle takes
        uint32 GetMainCycleTimeNs() 
            { 
                if (m_uMainCycleTimeNs)
                    return m_uMainCycleTimeNs;
                else
                    return m_uMainCycleTime*1000;
            }
            //; return number of ns a main cycle takes
        virtual uint32 GetSubCycleTime(uint8 auCategory=0) { return m_uSubCycleTime; }
            //; return number of us a sub cycle takes
        virtual uint32 GetSubCycleTimeNs(uint8 auCategory=0) { return GetTickTimeNs(); }
            //; return number of ns a sub cycle takes
        uint32 GetError() { return m_uError; };
            //; return actual bus errors
        void SetErrorMask(uint32 auMask) { m_uErrorMask = auMask;};
            //; set error mask and return old mask
        uint32 GetErrorMask() { return m_uErrorMask;};
            //; get actual error mask
        void AcceptError(uint32 auError = 0xffffffff);
            //; accept error            
        uint8 GetScanIncludeModuleName() { return m_pDesc->m_uScanIncludeModuleName; }     
            //; return value of flag 'm_uScanIncludeModuleName'
        uint16 GetScanMaxWaitForBus() { return m_pDesc->m_uScanMaxWaitForBus; }     
            //; return value of 'm_uScanMaxWaitForBus'
        uint16 GetScanMaxWaitForModules() { return m_pDesc->m_uScanMaxWaitForModules; }     
            //; return value of 'm_uScanMaxWaitForModules'
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with aName to aResult and return error code
        virtual void ResetMeasure();
            //; reset cpu load measurement
        virtual void SyncBus(uint32 auCmdOffset);
            //; sync bus to given offset
        virtual void Accelerate(){};
            //; accelerate bus cycle
        virtual void Decelerate(){};
            //; decelerate bus cycle
        virtual void Exactelerate(){};
            //; exactelerate bus cycle
        real64 GetTimebase(uint32 auHigh, uint32 auLow);
            //; return CPU timebase [ms] at bus tick auHigh|auLow
        virtual uint8 GetCategory(CINOSBusPort* apPort);
            //; get category number apPort belongs to
        virtual uint8 GetFastestCategory()
            { return 0;};
            //; get fastest category number
        uint32 GetCategoryNs(CINOSBusPort* apPort);
            //; get category ns of apPort
        virtual uint8 GetCategory(SINOSBusPort* apPort);
            //; get category number apPort belongs to
        uint8 GetCategory(uint32 auCycleTimeNs, bool abAssertOnError = true);
            //; get category of auCycleTime
        uint32 GetCategoryNs(uint8 auCategory);
            //; get ns of auCategory
        uint16 GetCycleId(CINOSBusPort* apPort);
            //; get cycle id of the port
        uint8 GetPage(CINOSBusPort* apPort);
            //; get page number apPort belongs to
        uint8 GetPage(uint32 auCycleTimeNs);
            //; get page number auCycleTimeNs belongs to
        uint32 ConvertToNs(uint32 auValue);
            //; convert auValue to Ns (if the value is <= 1000, we assume us if
            //; it is > 1000 we assume ns)
        virtual uint16 GetCycleId(const char* apName);
            //; get cycle id of process image channel named apName
        virtual uint32 GetCycleTimeNs(const char* apName);
            //; get cycle time [ns] of process image channel named apName
        virtual void Sleep(uint32 auBusTicks) 
            { ASSERT_ALWAYS(0 && "Not implemented for this bus type"); }
            //; let the caller task sleep for auBusTicks bus ticks. If a
            //; bus has several categories (such as ginlink), 1 bus tick
            //; equals to the highest active category.
            //; \param auBusTicks The amount of bus ticks to elapse until
            //;  the function returns. If a bus tick immediately occurs
            //;  after start waiting, the caller will be woken up. IOW:
            //;  if passing a value of 1 and the bus cycle time is 250us
            //;  the caller will sleep between 0..250us.
        virtual void SleepClocked(uint32 auBusTicks)
            { ASSERT_ALWAYS(0 && "Not implemented for this bus type"); }
            //; let the caller task sleep until the bus tick counter
            //; reaches a multiple of auBusTicks. If a
            //; bus has several categories (such as ginlink), 1 bus tick
            //; equals to the highest active category.
            //; This can be used for simple time slice mechanisms where
            //; e.g. every iteration of a loop is expected to take equally
            //; long. IOW:
            //;  if passing a value of 1 and the bus cycle time is 250us
            //;  the caller will sleep between 0..250us, and more precisely
            //;  will wake up at the next 250us tick.
 
        virtual void FlushCache(uint8 auCategory) {};
            //; flush cache. useful for post hooks under special conditions
 
        virtual CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
 
        virtual CINCOObject* GetModulesObj() {
            // ensure it is created
            GetRegister();
            return m_pModules;
        }
 
        uint8 GetCoreCount() const {
            return m_uCores;
        }
 
        INOS_INLINE void AtomicGatherEnter(uint32& ouToken) {
            ouToken = m_uAtomicGather;
            INOSOptimizationBarrier();
        }
        INOS_INLINE bool AtomicGatherExit(uint32 auToken) {
            if (ActualTask()->GetTskType() != CINOSTask::eTskTypeRealtime) {
                INOSOptimizationBarrier();
                return (auToken == m_uAtomicGather) && !(m_uAtomicGather & 0x000000FF);
            } else {
                // never block a bus task, especially not yourself
                return true;
            }
        }
 
        bool IsWatchdogPending(uint8 auCategory)
        {
            // yes if watchdog count >= watchdog level
            return m_CatInfo[auCategory].m_uWatchdogCount >= m_CatInfo[auCategory].m_uWatchdogLevel;
        }
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSBusJob;
    friend class CINOSBusModule;
    friend class CINOSBusChannelHandler;
    friend class CINOSBits;
    friend class CINOSAdcChannels;
    friend class CINOSDacChannels;
    friend class CINOSPosChannels;
    friend class CINOSProcessImageChannel;
    friend class CINOSTaskEx;
    friend class CGINModuleIMP;
    friend void _INI_0399_CINOSBus();
    friend void _INI_0500_CINOSBus();
 
    // protected members
    protected :
        SINOSBus* m_pDesc;                  // pointer to bus descriptor
        uint32 m_uState;                    // bus state
        uint32 m_uError;                    // bus errors
        uint32 m_uErrorMask;                // bus error mask
        uint32 m_uHeartBeat;                // bus heart beat
        char  m_cStateMsg[32];              // bus state message
        uint32 m_uMainCycleTime;            // main cycle time [us]
        uint32 m_uMainCycleTimeNs;          // main cycle time [ns]
        uint32 m_uSubCycleTime;             // sub cycle time [us]
        uint32 m_uSubCycleTimeNs;           // sub cycle time [ns]
        uint16 m_uSubCycles;                // number of sub cycles
        int16 m_iActCycle;                  // number of actual cycle
        uint8 m_uCores = 1;
        uint32 m_uErrorCounter;             // field bus error counter
        CINOSBusModule* m_pFirst;           // pointer to first module in list
        uint32 m_uJobs;                     // number of jobs in array of job pointers
        uint32 m_uJobsMax;                  // max. number of jobs in array of job pointers
        CINOSBusJob** m_pJobs;              // pointer to array of job pointers
        uint32 m_uIndexes;                  // number of vertical indexes
        uint16* m_pIndexes;                 // pointer to 2 dim array of job indexes
        uint16 m_uVirtualCycleIndex;        // actual virtual cycle index
        static CINOSBus* s_pFirstBus;
        class CINOSBusChannelHandler* m_pChnHnd = nullptr;
 
        // inco registration        
        static CINCOObject* m_pFieldBus;    // inco registration 'FieldBus'
        CINCOObject* m_pRegister;           // inco registration 'Bus'
        CINCOObject* m_pModules;            // inco registration 'Bus.Modules'
        CINCOObject* m_pTiming;             // inco registration 'Bus.Timing'
        CINCOObject* m_pHooks{};            // inco registration 'Bus.hooks'
 
        CINOSTask* m_pPostTask;
        enum {
            eMainHooks = 0,
            ePostHooks = 1,
            eErrorHooks = 2,
        };
        CINOSBusHooks m_Hooks{eMainHooks};
        CINOSBusHooks m_PostHooks{ePostHooks};
        CINOSBusHooks m_ErrorHooks{eErrorHooks};
        
        // eeprom handling
        void* m_pEepromBuffer;              // pointer to eprom buffer (with size
                                            // of m_uMaxEepromSize bytes)
        // contact module                           
        uint32 m_uContactAdr;               // contact module address
        uint32 m_uContactDat;               // contact module data
        uint32 m_uContactRet;               // contact module return value
 
        // additional bus info
        SINOSBusInfo m_Info{};
        // additional bus per category. The array lenght is the "longer" of
        // DF_INOS_BUS_MAX_SUB_CYCLES and DF_INOS_BUS_MAX_CATEGORY, as the
        // array is used by both, category based and subcycle based busses,
        // such as GinLink and InfoLink.
        SINOSCatInfo m_CatInfo[DF_INOS_BUS_MAX_SUB_CYCLES];
 
        // pointer to list of rec bus handlers (single core)
        SINOSBusHandlerBuffer* m_pRecHnd[DF_INOS_BUS_MAX_CATEGORY];
        // pointer to list of rec bus handlers (multi core)
        SINOSBusHandlerBuffer* m_pRecHndM[DF_INOS_MAX_CORES][DF_INOS_BUS_MAX_CATEGORY][DF_INOS_BUS_MAX_CYCLE_NUMBER];
        // pointer to list of tra bus handlers (single core)
        SINOSBusHandlerBuffer* m_pTraHnd[DF_INOS_BUS_MAX_CATEGORY];
        // pointer to list of rec bus handlers (multi core)
        SINOSBusHandlerBuffer* m_pTraHndM[DF_INOS_MAX_CORES][DF_INOS_BUS_MAX_CATEGORY][DF_INOS_BUS_MAX_CYCLE_NUMBER];
 
        // ticks
        uint64 m_uTickCount;                // actual tick count
        uint64 m_uTimebase;                 // actual cpu timebase at last tick
 
        // virtual address handling
        CINOSMutex m_VirtualAddressMutex;
        uint32 m_uVirtualAddressMask[8] = {0};
        uint8 m_uVirtualAddressCounter = DF_INOS_BUS_MOD_VADDR_MIN;
 
 
        friend class CINOSMcTargetKernelLogger;
        // tasklog trigger for overruns
        enum {
            eTskLogTriggerOverrun = 0x01,
            eTskLogTriggerPostOverrun = 0x02,
        };
        uint8 m_uTasklogTriggerFlags{};
        uint8 m_uTasklogTriggerPercent{50};
        void EnableTasklogTriggerOverrun(uint8 auPercent)
            {
                m_uTasklogTriggerFlags |= eTskLogTriggerOverrun;
                m_uTasklogTriggerPercent = auPercent;
            }
        void DisableTasklogTriggerOverrun()
        {
            m_uTasklogTriggerFlags &= ~eTskLogTriggerOverrun;
        }
        void EnableTasklogTriggerPostOverrun(uint8 auPercent)
            {
                m_uTasklogTriggerFlags |= eTskLogTriggerPostOverrun;
                m_uTasklogTriggerPercent = auPercent;
            }
        void DisableTasklogTriggerPostOverrun()
        {
            m_uTasklogTriggerFlags &= ~eTskLogTriggerPostOverrun;
        }
 
        // bus syncing
        enum {
            eBusSyncOff,
            eBusSyncOk,
            eBusSyncAccelerate,
            eBusSyncDecelerate
        } m_eBusSync = eBusSyncOff;
        enum EBusSyncType {
            eBusSyncNone = 0,
            eBusSyncMaster = 1,
            eBusSyncToMaster = 2,
            eBusSyncToUTC = 3
        } m_eBusSyncType = eBusSyncNone;
        enum {
            eBusSyncFilterLength = 16,
            eBusSyncFilterShift = 4,
            eBusSyncFilterMask = eBusSyncFilterLength-1,
        };
        uint8 m_uBusSyncIndex = 0;
        int32 m_iBusSyncFilter[eBusSyncFilterLength] = {0};
        int32 m_iBusSyncFilterSum = 0;
        int32 m_iBusSyncDelta = 0;
        uint32 m_uBusSyncOffset = 0;
        int32 m_iBusSyncTolerance = DF_INOS_BUS_SYNCTOLERANCE_DEFAULT;
        uint32 m_uBusSyncOk = 0;
        uint32 m_uBusSyncAccelerate = 0;
        uint32 m_uBusSyncDecelerate = 0;
        static uint64 m_uBusSyncMaster;
        void SyncBusOn();
        void SyncBusOff();
 
        uint8 VirtualAddressAlloc();
        void VirtualAddressFree(uint8 auAddress);
        bool VirtualAddressCheck(uint8 auAddress);
 
    // creation
    public :
        explicit CINOSBus(SINOSBus* apDesc);
            //; inos bus constructor
        virtual ~CINOSBus();
 
    // public members but just for internal use)
    public :
        virtual uint32 SetState(uint32 auState);
            //; set bus state and state message and return stae before
        void SetHeartBeat(uint32 auHeartBeat)
            {m_uHeartBeat = auHeartBeat;}; 
            //; set bus heart beat
        uint32 GetVirtualCycleIndex();
            //; return auto generated virtual cycle index
        virtual void Add(CINOSBusModule* apModule);
            //; add inos bus module
        virtual void Remove(CINOSBusModule* apModule);
            //; remove inos bus module
        virtual void RemoveAll();
            //; remove all modules
        virtual void Scan(){};
            //; scan field bus
        virtual void Prepare();
            //; prepare field bus jobs
        virtual void PostPrepare();
            //; called after field bus prepare
        virtual void Initialyse();
            //; initialyse field bus
        virtual bool InitDone();
            //; return true if initialisation of bus is done
        virtual bool IsDynamic()
            { return false;};
            //; return true if startup sequence is dynamic
        virtual bool IsCategoryBased()
            { return false;};
            //; return true if bus is category based (e.g. ginlink)
 
    // protected member functions
    protected :
        uint32 GetRealCycleIndex(uint32 auVirtualCycle);
            //; return real cycle index of virtual index auVirtualCycle
        void SortJobs();
            //; do job sort
 
        // eeprom handling routines
        
        void* RequestEepromBuffer();
            //; get pointer to eeprom buffer
        void ReleaseEepromBuffer(void* apBuffer);
            //; release  pointer to eeprom buffer
 
        void HandleDownSampling();
            //; handle down sampling
        SINOSBusHandlerBuffer* HandlerBufferPrepare(SINOSBusHandlerBuffer*& apBuffer);
            //; prepare buffer handler
        void HandlerBufferDone(SINOSBusHandlerBuffer*& apBuffer, SINOSBusHandlerBuffer* apNew);
            //; set new handler buffer pointer
        bool HandlerBufferEqualContent(SINOSBusHandlerBuffer* apBuffer1, SINOSBusHandlerBuffer* apBuffer2);
            //; compare two buffers
        void HandlerBufferSetup();
            //; setup all rec and tra handler lists
        void HandlerBufferSetupRec(uint8 auCategory=0);
            //; setup receive data
        ICACHE void HandleRecData(uint8 auCategory=0);
            //; handle receive data
        void HandlerBufferSetupRecM(uint16 auCycleId);
            //; setup receive data (multicore)
        ICACHE void HandleRecDataM(uint16 auCycleId);
            //; handle receive data (multicore)
        void HandlerBufferSetupTra(uint8 auCategory=0);
            //; setup trans data
        ICACHE void HandleTraData(uint8 auCategory=0);
            //; handle trans data
        void HandlerBufferSetupTraM(uint16 auCycleId);
            //; setup trans data (multicore)
        ICACHE void HandleTraDataM(uint16 auCycleId);
            //; handle trans data (multicore)
        static void HandleRecBuffer(SINOSBusHandlerBuffer* apHnd);
            //; handle rec port handler list
        static void HandleTraBuffer(SINOSBusHandlerBuffer* apHnd);
            //; handle tra port handler list
        ICACHE void HandleHooks(uint8 auCategory = 0);
            //; handle inos bus hooks
        ICACHE void HandlePostHooks(uint8 auCategory = 0, bool abWakeupPostTask = true);
            //; handle inos bus post hooks
        void iHandlePostHooks();
            //; handle inos bus post hooks
        virtual uint32 iRegisterHook(uintid& auHookId, CINOSBusHooks& aHooks, void* apHandler, void* apObject,
            uint32 auCycleTime, uint16 auCycleId, int32 aiOrder, uint32 auFlags);
        virtual void iiHandlePostHooks();
            //; handle inos bus post hooks
            
        // cpu load measurement
        void Measure();
            //; measure cpu load (from task Resume till now)
        
        void SetError(uint32 auErrors);
            //; set bus error (and call error hook if nessecary)
 
        void RegisterHooks();
 
        INOS_INLINE void AtomicGatherBeginUpdate() {
            // increment task and update counter
            INOS_ADD(m_uAtomicGather,  0x00000101);
        }
        INOS_INLINE void AtomicGatherEndUpdate() {
            // decrement task counter
            INOS_ADD(m_uAtomicGather, -0x00000001);
        }
 
    // protected members
    protected :
        uint32 m_uAtomicGather = 0x00000000;
 
    // public members but just for internal use)
    public :
        uint32 GetChannelBase(uint16 auAddress);
        uint32 GetBitBase(uint16 auAddress);
 
    // processimage channel conflict supervision
    protected :
        static CINOSMutex m_ChnCheck;
        static bool m_bChkEnabled;
        static bool m_bChkPermanent;
        static uint8 m_uChkBusId;
        struct SCheck {
            uint32 m_uMin;
            uint32 m_uMax;
            CINOSTask* m_pTsk;
        };
        static SCheck m_Chk[DF_INOS_BUS_MAX_NUMBER];
        static void EnbCheck(bool abEnable)
            { m_bChkEnabled = abEnable; };
        static void ModSetup(uint8 auBusId);
        static void ChnCreate(uint32 auNumber);
        static void ConflictCheck();
        static void PermanentCheck()
            { m_bChkPermanent = true; };
};
 
//------------------------------------------------------------------------------
// class CINOSBusRegister 
//------------------------------------------------------------------------------
 
typedef CINOSBus* (*TCreateBus)(SINOSBus* apDesc);
 
class CINOSBusRegister 
{   
    friend void _INI_0000_CINOSBusRegister();
 
    //--- internals --------------------------------------------------------
 
    // private members 
    private:
        // pointer to the first registered inos bus
        static CINOSBusRegister* m_pFirst; 
        // pointer to the next inos bus
        CINOSBusRegister* m_pNext; 
        // create funtion for the inos bus
        TCreateBus m_pCreate;
        // bus type name 
        const char* m_pBusType;
        // database table name
        const char* m_pDatabaseTable;
        
    //--- user interface ---------------------------------------------------
 
    public:
        // register a new inos bus of type apType
        CINOSBusRegister(TCreateBus apCreate, const char* apBusType,
            const char* apDatabaseTable);
        
        // create and return a new inos bus instance
        static CINOSBus* GetBus(SINOSBus* apDesc);
        // create all registered busses
        static void CreateAll();
};  
 
//------------------------------------------------------------------------------
// class CINOSDeviceMap
//------------------------------------------------------------------------------
 
class CINOSDeviceMap 
{    
    #ifdef INOSV
    friend uint32 _INI_0201_CDEVICE_MAP_();
    #else
    friend void _INI_0201_CDEVICE_MAP_();
    #endif
    public: 
    
    // Type declaration
    
    enum EError {   
        eErrOk = 0,
        eErrDeviceNotFound = 1,
        eErrDeviceTypeNotSupported = 2, 
        eErrResultBufferTooSmall = 3,
        eErrDeviceNoAddress = 4,
        eErrDeviceNoName = 5,
    };    
    
    enum EDeviceType {
        eDevDontCare = 0,   
        eDevGin,
        eDevTypeLast
    };
 
    
    static EError GetDeviceAddress(const char* apName, char* apResult, uint32 auBufferLength);
    static EError GetDeviceAddress(const char* apName, uint32& auResult);
    static EError GetDeviceName(uint32 auAddress, char* apResult, uint32 auBufferLength);
    static EError GetDeviceNode(const char* apName, XMLNode& axResult);
    static EError GetDeviceNode(uint32 auAddress, XMLNode& axResult);
    
    static EError GetDeviceUid(uint64 auMacAddress, uint32 auDeviceAddress, uint32& auUid);
    static EError GetDeviceUid(XMLNode& aNode, uint64 auMacAddress, uint32 auDeviceAddress, uint32& auUid);
    static EError GetDeviceUid(uint64 auMacAddress, uint32 auProductCode, uint8 auIndex, uint32& auUid);
    static EError GetDeviceUid(XMLNode& aNode, uint64 auMacAddress, uint32 auProductCode, uint8 auIndex, uint32& auUid);
    static EError GetDevicePathByUid(uint32 auUid, char* apResult, uint32 auBufferLength);
 
    static EError GetDeviceName(XMLNode& aNode, uint32 auUid, char* apResult, uint32 auLength);
 
    private:
    static XMLNode m_sxDevices;
  
};
 
//
//------------------------------------------------------------------------------
// class CINCOpercent
//------------------------------------------------------------------------------
template <typename T>
class CINCOpercent : public CINCOdouble
{
    // constructor
    public:
        CINCOpercent(char* apName, T* apData)
            : CINCOdouble(apName, apData, 0, 0, "%", defCharShowFix + SHOW_DIGIT(2) + defCharReadOnly)
        {
        }
 
    // public member functions
    public:
        // item address = (long) pData + aIndex*sizeof(item) + aOffset
        virtual long Get(void* apDest, long& maxLength, long aIndex, long aOffset) override {
            // do we have already a pointer
            if (!pData) {
                // no
                *((double *) apDest) = 0;
                return 0;
            }
            else {
                // convert ticks to us
                T* pTiming = (T*) ((uintptr) pData + aIndex*GetConfig()->GetSize() + aOffset);
                double p = double(pTiming->m_uMax * 100) / double(pTiming->m_uAllowed);
                *((double *) apDest) = p;
            }
 
            // ok
            return 0;
            // end CINCOpercent::Get
        }
};
 
void SleepBusTicks(uint32 auBusTicks, uint32 auBusId = 0);
 
//  
//------------------------------------------------------------------------------
// global variables
//------------------------------------------------------------------------------
//
extern CINOSBus* g_pBus[DF_INOS_BUS_MAX_NUMBER];
extern CINOSBus* g_pBus2[DF_INOS_BUS_MAX_NUMBER];
extern uint32 g_uBusIndex;
//
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBUS_H