cinoscopmaster.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSCOPMASTER_H
#define INC_CINOSCOPMASTER_H
 
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
// commands
#define DF_COP_CMD_READ             0x80003000  
#define DF_COP_CMD_WRITE            0x80007000  
//
// blink job
#define DF_COP_BLINK_JOB0           0x80005FFC  
#define DF_COP_BLINK_JOB1           0x00010192  
// port communication job
#define DF_COP_PORTCOMM_JOB0        0x80003F00  
#define DF_COP_PORTCOMM_JOB1        0x00010000  
 
// eeprom commands
#define DF_COP_EEPROM_CMD           0x10000000  
#define DF_COP_EEPROM_CMD_READ      0x11000000  
#define DF_COP_EEPROM_CMD_WRITE     0x12000000  
#define DF_COP_CMD_MASK             0x0F000000  
 
// spi commands
#define DF_COP_SPI_CMD              0x30000000  
#define DF_COP_SPI_CMD_COMM         0x31000000  
 
#define DF_COP_INTERNAL_ADDRESS     8
#define DF_COP_MASTER_ADDRESS       9
 
#define ER_COP_CONFIG_MISMATCH      0x00000001
 
#define DF_COP_MOD_XDB              "xcfg-mod-cop"
 
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//  
// system
#include <inos_lib.h>
#include <inos_xml.h>
#include <cincocopdevice.h>
 
// C++
 
// project
#include <cinoscopmodule.h> 
 
 
//------------------------------------------------------------------------------
// helper macros
//------------------------------------------------------------------------------
 
#define DPR_OFFSET(aMember) inos_offsetof(SINOSCOPMaster, aMember)
#define DPR_MAX_OFFSET(aMember) (inos_offsetof(SINOSCOPMaster, aMember) + sizeofm(SINOSCOPMaster, aMember))
#define DPR_OFFSET8K(aMember) inos_offsetof(SINOSCOPMaster8K, aMember)
#define DPR_MAX_OFFSET8K(aMember) (inos_offsetof(SINOSCOPMaster8K, aMember) + sizeofm(SINOSCOPMaster8K, aMember))
 
 
//------------------------------------------------------------------------------
// structures
//------------------------------------------------------------------------------
 
struct SINOSCOPMaster
{
    uint8 m_uMisc1[0x1C0];
    uint32 m_uRevision;
    uint8 m_uMisc2[0x300-0x1C0-4];
    uint32 m_uCycleTimer;
    uint32 m_uReserved[2];
    uint32 m_uCycleCount;
    uint16 m_uGlTlgTime;
    uint16 m_uGlTlgCounter;
    uint32 m_uReserved1;
    uint32 m_uCmdDesc;
    uint32 m_uCmdJob;
    uint32 m_uBlinkJob[2];
    uint8 m_uMasterTable[(0xA00-0x320)-2*4];
    uint8 m_uTransData[0x200-4*4];
    uint32 m_uPortCommRead[2];
    uint32 m_uPortCommWrite[2];
    uint8 m_uReceiveData0[0x200];
    uint8 m_uReceiveData1[0x200];
 
    DECLARE_DYNAMIC(SINOSCOPMaster);
};
struct SINOSCOPMaster {…};
 
struct SINOSCOPMaster8K
{
    uint8 m_uMisc1[0x1C0];
    uint32 m_uRevision;
    uint8 m_uMisc2[0x300-0x1C0-4];
    uint32 m_uCycleTimer;
    uint32 m_uReserved[2];
    uint32 m_uCycleCount;
    uint16 m_uGlTlgTime;
    uint16 m_uGlTlgCounter;
    uint32 m_uReserved1;
    uint32 m_uCmdDesc;
    uint32 m_uCmdJob;
    uint32 m_uBlinkJob[2];
    uint8 m_uMasterTable[(0x800-0x328)];
    uint8 m_uTransData[0x600-4*4];
    uint32 m_uPortCommRead[2];
    uint32 m_uPortCommWrite[2];
    uint8 m_uTransInco[0x200];
    uint8 m_uReserved2[0x7000];
    uint8 m_uReceiveData0[0x600];
    uint8 m_uReceiveInco0[0x200];
    uint8 m_uReceiveData1[0x600];
    uint8 m_uReceiveInco1[0x200];
 
    DECLARE_DYNAMIC(SINOSCOPMaster8K);
};
struct SINOSCOPMaster8K {…};
 
 
struct SINOSCOPScanMod {
    uint16 m_uAppRev;
    const char* m_pModName;
    bool m_bModXmlValid;
    bool m_bEeprom;
    SINOSCOPModuleEeprom m_Eeprom;
    uint32 m_uProductCode;
    uint32 m_uEepromSize;
    XMLNode m_xCard;
    bool m_bCreateModule;
    bool m_bOnline;
    bool m_bNameUnique;
    const char* m_pModXml;
 
    DECLARE_DYNAMIC(SINOSCOPScanMod);
};
struct SINOSCOPScanMod {…};
 
struct SINOSCOPSubroutine
{
    enum {
        eMaxCode = 0x100,
    };
    uint32 m_uId;
    uint32 m_uIndex;
    uint32 m_uCode[eMaxCode];
    SINOSCOPSubroutine* m_pNext;
};
struct SINOSCOPSubroutine {…};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
 
class CINOSCOPMaster
{
    //--- user interface ---------------------------------------------------
 
    public :
        enum EOptionalFeatures {
            eNone = 0,
            
            eEepromRead = (1<<0),
            eEepromWrite = (1<<1),
            eSpiRead = (1<<2),
            eSpiWrite = (1<<3),
 
            e8kLayout = (1<<4),     // 8k layout
            eActive = (1<<5),       // running on active master
            // CopBus is running as a parasite in the following situation:
            // 1. we're running on core 0
            // 2. we're running on a asymmetric system
            // 3. core 1 is also running a CopBus instance
            eParasite = (1<<6),
            // CopBus is running as a chief in the following situation:
            // 1. we're running on core 1
            // 2. we're running on a asymmetric system
            eChief = (1<<7),
 
            eAll = (eEepromRead | eEepromWrite | eSpiRead | eSpiWrite)
        };
        enum EOptionalFeatures {…};
 
        // constants
        enum {
            eIrqMax = 8,    // max. number of interrupt vectors
            eIrqMain = 1,   // main interrupt number
            eIrqCore1 = 2,  // core 1 interrupt number
            eIrqMotor = 2,  // motor control interrupt number
            eIrqOverrun = 8,// overrun interrupt number
        };
 
        void Reset();
        void BusScan(XMLNode aConfigNode);
        void BusStartup();
 
        void SeqStart(uint32 auCycleTimeNs, uint32 auSyncPage=0, bool abSoftSync = false);
        void SeqStop();
        void SeqWatchdog(uint32 auBusControl, int16 aiCycleAdjust);
        void ToggleWatchdog();
        void SeqClear();
        void SeqWrite(uint32* apTable, bool abForceIrq = false, SINOSCOPSubroutine* apSubChain = 0);
        void SeqEnableIrq();
        uint32 SeqGetTime(uint32 uSubCycle=0);
 
        // modules
 
        CINOSCOPModule* GetFirst() {
            return m_pModules;
        };
        CINOSCOPModule* GetFirst() {…}
        CINOSCOPModule* GetNext(CINOSCOPModule* apModule) {
            return apModule->GetNext();
        };
        CINOSCOPModule* GetNext(CINOSCOPModule* apModule) {…}
        CINOSCOPModule* GetModule(uint32 auAddress);
        CINOSCOPModule* GetModule(const char* apName);
 
        bool HasModuleType(const char* apType);
 
        // misc
 
        void* GetDprAddress(uint16 auDprOffset) {
            return m_pDevice->GetDprAddress(auDprOffset);
        };
        void* GetDprAddress(uint16 auDprOffset) {…}
        CINCOCOPDevice* GetDevice() {
            return m_pDevice;
        };
        CINCOCOPDevice* GetDevice() {…}
 
        bool ReadModuleSpiData(uint32 auNumber, uint32 auCount, uint8* apBuffer,
                uint32 auBufferSize);
 
        bool WriteModuleSpiData(uint32 auNumber, uint32 auCount, uint8* apBuffer);
 
 
    //--- internals --------------------------------------------------------
 
    friend class CGINModuleActive;
    friend class CINOSMcTargetFieldbusMasterCopBus;
 
    // public member functions but just for internal use
    public :
        CINOSCOPMaster(CINCOCOPDevice* apDevice, bool abCopPas = false);
        virtual ~CINOSCOPMaster();
 
        uint32 GetError() {
            return m_uErrors;
        }
        uint32 GetError() {…}
 
        bool ReadModuleEeprom(uint32 auNumber, SINOSCOPModuleEeprom& aEeprom, uint32 auSize);
 
        bool WriteModuleEeprom(uint32 auNumber, SINOSCOPModuleEeprom& aEeprom, uint32 auSize);
 
        uint32* GetSeqTable() {
            return m_uSeqTable;
        }
        uint32* GetSeqTable() {…}
        uint32 GetSeqTableSize() {
            return m_uSeqTableSize;
        }
        uint32 GetSeqTableSize() {…}
 
        bool CheckRangeCondition(const char* apModule, CINOSBusPortHandlerRangeCondition* apCond);
 
        void CreateModules(XMLNode aConfigNode);
 
        CINOSCOPModule* CreateModule(XMLNode xCard, const char* apModName,
                uint32 auAddress, uint32 auAppRev, uint32 auProductCode);
 
        bool IsModuleOnline();
 
        void SetOptionalFeatures(uint32 auFeatures) {
            m_uOptionalFeatures = auFeatures;
        }
        void SetOptionalFeatures(uint32 auFeatures) {…}
 
        void AddOptionalFeatures(uint32 auFeature) {
            m_uOptionalFeatures |= auFeature;
        }
        void AddOptionalFeatures(uint32 auFeature) {…}
 
        bool IsOptionalFeatureEnabled(EOptionalFeatures aeFeature) const {
            return (m_uOptionalFeatures & aeFeature);
        }
        bool IsOptionalFeatureEnabled(EOptionalFeatures aeFeature) const  {…}
 
        bool IsParasite() const {
            return (m_uOptionalFeatures & eParasite);
        }
        bool IsParasite() const  {…}
 
        bool IsChief() const {
            return (m_uOptionalFeatures & eChief);
        }
        bool IsChief() const  {…}
 
        uint32 GetCycleTimer() const;
 
    // private methods
    private :
        void uSleep(uint32 auMicroseconds);
 
        static const char* GetXmlFile(const char* apcProductCode);
 
        static EXmlError GetModuleConfig(const char* apModuleXml, SINOSCOPModuleEeprom& aEeprom,
                uint32 auType, uint32 auAddress, XMLNode aParentNode, XMLNode& axDestNode);
 
        static XMLNode GetSystemModuleConfig(const char* apcProductCode,
                uint8 auType, bool abConfigLib);
 
        void StartReadModuleEeprom(uint32 auNumber, uint32 auSize);
        void StartWriteModuleEeprom(uint32 auNumber, SINOSCOPModuleEeprom& aEeprom, uint32 auSize);
        void GetEepromData(SINOSCOPModuleEeprom& aEeprom);
 
        bool ReadModuleSpi(uint32 auNumber, uint32 auAddress, uint32 auCount,
                uint8* apBuffer, uint32 auBufferSize);
 
        void StartModuleSpiComm(uint32 auNumber, uint32 auAddress, uint32 auSize,
                uint32 auCommand, uint32 auCmdSize, bool abRound);
 
        bool WriteModuleSpi(uint32 auNumber, uint32 auAddress, uint32 auCount,
            uint8* apBuffer);
 
        uint32 SpiGetFlashStatus(uint32 auNumber);
 
        bool SpiEnableWrite(uint32 auNumber);
 
        bool SpiUnlock(uint32 auNumber);
 
        bool SpiLock(uint32 auNumber);
 
        bool SpiWaitForCompletion(uint32 auNumber);
 
        bool SpiDoEraseSectorAt(uint32 auNumber, uint32 auSectorAddress);
 
        void StopModuleSpiAccess();
        void GetSpiData(uint8* apBuffer, uint32 auBufferSize);
        void PutSpiData(uint8* apBuffer, uint32 auBufferSize);
 
        bool IsCmdRunning();
 
        void SetSupportedModules(const char* apModules)
        {
            // set string
            inos_strncpy(m_cSupportedModules, apModules, sizeof(m_cSupportedModules));
        }
 
    // private members
    private :
        CINCOCOPDevice* m_pDevice;
        CINOSCOPModule* m_pModules;
        uint32 m_uSeqTable[1024];
        uint32 m_uSeqTableSize;
        uint32 m_uWatchdog;
        volatile uint32* m_pWatchdog;
        uint32 m_uErrors;
        uint32 m_uOptionalFeatures;
 
        enum {
            eFlgForceMainIrq = 0x00000001,
            eFlgTableValid = 0x00000002,
        };
        uint32 m_uFlags;
 
        #ifdef INOSV
        class CINOSSharedMemoryCopBus* m_pShared = 0;
        uint8* m_pScanData = 0;
        uint32 m_uScanDataIndex = 0;
        #endif
 
        char m_cSupportedModules[256] = {0};
 
    DECLARE_DYNAMIC(CINOSCOPMaster);
};
class CINOSCOPMaster {…};
 
 
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSCOPMASTER_H
 
 
//------------------------------------------------------------------------------
// end of file