| /**************************************************************************** |
| |
| (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29 |
| www.systec-electronic.com |
| |
| Project: openPOWERLINK |
| |
| Description: source file for generic EPL API module |
| |
| License: |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| 1. Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| |
| 2. Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in the |
| documentation and/or other materials provided with the distribution. |
| |
| 3. Neither the name of SYSTEC electronic GmbH nor the names of its |
| contributors may be used to endorse or promote products derived |
| from this software without prior written permission. For written |
| permission, please contact info@systec-electronic.com. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGE. |
| |
| Severability Clause: |
| |
| If a provision of this License is or becomes illegal, invalid or |
| unenforceable in any jurisdiction, that shall not affect: |
| 1. the validity or enforceability in that jurisdiction of any other |
| provision of this License; or |
| 2. the validity or enforceability in other jurisdictions of that or |
| any other provision of this License. |
| |
| ------------------------------------------------------------------------- |
| |
| $RCSfile: EplApiGeneric.c,v $ |
| |
| $Author: D.Krueger $ |
| |
| $Revision: 1.21 $ $Date: 2008/11/21 09:00:38 $ |
| |
| $State: Exp $ |
| |
| Build Environment: |
| GCC V3.4 |
| |
| ------------------------------------------------------------------------- |
| |
| Revision History: |
| |
| 2006/09/05 d.k.: start of the implementation, version 1.00 |
| |
| ****************************************************************************/ |
| |
| #include "Epl.h" |
| #include "kernel/EplDllk.h" |
| #include "kernel/EplErrorHandlerk.h" |
| #include "kernel/EplEventk.h" |
| #include "kernel/EplNmtk.h" |
| #include "kernel/EplObdk.h" |
| #include "kernel/EplTimerk.h" |
| #include "kernel/EplDllkCal.h" |
| #include "kernel/EplPdokCal.h" |
| #include "user/EplDlluCal.h" |
| #include "user/EplLedu.h" |
| #include "user/EplNmtCnu.h" |
| #include "user/EplNmtMnu.h" |
| #include "user/EplSdoComu.h" |
| #include "user/EplIdentu.h" |
| #include "user/EplStatusu.h" |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) |
| #include "kernel/EplPdok.h" |
| #endif |
| |
| #include "SharedBuff.h" |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) == 0) |
| #error "EPL API layer needs EPL module OBDK!" |
| #endif |
| |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* G L O B A L D E F I N I T I O N S */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| |
| //--------------------------------------------------------------------------- |
| // const defines |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // local types |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // modul globale vars |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // local function prototypes |
| //--------------------------------------------------------------------------- |
| |
| /***************************************************************************/ |
| /* */ |
| /* */ |
| /* C L A S S EplApi */ |
| /* */ |
| /* */ |
| /***************************************************************************/ |
| // |
| // Description: |
| // |
| // |
| /***************************************************************************/ |
| |
| //=========================================================================// |
| // // |
| // P R I V A T E D E F I N I T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // const defines |
| //--------------------------------------------------------------------------- |
| |
| //--------------------------------------------------------------------------- |
| // local types |
| //--------------------------------------------------------------------------- |
| |
| typedef struct { |
| tEplApiInitParam m_InitParam; |
| |
| } tEplApiInstance; |
| |
| //--------------------------------------------------------------------------- |
| // local vars |
| //--------------------------------------------------------------------------- |
| |
| static tEplApiInstance EplApiInstance_g; |
| |
| //--------------------------------------------------------------------------- |
| // local function prototypes |
| //--------------------------------------------------------------------------- |
| |
| // NMT state change event callback function |
| static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange |
| NmtStateChange_p); |
| |
| // update DLL configuration from OD |
| static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p); |
| |
| // update OD from init param |
| static tEplKernel PUBLIC EplApiUpdateObd(void); |
| |
| // process events from user event queue |
| static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p); |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) |
| // callback function of SDO module |
| static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p); |
| #endif |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // callback functions of NmtMnu module |
| static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p, |
| tEplNmtNodeEvent NodeEvent_p, |
| tEplNmtState NmtState_p, |
| WORD wErrorCode_p, |
| BOOL fMandatory_p); |
| |
| static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p, |
| tEplNmtState NmtState_p, |
| WORD wErrorCode_p); |
| #endif |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) |
| // callback function of Ledu module |
| static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p, |
| BOOL fOn_p); |
| #endif |
| |
| // OD initialization function (implemented in Objdict.c) |
| tEplKernel PUBLIC EplObdInitRam(tEplObdInitParam MEM * pInitParam_p); |
| |
| //=========================================================================// |
| // // |
| // P U B L I C F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiInitialize() |
| // |
| // Description: add and initialize new instance of EPL stack. |
| // After return from this function the application must start |
| // the NMT state machine via |
| // EplApiExecNmtCommand(kEplNmtEventSwReset) |
| // and thereby the whole EPL stack :-) |
| // |
| // Parameters: pInitParam_p = initialisation parameters |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiInitialize(tEplApiInitParam * pInitParam_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplObdInitParam ObdInitParam; |
| tEplDllkInitParam DllkInitParam; |
| #ifndef EPL_NO_FIFO |
| tShbError ShbError; |
| #endif |
| |
| // reset instance structure |
| EPL_MEMSET(&EplApiInstance_g, 0, sizeof(EplApiInstance_g)); |
| |
| EPL_MEMCPY(&EplApiInstance_g.m_InitParam, pInitParam_p, |
| min(sizeof(tEplApiInitParam), |
| pInitParam_p->m_uiSizeOfStruct)); |
| |
| // check event callback function pointer |
| if (EplApiInstance_g.m_InitParam.m_pfnCbEvent == NULL) { // application must always have an event callback function |
| Ret = kEplApiInvalidParam; |
| goto Exit; |
| } |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0) |
| // init OD |
| // FIXME |
| // Ret = EplObdInitRam(&ObdInitParam); |
| // if (Ret != kEplSuccessful) |
| // { |
| // goto Exit; |
| // } |
| |
| // initialize EplObd module |
| Ret = EplObdInit(&ObdInitParam); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| #ifndef EPL_NO_FIFO |
| ShbError = ShbInit(); |
| if (ShbError != kShbOk) { |
| Ret = kEplNoResource; |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplEventk module |
| Ret = EplEventkInit(EplApiInstance_g.m_InitParam.m_pfnCbSync); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplEventu module |
| Ret = EplEventuInit(EplApiProcessEvent); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // init EplTimerk module |
| Ret = EplTimerkInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplNmtk module before DLL |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0) |
| Ret = EplNmtkInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplDllk module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) |
| EPL_MEMCPY(DllkInitParam.m_be_abSrcMac, |
| EplApiInstance_g.m_InitParam.m_abMacAddress, 6); |
| Ret = EplDllkAddInstance(&DllkInitParam); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplErrorHandlerk module |
| Ret = EplErrorHandlerkInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplDllkCal module |
| Ret = EplDllkCalAddInstance(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplDlluCal module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0) |
| Ret = EplDlluCalAddInstance(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplPdok module |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_PDOK)) != 0) |
| Ret = EplPdokAddInstance(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| Ret = EplPdokCalAddInstance(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplNmtCnu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0) |
| Ret = EplNmtCnuAddInstance(EplApiInstance_g.m_InitParam.m_uiNodeId); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplNmtu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = EplNmtuInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // register NMT event callback function |
| Ret = EplNmtuRegisterStateChangeCb(EplApiCbNmtStateChange); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // initialize EplNmtMnu module |
| Ret = EplNmtMnuInit(EplApiCbNodeEvent, EplApiCbBootEvent); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplIdentu module |
| Ret = EplIdentuInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // initialize EplStatusu module |
| Ret = EplStatusuInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // initialize EplLedu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) |
| Ret = EplLeduInit(EplApiCbLedStateChange); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // init SDO module |
| #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0) || \ |
| (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)) |
| // init sdo command layer |
| Ret = EplSdoComInit(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // the application must start NMT state machine |
| // via EplApiExecNmtCommand(kEplNmtEventSwReset) |
| // and thereby the whole EPL stack |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiShutdown() |
| // |
| // Description: deletes an instance of EPL stack |
| // |
| // Parameters: (none) |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiShutdown(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| // $$$ d.k.: check if NMT state is NMT_GS_OFF |
| |
| // $$$ d.k.: maybe delete event queues at first, but this implies that |
| // no other module must not use the event queues for communication |
| // during shutdown. |
| |
| // delete instance for all modules |
| |
| // deinitialize EplSdoCom module |
| #if ((((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOS)) != 0) || \ |
| (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0)) |
| Ret = EplSdoComDelInstance(); |
| // PRINTF1("EplSdoComDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplLedu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) |
| Ret = EplLeduDelInstance(); |
| // PRINTF1("EplLeduDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // deinitialize EplNmtMnu module |
| Ret = EplNmtMnuDelInstance(); |
| // PRINTF1("EplNmtMnuDelInstance(): 0x%X\n", Ret); |
| |
| // deinitialize EplIdentu module |
| Ret = EplIdentuDelInstance(); |
| // PRINTF1("EplIdentuDelInstance(): 0x%X\n", Ret); |
| |
| // deinitialize EplStatusu module |
| Ret = EplStatusuDelInstance(); |
| // PRINTF1("EplStatusuDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplNmtCnu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_CN)) != 0) |
| Ret = EplNmtCnuDelInstance(); |
| // PRINTF1("EplNmtCnuDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplNmtu module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = EplNmtuDelInstance(); |
| // PRINTF1("EplNmtuDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplDlluCal module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLU)) != 0) |
| Ret = EplDlluCalDelInstance(); |
| // PRINTF1("EplDlluCalDelInstance(): 0x%X\n", Ret); |
| |
| #endif |
| |
| // deinitialize EplEventu module |
| Ret = EplEventuDelInstance(); |
| // PRINTF1("EplEventuDelInstance(): 0x%X\n", Ret); |
| |
| // deinitialize EplNmtk module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTK)) != 0) |
| Ret = EplNmtkDelInstance(); |
| // PRINTF1("EplNmtkDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplDllk module |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_DLLK)) != 0) |
| Ret = EplDllkDelInstance(); |
| // PRINTF1("EplDllkDelInstance(): 0x%X\n", Ret); |
| |
| // deinitialize EplDllkCal module |
| Ret = EplDllkCalDelInstance(); |
| // PRINTF1("EplDllkCalDelInstance(): 0x%X\n", Ret); |
| #endif |
| |
| // deinitialize EplEventk module |
| Ret = EplEventkDelInstance(); |
| // PRINTF1("EplEventkDelInstance(): 0x%X\n", Ret); |
| |
| // deinitialize EplTimerk module |
| Ret = EplTimerkDelInstance(); |
| // PRINTF1("EplTimerkDelInstance(): 0x%X\n", Ret); |
| |
| #ifndef EPL_NO_FIFO |
| ShbExit(); |
| #endif |
| |
| return Ret; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // Function: EplApiExecNmtCommand() |
| // |
| // Description: executes a NMT command, i.e. post the NMT command/event to the |
| // NMTk module. NMT commands which are not appropriate in the current |
| // NMT state are silently ignored. Please keep in mind that the |
| // NMT state may change until the NMT command is actually executed. |
| // |
| // Parameters: NmtEvent_p = NMT command/event |
| // |
| // Returns: tEplKernel = error code |
| // |
| // State: |
| //---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiExecNmtCommand(tEplNmtEvent NmtEvent_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = EplNmtuNmtEvent(NmtEvent_p); |
| #endif |
| |
| return Ret; |
| } |
| |
| //---------------------------------------------------------------------------- |
| // Function: EplApiLinkObject() |
| // |
| // Description: Function maps array of application variables onto specified object in OD |
| // |
| // Parameters: uiObjIndex_p = Function maps variables for this object index |
| // pVar_p = Pointer to data memory area for the specified object |
| // puiVarEntries_p = IN: pointer to number of entries to map |
| // OUT: pointer to number of actually used entries |
| // pEntrySize_p = IN: pointer to size of one entry; |
| // if size is zero, the actual size will be read from OD |
| // OUT: pointer to entire size of all entries mapped |
| // uiFirstSubindex_p = This is the first subindex to be mapped. |
| // |
| // Returns: tEplKernel = error code |
| // |
| // State: |
| //---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiLinkObject(unsigned int uiObjIndex_p, |
| void *pVar_p, |
| unsigned int *puiVarEntries_p, |
| tEplObdSize * pEntrySize_p, |
| unsigned int uiFirstSubindex_p) |
| { |
| BYTE bVarEntries; |
| BYTE bIndexEntries; |
| BYTE MEM *pbData; |
| unsigned int uiSubindex; |
| tEplVarParam VarParam; |
| tEplObdSize EntrySize; |
| tEplObdSize UsedSize; |
| |
| tEplKernel RetCode = kEplSuccessful; |
| |
| if ((pVar_p == NULL) |
| || (puiVarEntries_p == NULL) |
| || (*puiVarEntries_p == 0) |
| || (pEntrySize_p == NULL)) { |
| RetCode = kEplApiInvalidParam; |
| goto Exit; |
| } |
| |
| pbData = (BYTE MEM *) pVar_p; |
| bVarEntries = (BYTE) * puiVarEntries_p; |
| UsedSize = 0; |
| |
| // init VarParam structure with default values |
| VarParam.m_uiIndex = uiObjIndex_p; |
| VarParam.m_ValidFlag = kVarValidAll; |
| |
| if (uiFirstSubindex_p != 0) { // check if object exists by reading subindex 0x00, |
| // because user wants to link a variable to a subindex unequal 0x00 |
| // read number of entries |
| EntrySize = (tEplObdSize) sizeof(bIndexEntries); |
| RetCode = EplObdReadEntry(uiObjIndex_p, |
| 0x00, |
| (void GENERIC *)&bIndexEntries, |
| &EntrySize); |
| |
| if ((RetCode != kEplSuccessful) || (bIndexEntries == 0x00)) { |
| // Object doesn't exist or invalid entry number |
| RetCode = kEplObdIndexNotExist; |
| goto Exit; |
| } |
| } else { // user wants to link a variable to subindex 0x00 |
| // that's OK |
| bIndexEntries = 0; |
| } |
| |
| // Correct number of entries if number read from OD is greater |
| // than the specified number. |
| // This is done, so that we do not set more entries than subindexes the |
| // object actually has. |
| if ((bIndexEntries > (bVarEntries + uiFirstSubindex_p - 1)) && |
| (bVarEntries != 0x00)) { |
| bIndexEntries = (BYTE) (bVarEntries + uiFirstSubindex_p - 1); |
| } |
| // map entries |
| for (uiSubindex = uiFirstSubindex_p; uiSubindex <= bIndexEntries; |
| uiSubindex++) { |
| // if passed entry size is 0, then get size from OD |
| if (*pEntrySize_p == 0x00) { |
| // read entry size |
| EntrySize = EplObdGetDataSize(uiObjIndex_p, uiSubindex); |
| |
| if (EntrySize == 0x00) { |
| // invalid entry size (maybe object doesn't exist or entry of type DOMAIN is empty) |
| RetCode = kEplObdSubindexNotExist; |
| break; |
| } |
| } else { // use passed entry size |
| EntrySize = *pEntrySize_p; |
| } |
| |
| VarParam.m_uiSubindex = uiSubindex; |
| |
| // set pointer to user var |
| VarParam.m_Size = EntrySize; |
| VarParam.m_pData = pbData; |
| |
| UsedSize += EntrySize; |
| pbData += EntrySize; |
| |
| RetCode = EplObdDefineVar(&VarParam); |
| if (RetCode != kEplSuccessful) { |
| break; |
| } |
| } |
| |
| // set number of mapped entries and entry size |
| *puiVarEntries_p = ((bIndexEntries - uiFirstSubindex_p) + 1); |
| *pEntrySize_p = UsedSize; |
| |
| Exit: |
| |
| return (RetCode); |
| |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiReadObject() |
| // |
| // Description: reads the specified entry from the OD of the specified node. |
| // If this node is a remote node, it performs a SDO transfer, which |
| // means this function returns kEplApiTaskDeferred and the application |
| // is informed via the event callback function when the task is completed. |
| // |
| // Parameters: pSdoComConHdl_p = INOUT: pointer to SDO connection handle (may be NULL in case of local OD access) |
| // uiNodeId_p = IN: node ID (0 = itself) |
| // uiIndex_p = IN: index of object in OD |
| // uiSubindex_p = IN: sub-index of object in OD |
| // pDstData_le_p = OUT: pointer to data in little endian |
| // puiSize_p = INOUT: pointer to size of data |
| // SdoType_p = IN: type of SDO transfer |
| // pUserArg_p = IN: user-definable argument pointer, |
| // which will be passed to the event callback function |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiReadObject(tEplSdoComConHdl * pSdoComConHdl_p, |
| unsigned int uiNodeId_p, |
| unsigned int uiIndex_p, |
| unsigned int uiSubindex_p, |
| void *pDstData_le_p, |
| unsigned int *puiSize_p, |
| tEplSdoType SdoType_p, void *pUserArg_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| if ((uiIndex_p == 0) || (pDstData_le_p == NULL) || (puiSize_p == NULL) |
| || (*puiSize_p == 0)) { |
| Ret = kEplApiInvalidParam; |
| goto Exit; |
| } |
| |
| if (uiNodeId_p == 0 || uiNodeId_p == EplObdGetNodeId()) { // local OD access can be performed |
| tEplObdSize ObdSize; |
| |
| ObdSize = (tEplObdSize) * puiSize_p; |
| Ret = |
| EplObdReadEntryToLe(uiIndex_p, uiSubindex_p, pDstData_le_p, |
| &ObdSize); |
| *puiSize_p = (unsigned int)ObdSize; |
| } else { // perform SDO transfer |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) |
| tEplSdoComTransParamByIndex TransParamByIndex; |
| // tEplSdoComConHdl SdoComConHdl; |
| |
| // check if application provides space for handle |
| if (pSdoComConHdl_p == NULL) { |
| Ret = kEplApiInvalidParam; |
| goto Exit; |
| // pSdoComConHdl_p = &SdoComConHdl; |
| } |
| // init command layer connection |
| Ret = EplSdoComDefineCon(pSdoComConHdl_p, uiNodeId_p, // target node id |
| SdoType_p); // SDO type |
| if ((Ret != kEplSuccessful) && (Ret != kEplSdoComHandleExists)) { |
| goto Exit; |
| } |
| TransParamByIndex.m_pData = pDstData_le_p; |
| TransParamByIndex.m_SdoAccessType = kEplSdoAccessTypeRead; |
| TransParamByIndex.m_SdoComConHdl = *pSdoComConHdl_p; |
| TransParamByIndex.m_uiDataSize = *puiSize_p; |
| TransParamByIndex.m_uiIndex = uiIndex_p; |
| TransParamByIndex.m_uiSubindex = uiSubindex_p; |
| TransParamByIndex.m_pfnSdoFinishedCb = EplApiCbSdoCon; |
| TransParamByIndex.m_pUserArg = pUserArg_p; |
| |
| Ret = EplSdoComInitTransferByIndex(&TransParamByIndex); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| Ret = kEplApiTaskDeferred; |
| |
| #else |
| Ret = kEplApiInvalidParam; |
| #endif |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiWriteObject() |
| // |
| // Description: writes the specified entry to the OD of the specified node. |
| // If this node is a remote node, it performs a SDO transfer, which |
| // means this function returns kEplApiTaskDeferred and the application |
| // is informed via the event callback function when the task is completed. |
| // |
| // Parameters: pSdoComConHdl_p = INOUT: pointer to SDO connection handle (may be NULL in case of local OD access) |
| // uiNodeId_p = IN: node ID (0 = itself) |
| // uiIndex_p = IN: index of object in OD |
| // uiSubindex_p = IN: sub-index of object in OD |
| // pSrcData_le_p = IN: pointer to data in little endian |
| // uiSize_p = IN: size of data in bytes |
| // SdoType_p = IN: type of SDO transfer |
| // pUserArg_p = IN: user-definable argument pointer, |
| // which will be passed to the event callback function |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiWriteObject(tEplSdoComConHdl * pSdoComConHdl_p, |
| unsigned int uiNodeId_p, |
| unsigned int uiIndex_p, |
| unsigned int uiSubindex_p, |
| void *pSrcData_le_p, |
| unsigned int uiSize_p, |
| tEplSdoType SdoType_p, void *pUserArg_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| if ((uiIndex_p == 0) || (pSrcData_le_p == NULL) || (uiSize_p == 0)) { |
| Ret = kEplApiInvalidParam; |
| goto Exit; |
| } |
| |
| if (uiNodeId_p == 0 || uiNodeId_p == EplObdGetNodeId()) { // local OD access can be performed |
| |
| Ret = |
| EplObdWriteEntryFromLe(uiIndex_p, uiSubindex_p, |
| pSrcData_le_p, uiSize_p); |
| } else { // perform SDO transfer |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) |
| tEplSdoComTransParamByIndex TransParamByIndex; |
| // tEplSdoComConHdl SdoComConHdl; |
| |
| // check if application provides space for handle |
| if (pSdoComConHdl_p == NULL) { |
| Ret = kEplApiInvalidParam; |
| goto Exit; |
| // pSdoComConHdl_p = &SdoComConHdl; |
| } |
| // d.k.: How to recycle command layer connection? |
| // Try to redefine it, which will return kEplSdoComHandleExists |
| // and the existing command layer handle. |
| // If the returned handle is busy, EplSdoComInitTransferByIndex() |
| // will return with error. |
| // $$$ d.k.: Collisions may occur with Configuration Manager, if both the application and |
| // Configuration Manager, are trying to communicate with the very same node. |
| // possible solution: disallow communication by application if Configuration Manager is busy |
| |
| // init command layer connection |
| Ret = EplSdoComDefineCon(pSdoComConHdl_p, uiNodeId_p, // target node id |
| SdoType_p); // SDO type |
| if ((Ret != kEplSuccessful) && (Ret != kEplSdoComHandleExists)) { |
| goto Exit; |
| } |
| TransParamByIndex.m_pData = pSrcData_le_p; |
| TransParamByIndex.m_SdoAccessType = kEplSdoAccessTypeWrite; |
| TransParamByIndex.m_SdoComConHdl = *pSdoComConHdl_p; |
| TransParamByIndex.m_uiDataSize = uiSize_p; |
| TransParamByIndex.m_uiIndex = uiIndex_p; |
| TransParamByIndex.m_uiSubindex = uiSubindex_p; |
| TransParamByIndex.m_pfnSdoFinishedCb = EplApiCbSdoCon; |
| TransParamByIndex.m_pUserArg = pUserArg_p; |
| |
| Ret = EplSdoComInitTransferByIndex(&TransParamByIndex); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| Ret = kEplApiTaskDeferred; |
| |
| #else |
| Ret = kEplApiInvalidParam; |
| #endif |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiFreeSdoChannel() |
| // |
| // Description: frees the specified SDO channel. |
| // This function must be called after each call to EplApiReadObject()/EplApiWriteObject() |
| // which returns kEplApiTaskDeferred and the application |
| // is informed via the event callback function when the task is completed. |
| // |
| // Parameters: SdoComConHdl_p = IN: SDO connection handle |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiFreeSdoChannel(tEplSdoComConHdl SdoComConHdl_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) |
| |
| // init command layer connection |
| Ret = EplSdoComUndefineCon(SdoComConHdl_p); |
| |
| #else |
| Ret = kEplApiInvalidParam; |
| #endif |
| |
| return Ret; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiReadLocalObject() |
| // |
| // Description: reads the specified entry from the local OD. |
| // |
| // Parameters: uiIndex_p = IN: index of object in OD |
| // uiSubindex_p = IN: sub-index of object in OD |
| // pDstData_p = OUT: pointer to data in platform byte order |
| // puiSize_p = INOUT: pointer to size of data |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiReadLocalObject(unsigned int uiIndex_p, |
| unsigned int uiSubindex_p, |
| void *pDstData_p, |
| unsigned int *puiSize_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplObdSize ObdSize; |
| |
| ObdSize = (tEplObdSize) * puiSize_p; |
| Ret = EplObdReadEntry(uiIndex_p, uiSubindex_p, pDstData_p, &ObdSize); |
| *puiSize_p = (unsigned int)ObdSize; |
| |
| return Ret; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiWriteLocalObject() |
| // |
| // Description: writes the specified entry to the local OD. |
| // |
| // Parameters: uiIndex_p = IN: index of object in OD |
| // uiSubindex_p = IN: sub-index of object in OD |
| // pSrcData_p = IN: pointer to data in platform byte order |
| // uiSize_p = IN: size of data in bytes |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiWriteLocalObject(unsigned int uiIndex_p, |
| unsigned int uiSubindex_p, |
| void *pSrcData_p, |
| unsigned int uiSize_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| Ret = |
| EplObdWriteEntry(uiIndex_p, uiSubindex_p, pSrcData_p, |
| (tEplObdSize) uiSize_p); |
| |
| return Ret; |
| } |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // ---------------------------------------------------------------------------- |
| // |
| // Function: EplApiMnTriggerStateChange() |
| // |
| // Description: triggers the specified node command for the specified node. |
| // |
| // Parameters: uiNodeId_p = node ID for which the node command will be executed |
| // NodeCommand_p = node command |
| // |
| // Return: tEplKernel = error code |
| // |
| // ---------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiMnTriggerStateChange(unsigned int uiNodeId_p, |
| tEplNmtNodeCommand NodeCommand_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| Ret = EplNmtMnuTriggerStateChange(uiNodeId_p, NodeCommand_p); |
| |
| return Ret; |
| } |
| |
| #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbObdAccess |
| // |
| // Description: callback function for OD accesses |
| // |
| // Parameters: pParam_p = OBD parameter |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| tEplKernel PUBLIC EplApiCbObdAccess(tEplObdCbParam MEM * pParam_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| |
| #if (EPL_API_OBD_FORWARD_EVENT != FALSE) |
| tEplApiEventArg EventArg; |
| |
| // call user callback |
| // must be disabled for EplApiLinuxKernel.c, because of reentrancy problem |
| // for local OD access. This is not so bad as user callback function in |
| // application does not use OD callbacks at the moment. |
| EventArg.m_ObdCbParam = *pParam_p; |
| Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventObdAccess, |
| &EventArg, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| #endif |
| |
| switch (pParam_p->m_uiIndex) { |
| //case 0x1006: // NMT_CycleLen_U32 (valid on reset) |
| case 0x1C14: // DLL_LossOfFrameTolerance_U32 |
| //case 0x1F98: // NMT_CycleTiming_REC (valid on reset) |
| { |
| if (pParam_p->m_ObdEvent == kEplObdEvPostWrite) { |
| // update DLL configuration |
| Ret = EplApiUpdateDllConfig(FALSE); |
| } |
| break; |
| } |
| |
| case 0x1020: // CFM_VerifyConfiguration_REC.ConfId_U32 != 0 |
| { |
| if ((pParam_p->m_ObdEvent == kEplObdEvPostWrite) |
| && (pParam_p->m_uiSubIndex == 3) |
| && (*((DWORD *) pParam_p->m_pArg) != 0)) { |
| DWORD dwVerifyConfInvalid = 0; |
| // set CFM_VerifyConfiguration_REC.VerifyConfInvalid_U32 to 0 |
| Ret = |
| EplObdWriteEntry(0x1020, 4, |
| &dwVerifyConfInvalid, 4); |
| // ignore any error because this objekt is optional |
| Ret = kEplSuccessful; |
| } |
| break; |
| } |
| |
| case 0x1F9E: // NMT_ResetCmd_U8 |
| { |
| if (pParam_p->m_ObdEvent == kEplObdEvPreWrite) { |
| BYTE bNmtCommand; |
| |
| bNmtCommand = *((BYTE *) pParam_p->m_pArg); |
| // check value range |
| switch ((tEplNmtCommand) bNmtCommand) { |
| case kEplNmtCmdResetNode: |
| case kEplNmtCmdResetCommunication: |
| case kEplNmtCmdResetConfiguration: |
| case kEplNmtCmdSwReset: |
| case kEplNmtCmdInvalidService: |
| // valid command identifier specified |
| break; |
| |
| default: |
| pParam_p->m_dwAbortCode = |
| EPL_SDOAC_VALUE_RANGE_EXCEEDED; |
| Ret = kEplObdAccessViolation; |
| break; |
| } |
| } else if (pParam_p->m_ObdEvent == kEplObdEvPostWrite) { |
| BYTE bNmtCommand; |
| |
| bNmtCommand = *((BYTE *) pParam_p->m_pArg); |
| // check value range |
| switch ((tEplNmtCommand) bNmtCommand) { |
| case kEplNmtCmdResetNode: |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = |
| EplNmtuNmtEvent |
| (kEplNmtEventResetNode); |
| #endif |
| break; |
| |
| case kEplNmtCmdResetCommunication: |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = |
| EplNmtuNmtEvent |
| (kEplNmtEventResetCom); |
| #endif |
| break; |
| |
| case kEplNmtCmdResetConfiguration: |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = |
| EplNmtuNmtEvent |
| (kEplNmtEventResetConfig); |
| #endif |
| break; |
| |
| case kEplNmtCmdSwReset: |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMTU)) != 0) |
| Ret = |
| EplNmtuNmtEvent |
| (kEplNmtEventSwReset); |
| #endif |
| break; |
| |
| case kEplNmtCmdInvalidService: |
| break; |
| |
| default: |
| pParam_p->m_dwAbortCode = |
| EPL_SDOAC_VALUE_RANGE_EXCEEDED; |
| Ret = kEplObdAccessViolation; |
| break; |
| } |
| } |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| //Exit: |
| return Ret; |
| } |
| |
| //=========================================================================// |
| // // |
| // P R I V A T E F U N C T I O N S // |
| // // |
| //=========================================================================// |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiProcessEvent |
| // |
| // Description: processes events from event queue and forwards these to |
| // the application's event callback function |
| // |
| // Parameters: pEplEvent_p = pointer to event |
| // |
| // Returns: tEplKernel = errorcode |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiProcessEvent(tEplEvent * pEplEvent_p) |
| { |
| tEplKernel Ret; |
| tEplEventError *pEventError; |
| tEplApiEventType EventType; |
| |
| Ret = kEplSuccessful; |
| |
| // process event |
| switch (pEplEvent_p->m_EventType) { |
| // error event |
| case kEplEventTypeError: |
| { |
| pEventError = (tEplEventError *) pEplEvent_p->m_pArg; |
| switch (pEventError->m_EventSource) { |
| // treat the errors from the following sources as critical |
| case kEplEventSourceEventk: |
| case kEplEventSourceEventu: |
| case kEplEventSourceDllk: |
| { |
| EventType = kEplApiEventCriticalError; |
| // halt the stack by entering NMT state Off |
| Ret = |
| EplNmtuNmtEvent |
| (kEplNmtEventCriticalError); |
| break; |
| } |
| |
| // the other errors are just warnings |
| default: |
| { |
| EventType = kEplApiEventWarning; |
| break; |
| } |
| } |
| |
| // call user callback |
| Ret = |
| EplApiInstance_g.m_InitParam.m_pfnCbEvent(EventType, |
| (tEplApiEventArg |
| *) |
| pEventError, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| // discard error from callback function, because this could generate an endless loop |
| Ret = kEplSuccessful; |
| break; |
| } |
| |
| // at present, there are no other events for this module |
| default: |
| break; |
| } |
| |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbNmtStateChange |
| // |
| // Description: callback function for NMT state changes |
| // |
| // Parameters: NmtStateChange_p = NMT state change event |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiCbNmtStateChange(tEplEventNmtStateChange |
| NmtStateChange_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| BYTE bNmtState; |
| tEplApiEventArg EventArg; |
| |
| // save NMT state in OD |
| bNmtState = (BYTE) NmtStateChange_p.m_NewNmtState; |
| Ret = EplObdWriteEntry(0x1F8C, 0, &bNmtState, 1); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // do work which must be done in that state |
| switch (NmtStateChange_p.m_NewNmtState) { |
| // EPL stack is not running |
| case kEplNmtGsOff: |
| break; |
| |
| // first init of the hardware |
| case kEplNmtGsInitialising: |
| #if 0 |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDO_UDP)) != 0) |
| // configure SDO via UDP (i.e. bind it to the EPL ethernet interface) |
| Ret = |
| EplSdoUdpuConfig(EplApiInstance_g.m_InitParam.m_dwIpAddress, |
| EPL_C_SDO_EPL_PORT); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| #endif |
| |
| break; |
| |
| // init of the manufacturer-specific profile area and the |
| // standardised device profile area |
| case kEplNmtGsResetApplication: |
| { |
| // reset application part of OD |
| Ret = EplObdAccessOdPart(kEplObdPartApp, |
| kEplObdDirLoad); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| break; |
| } |
| |
| // init of the communication profile area |
| case kEplNmtGsResetCommunication: |
| { |
| // reset communication part of OD |
| Ret = EplObdAccessOdPart(kEplObdPartGen, |
| kEplObdDirLoad); |
| |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // $$$ d.k.: update OD only if OD was not loaded from non-volatile memory |
| Ret = EplApiUpdateObd(); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| break; |
| } |
| |
| // build the configuration with infos from OD |
| case kEplNmtGsResetConfiguration: |
| { |
| |
| Ret = EplApiUpdateDllConfig(TRUE); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| break; |
| } |
| |
| //----------------------------------------------------------- |
| // CN part of the state machine |
| |
| // node liste for EPL-Frames and check timeout |
| case kEplNmtCsNotActive: |
| { |
| // indicate completion of reset in NMT_ResetCmd_U8 |
| bNmtState = (BYTE) kEplNmtCmdInvalidService; |
| Ret = EplObdWriteEntry(0x1F9E, 0, &bNmtState, 1); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| break; |
| } |
| |
| // node process only async frames |
| case kEplNmtCsPreOperational1: |
| { |
| break; |
| } |
| |
| // node process isochronus and asynchronus frames |
| case kEplNmtCsPreOperational2: |
| { |
| break; |
| } |
| |
| // node should be configured und application is ready |
| case kEplNmtCsReadyToOperate: |
| { |
| break; |
| } |
| |
| // normal work state |
| case kEplNmtCsOperational: |
| { |
| break; |
| } |
| |
| // node stopped by MN |
| // -> only process asynchronus frames |
| case kEplNmtCsStopped: |
| { |
| break; |
| } |
| |
| // no EPL cycle |
| // -> normal ethernet communication |
| case kEplNmtCsBasicEthernet: |
| { |
| break; |
| } |
| |
| //----------------------------------------------------------- |
| // MN part of the state machine |
| |
| // node listens for EPL-Frames and check timeout |
| case kEplNmtMsNotActive: |
| { |
| break; |
| } |
| |
| // node processes only async frames |
| case kEplNmtMsPreOperational1: |
| { |
| break; |
| } |
| |
| // node processes isochronous and asynchronous frames |
| case kEplNmtMsPreOperational2: |
| { |
| break; |
| } |
| |
| // node should be configured und application is ready |
| case kEplNmtMsReadyToOperate: |
| { |
| break; |
| } |
| |
| // normal work state |
| case kEplNmtMsOperational: |
| { |
| break; |
| } |
| |
| // no EPL cycle |
| // -> normal ethernet communication |
| case kEplNmtMsBasicEthernet: |
| { |
| break; |
| } |
| |
| default: |
| { |
| TRACE0 |
| ("EplApiCbNmtStateChange(): unhandled NMT state\n"); |
| } |
| } |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) |
| // forward event to Led module |
| Ret = EplLeduCbNmtStateChange(NmtStateChange_p); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // forward event to NmtMn module |
| Ret = EplNmtMnuCbNmtStateChange(NmtStateChange_p); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| #endif |
| |
| // call user callback |
| EventArg.m_NmtStateChange = NmtStateChange_p; |
| Ret = |
| EplApiInstance_g.m_InitParam. |
| m_pfnCbEvent(kEplApiEventNmtStateChange, &EventArg, |
| EplApiInstance_g.m_InitParam.m_pEventUserArg); |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiUpdateDllConfig |
| // |
| // Description: update configuration of DLL |
| // |
| // Parameters: fUpdateIdentity_p = TRUE, if identity must be updated |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiUpdateDllConfig(BOOL fUpdateIdentity_p) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| tEplDllConfigParam DllConfigParam; |
| tEplDllIdentParam DllIdentParam; |
| tEplObdSize ObdSize; |
| WORD wTemp; |
| BYTE bTemp; |
| |
| // configure Dll |
| EPL_MEMSET(&DllConfigParam, 0, sizeof(DllConfigParam)); |
| DllConfigParam.m_uiNodeId = EplObdGetNodeId(); |
| |
| // Cycle Length (0x1006: NMT_CycleLen_U32) in [us] |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1006, 0, &DllConfigParam.m_dwCycleLen, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // 0x1F82: NMT_FeatureFlags_U32 |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1F82, 0, &DllConfigParam.m_dwFeatureFlags, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // d.k. There is no dependance between FeatureFlags and async-only CN |
| DllConfigParam.m_fAsyncOnly = EplApiInstance_g.m_InitParam.m_fAsyncOnly; |
| |
| // 0x1C14: DLL_LossOfFrameTolerance_U32 in [ns] |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1C14, 0, &DllConfigParam.m_dwLossOfFrameTolerance, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // 0x1F98: NMT_CycleTiming_REC |
| // 0x1F98.1: IsochrTxMaxPayload_U16 |
| ObdSize = 2; |
| Ret = EplObdReadEntry(0x1F98, 1, &wTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiIsochrTxMaxPayload = wTemp; |
| |
| // 0x1F98.2: IsochrRxMaxPayload_U16 |
| ObdSize = 2; |
| Ret = EplObdReadEntry(0x1F98, 2, &wTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiIsochrRxMaxPayload = wTemp; |
| |
| // 0x1F98.3: PResMaxLatency_U32 |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1F98, 3, &DllConfigParam.m_dwPresMaxLatency, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // 0x1F98.4: PReqActPayloadLimit_U16 |
| ObdSize = 2; |
| Ret = EplObdReadEntry(0x1F98, 4, &wTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiPreqActPayloadLimit = wTemp; |
| |
| // 0x1F98.5: PResActPayloadLimit_U16 |
| ObdSize = 2; |
| Ret = EplObdReadEntry(0x1F98, 5, &wTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiPresActPayloadLimit = wTemp; |
| |
| // 0x1F98.6: ASndMaxLatency_U32 |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1F98, 6, &DllConfigParam.m_dwAsndMaxLatency, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // 0x1F98.7: MultiplCycleCnt_U8 |
| ObdSize = 1; |
| Ret = EplObdReadEntry(0x1F98, 7, &bTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiMultiplCycleCnt = bTemp; |
| |
| // 0x1F98.8: AsyncMTU_U16 |
| ObdSize = 2; |
| Ret = EplObdReadEntry(0x1F98, 8, &wTemp, &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| DllConfigParam.m_uiAsyncMtu = wTemp; |
| |
| // $$$ Prescaler |
| |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| // 0x1F8A.1: WaitSoCPReq_U32 in [ns] |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1F8A, 1, &DllConfigParam.m_dwWaitSocPreq, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| // 0x1F8A.2: AsyncSlotTimeout_U32 in [ns] (optional) |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1F8A, 2, &DllConfigParam.m_dwAsyncSlotTimeout, |
| &ObdSize); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| #endif |
| |
| DllConfigParam.m_uiSizeOfStruct = sizeof(DllConfigParam); |
| Ret = EplDllkConfig(&DllConfigParam); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| if (fUpdateIdentity_p != FALSE) { |
| // configure Identity |
| EPL_MEMSET(&DllIdentParam, 0, sizeof(DllIdentParam)); |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1000, 0, &DllIdentParam.m_dwDeviceType, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1018, 1, &DllIdentParam.m_dwVendorId, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1018, 2, &DllIdentParam.m_dwProductCode, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1018, 3, |
| &DllIdentParam.m_dwRevisionNumber, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1018, 4, &DllIdentParam.m_dwSerialNumber, |
| &ObdSize); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| DllIdentParam.m_dwIpAddress = |
| EplApiInstance_g.m_InitParam.m_dwIpAddress; |
| DllIdentParam.m_dwSubnetMask = |
| EplApiInstance_g.m_InitParam.m_dwSubnetMask; |
| EPL_MEMCPY(DllIdentParam.m_sHostname, |
| EplApiInstance_g.m_InitParam.m_sHostname, |
| sizeof(DllIdentParam.m_sHostname)); |
| |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1020, 1, |
| &DllIdentParam.m_dwVerifyConfigurationDate, |
| &ObdSize); |
| // ignore any error, because this object is optional |
| |
| ObdSize = 4; |
| Ret = |
| EplObdReadEntry(0x1020, 2, |
| &DllIdentParam.m_dwVerifyConfigurationTime, |
| &ObdSize); |
| // ignore any error, because this object is optional |
| |
| // $$$ d.k.: fill rest of ident structure |
| |
| DllIdentParam.m_uiSizeOfStruct = sizeof(DllIdentParam); |
| Ret = EplDllkSetIdentity(&DllIdentParam); |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiUpdateObd |
| // |
| // Description: update OD from init param |
| // |
| // Parameters: (none) |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiUpdateObd(void) |
| { |
| tEplKernel Ret = kEplSuccessful; |
| WORD wTemp; |
| BYTE bTemp; |
| |
| // set node id in OD |
| Ret = EplObdSetNodeId(EplApiInstance_g.m_InitParam.m_uiNodeId, // node id |
| kEplObdNodeIdHardware); // set by hardware |
| if (Ret != kEplSuccessful) { |
| goto Exit; |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwCycleLen != -1) { |
| Ret = |
| EplObdWriteEntry(0x1006, 0, |
| &EplApiInstance_g.m_InitParam.m_dwCycleLen, |
| 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwLossOfFrameTolerance != -1) { |
| Ret = |
| EplObdWriteEntry(0x1C14, 0, |
| &EplApiInstance_g.m_InitParam. |
| m_dwLossOfFrameTolerance, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| } */ |
| } |
| // d.k. There is no dependance between FeatureFlags and async-only CN. |
| if (EplApiInstance_g.m_InitParam.m_dwFeatureFlags != -1) { |
| Ret = |
| EplObdWriteEntry(0x1F82, 0, |
| &EplApiInstance_g.m_InitParam. |
| m_dwFeatureFlags, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| } */ |
| } |
| |
| wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiIsochrTxMaxPayload; |
| Ret = EplObdWriteEntry(0x1F98, 1, &wTemp, 2); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| |
| wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiIsochrRxMaxPayload; |
| Ret = EplObdWriteEntry(0x1F98, 2, &wTemp, 2); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| |
| Ret = |
| EplObdWriteEntry(0x1F98, 3, |
| &EplApiInstance_g.m_InitParam.m_dwPresMaxLatency, |
| 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| |
| if (EplApiInstance_g.m_InitParam.m_uiPreqActPayloadLimit <= |
| EPL_C_DLL_ISOCHR_MAX_PAYL) { |
| wTemp = |
| (WORD) EplApiInstance_g.m_InitParam.m_uiPreqActPayloadLimit; |
| Ret = EplObdWriteEntry(0x1F98, 4, &wTemp, 2); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_uiPresActPayloadLimit <= |
| EPL_C_DLL_ISOCHR_MAX_PAYL) { |
| wTemp = |
| (WORD) EplApiInstance_g.m_InitParam.m_uiPresActPayloadLimit; |
| Ret = EplObdWriteEntry(0x1F98, 5, &wTemp, 2); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| Ret = |
| EplObdWriteEntry(0x1F98, 6, |
| &EplApiInstance_g.m_InitParam.m_dwAsndMaxLatency, |
| 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| |
| if (EplApiInstance_g.m_InitParam.m_uiMultiplCycleCnt <= 0xFF) { |
| bTemp = (BYTE) EplApiInstance_g.m_InitParam.m_uiMultiplCycleCnt; |
| Ret = EplObdWriteEntry(0x1F98, 7, &bTemp, 1); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_uiAsyncMtu <= |
| EPL_C_DLL_MAX_ASYNC_MTU) { |
| wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiAsyncMtu; |
| Ret = EplObdWriteEntry(0x1F98, 8, &wTemp, 2); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_uiPrescaler <= 1000) { |
| wTemp = (WORD) EplApiInstance_g.m_InitParam.m_uiPrescaler; |
| Ret = EplObdWriteEntry(0x1F98, 9, &wTemp, 2); |
| // ignore return code |
| Ret = kEplSuccessful; |
| } |
| #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| if (EplApiInstance_g.m_InitParam.m_dwWaitSocPreq != -1) { |
| Ret = |
| EplObdWriteEntry(0x1F8A, 1, |
| &EplApiInstance_g.m_InitParam. |
| m_dwWaitSocPreq, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| } */ |
| } |
| |
| if ((EplApiInstance_g.m_InitParam.m_dwAsyncSlotTimeout != 0) |
| && (EplApiInstance_g.m_InitParam.m_dwAsyncSlotTimeout != -1)) { |
| Ret = |
| EplObdWriteEntry(0x1F8A, 2, |
| &EplApiInstance_g.m_InitParam. |
| m_dwAsyncSlotTimeout, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| } */ |
| } |
| #endif |
| |
| // configure Identity |
| if (EplApiInstance_g.m_InitParam.m_dwDeviceType != -1) { |
| Ret = |
| EplObdWriteEntry(0x1000, 0, |
| &EplApiInstance_g.m_InitParam. |
| m_dwDeviceType, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwVendorId != -1) { |
| Ret = |
| EplObdWriteEntry(0x1018, 1, |
| &EplApiInstance_g.m_InitParam.m_dwVendorId, |
| 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwProductCode != -1) { |
| Ret = |
| EplObdWriteEntry(0x1018, 2, |
| &EplApiInstance_g.m_InitParam. |
| m_dwProductCode, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwRevisionNumber != -1) { |
| Ret = |
| EplObdWriteEntry(0x1018, 3, |
| &EplApiInstance_g.m_InitParam. |
| m_dwRevisionNumber, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_dwSerialNumber != -1) { |
| Ret = |
| EplObdWriteEntry(0x1018, 4, |
| &EplApiInstance_g.m_InitParam. |
| m_dwSerialNumber, 4); |
| /* if(Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_pszDevName != NULL) { |
| // write Device Name (0x1008) |
| Ret = |
| EplObdWriteEntry(0x1008, 0, |
| (void GENERIC *)EplApiInstance_g. |
| m_InitParam.m_pszDevName, |
| (tEplObdSize) strlen(EplApiInstance_g. |
| m_InitParam. |
| m_pszDevName)); |
| /* if (Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_pszHwVersion != NULL) { |
| // write Hardware version (0x1009) |
| Ret = |
| EplObdWriteEntry(0x1009, 0, |
| (void GENERIC *)EplApiInstance_g. |
| m_InitParam.m_pszHwVersion, |
| (tEplObdSize) strlen(EplApiInstance_g. |
| m_InitParam. |
| m_pszHwVersion)); |
| /* if (Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| if (EplApiInstance_g.m_InitParam.m_pszSwVersion != NULL) { |
| // write Software version (0x100A) |
| Ret = |
| EplObdWriteEntry(0x100A, 0, |
| (void GENERIC *)EplApiInstance_g. |
| m_InitParam.m_pszSwVersion, |
| (tEplObdSize) strlen(EplApiInstance_g. |
| m_InitParam. |
| m_pszSwVersion)); |
| /* if (Ret != kEplSuccessful) |
| { |
| goto Exit; |
| }*/ |
| } |
| |
| Exit: |
| return Ret; |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbSdoCon |
| // |
| // Description: callback function for SDO transfers |
| // |
| // Parameters: pSdoComFinished_p = SDO parameter |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_SDOC)) != 0) |
| static tEplKernel PUBLIC EplApiCbSdoCon(tEplSdoComFinished * pSdoComFinished_p) |
| { |
| tEplKernel Ret; |
| tEplApiEventArg EventArg; |
| |
| Ret = kEplSuccessful; |
| |
| // call user callback |
| EventArg.m_Sdo = *pSdoComFinished_p; |
| Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventSdo, |
| &EventArg, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| |
| return Ret; |
| |
| } |
| #endif |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbNodeEvent |
| // |
| // Description: callback function for node events |
| // |
| // Parameters: uiNodeId_p = node ID of the CN |
| // NodeEvent_p = event from the specified CN |
| // NmtState_p = current NMT state of the CN |
| // wErrorCode_p = EPL error code if NodeEvent_p==kEplNmtNodeEventError |
| // fMandatory_p = flag if CN is mandatory |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiCbNodeEvent(unsigned int uiNodeId_p, |
| tEplNmtNodeEvent NodeEvent_p, |
| tEplNmtState NmtState_p, |
| WORD wErrorCode_p, BOOL fMandatory_p) |
| { |
| tEplKernel Ret; |
| tEplApiEventArg EventArg; |
| |
| Ret = kEplSuccessful; |
| |
| // call user callback |
| EventArg.m_Node.m_uiNodeId = uiNodeId_p; |
| EventArg.m_Node.m_NodeEvent = NodeEvent_p; |
| EventArg.m_Node.m_NmtState = NmtState_p; |
| EventArg.m_Node.m_wErrorCode = wErrorCode_p; |
| EventArg.m_Node.m_fMandatory = fMandatory_p; |
| |
| Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventNode, |
| &EventArg, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| |
| return Ret; |
| |
| } |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbBootEvent |
| // |
| // Description: callback function for boot events |
| // |
| // Parameters: BootEvent_p = event from the boot-up process |
| // NmtState_p = current local NMT state |
| // wErrorCode_p = EPL error code if BootEvent_p==kEplNmtBootEventError |
| // |
| // Returns: tEplKernel = error code |
| // |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiCbBootEvent(tEplNmtBootEvent BootEvent_p, |
| tEplNmtState NmtState_p, |
| WORD wErrorCode_p) |
| { |
| tEplKernel Ret; |
| tEplApiEventArg EventArg; |
| |
| Ret = kEplSuccessful; |
| |
| // call user callback |
| EventArg.m_Boot.m_BootEvent = BootEvent_p; |
| EventArg.m_Boot.m_NmtState = NmtState_p; |
| EventArg.m_Boot.m_wErrorCode = wErrorCode_p; |
| |
| Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventBoot, |
| &EventArg, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| |
| return Ret; |
| |
| } |
| |
| #endif // (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_NMT_MN)) != 0) |
| |
| #if (((EPL_MODULE_INTEGRATION) & (EPL_MODULE_LEDU)) != 0) |
| |
| //--------------------------------------------------------------------------- |
| // |
| // Function: EplApiCbLedStateChange |
| // |
| // Description: callback function for LED change events. |
| // |
| // Parameters: LedType_p = type of LED |
| // fOn_p = state of LED |
| // |
| // Returns: tEplKernel = errorcode |
| // |
| // State: |
| // |
| //--------------------------------------------------------------------------- |
| |
| static tEplKernel PUBLIC EplApiCbLedStateChange(tEplLedType LedType_p, |
| BOOL fOn_p) |
| { |
| tEplKernel Ret; |
| tEplApiEventArg EventArg; |
| |
| Ret = kEplSuccessful; |
| |
| // call user callback |
| EventArg.m_Led.m_LedType = LedType_p; |
| EventArg.m_Led.m_fOn = fOn_p; |
| |
| Ret = EplApiInstance_g.m_InitParam.m_pfnCbEvent(kEplApiEventLed, |
| &EventArg, |
| EplApiInstance_g. |
| m_InitParam. |
| m_pEventUserArg); |
| |
| return Ret; |
| |
| } |
| |
| #endif |
| |
| // EOF |
