doxygen/inos/cinosbus_8h_source.html

//******************************************************************************

//******************************************************************************


#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>

#if defined(INOS_BUS_HOOKS)

#include <cinosbushooks.h>

#endif

#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

    #if defined(INOS_BUS_HOOKS)

    uint8 m_uCoreId;

        //; base core id (virtual core id of first core)

    uint32 m_uMaxHooks;

        //; max. number of hooks supported

    #endif

    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)

};


//


struct SINOSBusHook {

    // IMPORTANT : m_pNext HAS TO BE  the first entry !!!

    SINOSBusHook* m_pNxt;

        //; pointer to next hook in list

    SINOSBusHook* m_pPrv;

        //; pointer to previous hook in list

    SINOSBusHook* m_pPartner;

        //; pointer to partner hook in other list

    SINOSBusHook* m_pNxtRem;

        //; pointer to next hook in list of hooks to be removed

    void* m_pHandler;

        //; pointer to handler funtion

    void* m_pObject;

        //; pointer to handler object

    uintid m_uId;

        //; hood id (== pointer to first hook in partner list)

    uint16 m_uFlags;

        //; hook flags

    uint8 m_uCoreId;

        //; core id this hook has to run on

    uint8 m_uCat;

        //; category this hook belongs to

    uint8 m_uCycleNumber;

        //; cyclenumber this hook runs in

    int16 m_iOrder;

        //; hook order

    uint16 m_uMainCycles;

        //; hook has to be called every 'm_uMainCycles' main cycle

    uint32 m_uCycleTime;

        //; requested hook cycletime


    // allow dynamic handling

    DECLARE_DYNAMIC(SINOSBusHook);

};


//


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 {


    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)

    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.


        #if defined(INOS_BUS_HOOKS)

        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);

        #else

        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,

            bool abEnabled = true);


        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,

            bool abEnabled = true);

        #endif


        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);


        #if !defined(INOS_BUS_HOOKS)

        void ChangeHookId(uintid auOldHookId, uintid auNewHookId);

            //; set handler of hook 'auHookId'

        #endif


        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

        #if !defined(INOS_BUS_HOOKS)

        uint32 GetMainCycles()

            { return m_uMainCycles;};

        #endif

            //; 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

        #if !defined(INOS_BUS_HOOKS)

        uint16 m_uMainCycles;               // number of main cycles

        int16 m_iActMainCycle;              // number of actual main cycle

        #endif

        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'

        #if defined(INOS_BUS_HOOKS)

        CINCOObject* m_pHooks{};            // inco registration 'Bus.hooks'

        #endif


        CINOSTask* m_pPostTask;

        #if defined(INOS_BUS_HOOKS)

        enum {

            eMainHooks = 0,

            ePostHooks = 1,

            eErrorHooks = 2,

        };

        CINOSBusHooks m_Hooks{eMainHooks};

        CINOSBusHooks m_PostHooks{ePostHooks};

        CINOSBusHooks m_ErrorHooks{eErrorHooks};

        #else

        // hook handling

        CINOSMutex* m_pHookLock;

        SINOSBusHook** m_pHooks;

        SINOSBusHook** m_pPostHooks;

        SINOSBusHook* m_pErrorHooks;

        volatile SINOSBusHook* m_pToBeRemoved;

        static SINOSBusHook* s_pHooks[256];

        static std::atomic<uint8> s_uHooks;

        #endif


        // 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

        #if defined(INOS_BUS_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

        #else

        virtual uint32 iRegisterHook(uintid& auHookId, SINOSBusHook** apHooks, void* apHandler, void* apObject,

            uint32 auCycleTime, uint16 auCycleId, int32 aiOrder, bool abEnabled);

            //; register requested hook in apHooks list

        void iUnRegisterHook(uintid auHookId, bool abDestroyFirst = true);

            //; unregister requested hook from its list

        void iInsertHook(SINOSBusHook** apList, SINOSBusHook* apHook);

            //; remove hook from according hook list

        void iRemoveHook(SINOSBusHook* apHook, bool abDestroy = true);

            //; remove hook from according hook list

        void iDeleteHook(SINOSBusHook* apHook);

            //; delete hook

        bool iToBeRemoved(uintid auHookId);

            //; mark hook as 'to be removed'. \return true upon success, false

            //; otherwise (e.g. if no valid hook id was passed)

        #if defined(INOS_TESTING)

        friend class CINOSBusHookTestMaster;

        #endif

        void iCleanupHooks(bool abDestroyFirst = true);

            //; delete all hooks of the 'to be removed' hooks list

        #endif


        // 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)


        #if defined(INOS_BUS_HOOKS)

        void RegisterHooks();

        #endif


        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) {

            // 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

INOS_CYCLEID_DONT_CARE
#define INOS_CYCLEID_DONT_CARE
don't care cycle id
Definition cinosbus.h:172

DF_INOS_BUS_HOOK_ORDER_DEFAULT
#define DF_INOS_BUS_HOOK_ORDER_DEFAULT
bus hook order 'default'
Definition cinosbus.h:137

SleepBusTicks
void SleepBusTicks(uint32 auBusTicks, uint32 auBusId=0)

cinosbushooks.h
The CINOSBusHook class.

DF_INOS_BUS_MOD_VADDR_MIN
#define DF_INOS_BUS_MOD_VADDR_MIN
min. allowed virtual address
Definition cinosbusmoduledef.h:40

DECLARE_DYNAMIC
#define DECLARE_DYNAMIC(aClass)
Definition cinospartitionmemory.h:328

CINCOpercent
Definition cinosbus.h:1529

CINOSAdcChannels
Definition cinosadcchannels.h:78

CINOSBits
Definition cinosbits.h:73

CINOSBusHooks
Definition cinosbushooks.h:467

CINOSBusRegister
Definition cinosbus.h:1440

CINOSBus
Definition cinosbus.h:600

CINOSBus::AtomicGatherEnter
INOS_INLINE void AtomicGatherEnter(uint32 &ouToken)
Definition cinosbus.h:1035

CINOSBus::m_ChnCheck
static CINOSMutex m_ChnCheck
check mutex
Definition cinosbus.h:1405

CINOSBus::GetFirstBusId
static uint8 GetFirstBusId()
Return the id of the first valid bus, or 0 if none available.

CINOSBus::AtomicGatherBeginUpdate
INOS_INLINE void AtomicGatherBeginUpdate()
Definition cinosbus.h:1373

CINOSBus::RegisterPostHook
virtual uint32 RegisterPostHook(uintid &auHookId, void *apHandler, void *apObject=0, uint32 auCycleTime=0, uint16 auCycleId=(0xffff), int32 aiOrder=20, bool abEnabled=true)
Register post hook and return hook id. The registered function will be called in the context of the c...

CINOSBus::VirtualAddressFree
void VirtualAddressFree(uint8 auAddress)
free virtual module address

CINOSBus::s_pFirstBus
static CINOSBus * s_pFirstBus
Pointer to first valid bus, cached for faster access of "g_pBus[0]".
Definition cinosbus.h:1103

CINOSBus::EnbCheck
static void EnbCheck(bool abEnable)
enable/disable channel check
Definition cinosbus.h:1420

CINOSBus::UnRegisterHook
virtual uint32 UnRegisterHook(uintid auHookId)
Unregister hook with given id.

CINOSBus::IsWatchdogPending
bool IsWatchdogPending(uint8 auCategory)
Return true if fieldbus watchdog pending of the given category.
Definition cinosbus.h:1053

CINOSBus::GetHookCycleTime
uint32 GetHookCycleTime(uintid auHookId)
Get cycle time of given hook.

CINOSBus::GetModulesObj
virtual CINCOObject * GetModulesObj()
Return root registration object of modules.
Definition cinosbus.h:1000

CINOSBus::m_iBusSyncFilter
int32 m_iBusSyncFilter[eBusSyncFilterLength]
bus sync delta [ns]
Definition cinosbus.h:1220

CINOSBus::GetFirstBus
static CINOSBus * GetFirstBus()
Return first valid bus (aka "g_pBus[0]").
Definition cinosbus.h:641

CINOSBus::GetHookCycleNumber
uint8 GetHookCycleNumber(uintid auHookId)
Get cycle number of given hook.

CINOSBus::GetChannelBase
uint32 GetChannelBase(uint16 auAddress)
get channel base number of module auAddress

CINOSBus::m_uChkBusId
static uint8 m_uChkBusId
current bus id
Definition cinosbus.h:1411

CINOSBus::m_uBusSyncOk
uint32 m_uBusSyncOk
bus sync ok counter
Definition cinosbus.h:1226

CINOSBus::IsBusTask
virtual bool IsBusTask(CINOSTask *apTask)
get bus number of module with given address
Definition cinosbus.h:620

CINOSBus::DisableHook
uint32 DisableHook(uintid auHookId)
Enable hook with given id.

CINOSBus::m_bChkEnabled
static bool m_bChkEnabled
check active
Definition cinosbus.h:1407

CINOSBus::m_uAtomicGather
uint32 m_uAtomicGather
Definition cinosbus.h:1393

CINOSBus::m_uBusSyncIndex
uint8 m_uBusSyncIndex
bus sync index
Definition cinosbus.h:1218

CINOSBus::ChnCreate
static void ChnCreate(uint32 auNumber)
inform the system about a process image channel creation

CINOSBus::AddBus
static void AddBus(uint32 auId, CINOSBus *apBus)
Add a new bus to the handled busses.

CINOSBus::VirtualAddressCheck
bool VirtualAddressCheck(uint8 auAddress)
check virtual module address

CINOSBus::ModSetup
static void ModSetup(uint8 auBusId)
inform the system about a bus module setup

CINOSBus::m_uBusSyncMaster
static uint64 m_uBusSyncMaster
master sync time stamp
Definition cinosbus.h:1232

CINOSBus::m_uBusSyncAccelerate
uint32 m_uBusSyncAccelerate
bus sync accelerate counter
Definition cinosbus.h:1228

CINOSBus::EnableHook
uint32 EnableHook(uintid auHookId)
Enable hook with given id.

CINOSBus::m_pChnHnd
class CINOSBusChannelHandler * m_pChnHnd
pointer to bus channel handler (if any)
Definition cinosbus.h:1105

CINOSBus::RegisterErrorHook
uint32 RegisterErrorHook(uintid &auHookId, void *apHandler, void *apObject=0)
Register error hook and return hook id. The registered function will be called in the context of the ...

CINOSBus::VirtualAddressAlloc
uint8 VirtualAddressAlloc()
allocate virtual module address

CINOSBus::GetBitBase
uint32 GetBitBase(uint16 auAddress)
get bit channel base number of module auAddress

CINOSBus::ConflictCheck
static void ConflictCheck()
check for possible conflicts

CINOSBus::m_uBusSyncDecelerate
uint32 m_uBusSyncDecelerate
bus sync decelerate counter
Definition cinosbus.h:1230

CINOSBus::PermanentCheck
static void PermanentCheck()
switch on permanent check
Definition cinosbus.h:1429

CINOSBus::m_uCores
uint8 m_uCores
actual number of cores used
Definition cinosbus.h:1093

CINOSBus::GetHookHandler
void * GetHookHandler(uintid auHookId)
Get handler of given hook.

CINOSBus::GetType
const char * GetType()
Get bus type, used for consistency checks.
Definition cinosbus.h:866

CINOSBus::UnRegisterErrorHook
uint32 UnRegisterErrorHook(uintid auHookId)
Unregister error hook with given id.

CINOSBus::UnRegisterPostHook
virtual uint32 UnRegisterPostHook(uintid auHookId)
Unregister post hook with given id.

CINOSBus::SetHookHandler
uint32 SetHookHandler(uintid auHookId, void *apHandler)
Set handler of given hook.

CINOSBus::RegisterHook
virtual uint32 RegisterHook(uintid &auHookId, void *apHandler, void *apObject=0, uint32 auCycleTime=0, uint16 auCycleId=(0xffff), int32 aiOrder=20, bool abEnabled=true)
Register hook and return hook id. The registered function will be called in the context of the corres...

CINOSBus::m_bChkPermanent
static bool m_bChkPermanent
permanent check
Definition cinosbus.h:1409

CINOSBus::GetCoreCount
uint8 GetCoreCount() const
Definition cinosbus.h:1010

CINOSDacChannels
Definition cinosdacchannels.h:77

CINOSDeviceMap
Definition cinosbus.h:1476

CINOSDeviceMap::EDeviceType
EDeviceType
Error type.
Definition cinosbus.h:1497

CINOSDeviceMap::EError
EError
Error type.
Definition cinosbus.h:1487

CINOSMutex
Definition cinosmutex.h:36

CINOSPosChannels
Definition cinosposchannels.h:82

CINOSProcessImageChannel
Definition cinosprocessimagechannel.h:111

CINOSSync
Definition inos_syn.h:67

CINOSTaskEx
Definition cinostaskex.h:966

CINOSTask
Definition cinostask.h:52

CINOSTask::GetTskType
INOS_INLINE ETskType GetTskType()
Get task type.
Definition cinostask.h:201

ActualTask
CINOSTask * ActualTask()

DF_INOS_BUS_INFO_MAX_HOOKS
#define DF_INOS_BUS_INFO_MAX_HOOKS
Definition inosdefault.h:518

DF_INOS_BUS_MAX_SUB_CYCLES
#define DF_INOS_BUS_MAX_SUB_CYCLES
Definition inosdefault.h:375

INOS_INLINE
#define INOS_INLINE
Definition inosdefine.h:60

DF_INOS_MAX_CORES
#define DF_INOS_MAX_CORES
Definition inosdefine.h:164

ASSERT_ALWAYS
#define ASSERT_ALWAYS(f)
Definition inosmacro.h:696

INOS_ADD
#define INOS_ADD(variable, value)
Definition inosmacro.h:220

CINOSBus::SCheck
bus min/max channel numbers
Definition cinosbus.h:1413

SBusSleeper
Definition cinosbus.h:561

SBusSleeper::m_uBusTicks
uint32 m_uBusTicks
Definition cinosbus.h:571

SBusSleeper::m_pSync
CINOSSync m_pSync
Definition cinosbus.h:568

SBusSleeper::s_uClockedTickCount
static uint64 s_uClockedTickCount
Definition cinosbus.h:577

SBusSleeper::AddSleeper
static void AddSleeper(SBusSleeper &aNewSleeper, SBusSleeper *&apFirstSleeper)

SBusSleeper::RemoveSleeper
static void RemoveSleeper(SBusSleeper &aNewSleeper, SBusSleeper *&apFirstSleeper)

SBusSleeper::m_pNext
SBusSleeper * m_pNext
Definition cinosbus.h:575

SBusSleeper::m_bClocked
bool m_bClocked
Definition cinosbus.h:573

SBusSleeper::HandleSleepers
static void HandleSleepers(SBusSleeper *&apFirstSleeper)

SINOSBusHandlerBuffer
Definition cinosbus.h:336

SINOSBusHandlerBuffer::m_cData
char m_cData[0x4000-3 *sizeof(uint32)]
Definition cinosbus.h:439

SINOSBusHandlerBuffer::m_uWriteIndex
uint32 m_uWriteIndex
actual write buffer
Definition cinosbus.h:431

SINOSBusHandlerBuffer::m_uTemporary
uint32 m_uTemporary[2]
temporary data
Definition cinosbus.h:433

SINOSBusHandlerCall
Definition cinosbus.h:326

SINOSBusHandlerCall::m_pMethod
void * m_pMethod
pointer to method
Definition cinosbus.h:330

SINOSBusHandlerCall::m_pObject
void * m_pObject
pointer to object
Definition cinosbus.h:328

SINOSBusHandlerCall::m_uParam
uint32 m_uParam
parameter
Definition cinosbus.h:332

SINOSBusHandlerPort
Definition cinosbus.h:320

SINOSBusHandlerPort::m_uAddress
uintptr m_uAddress
pointer to port
Definition cinosbus.h:322

SINOSBusHandler
Definition cinosbus.h:312

SINOSBusHandler::m_uCommand
uint8 m_uCommand
command
Definition cinosbus.h:314

SINOSBusHandler::m_uReserved
uint8 m_uReserved[sizeof(uintptr) -1]
reserved
Definition cinosbus.h:316

SINOSBusHook
Definition cinosbus.h:276

SINOSBusInfoHook
Definition cinosbus.h:446

SINOSBusInfo
Definition cinosbus.h:536

SINOSBusPostTiming
Definition cinosbus.h:503

SINOSBusPostTiming::m_uPostHooks
uint32 m_uPostHooks
number of bus post hooks
Definition cinosbus.h:512

SINOSBusTiming
Definition cinosbus.h:461

SINOSBusTiming::m_uCatActCycle
uint16 m_uCatActCycle
category based act cycle
Definition cinosbus.h:463

SINOSBusTiming::m_uHooks
std::atomic< uint32 > m_uHooks
number of bus hook
Definition cinosbus.h:474

SINOSBus
Definition cinosbus.h:206

SINOSCatInfo
Definition cinosbus.h:522

SINOSCatInfo::m_uWatchdogCountMax
uint32 m_uWatchdogCountMax
watchdog counter max
Definition cinosbus.h:528

SINOSCatInfo::m_uWatchdogLevel
uint32 m_uWatchdogLevel
watchdog level
Definition cinosbus.h:530

SINOSCatInfo::m_uCycleTimeCat
uint32 m_uCycleTimeCat
cycletime category
Definition cinosbus.h:524

SINOSCatInfo::m_uWatchdogCount
uint32 m_uWatchdogCount
watchdog counter
Definition cinosbus.h:526