****************************************************************************/
#include "EplInc.h"
-#include "kernel/EplObdk.h" // function prototyps of the EplOBD-Modul
+#include "kernel/EplObdk.h" // function prototyps of the EplOBD-Modul
#if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
#define BASE_TO_THE_T_SP ((float) 8388608.0)
#define GET_EXPONENT_SP(x) ((((x) >> T_SP) & _SHIFTED_EXPONENT_MASK_SP) - _BIAS_SP)
-
//---------------------------------------------------------------------------
// local types
//---------------------------------------------------------------------------
// struct for instance table
-INSTANCE_TYPE_BEGIN
-
- EPL_MCO_DECL_INSTANCE_MEMBER ()
+INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER()
- STATIC tEplObdInitParam INST_FAR m_ObdInitParam;
- STATIC tEplObdStoreLoadObjCallback INST_NEAR m_fpStoreLoadObjCallback;
+STATIC tEplObdInitParam INST_FAR m_ObdInitParam;
+STATIC tEplObdStoreLoadObjCallback INST_NEAR m_fpStoreLoadObjCallback;
INSTANCE_TYPE_END
-
// decomposition of float
-typedef union
-{
- tEplObdReal32 m_flRealPart;
- int m_nIntegerPart;
+typedef union {
+ tEplObdReal32 m_flRealPart;
+ int m_nIntegerPart;
} tEplObdRealParts;
-
//---------------------------------------------------------------------------
// modul globale vars
//---------------------------------------------------------------------------
// must defined in each modul.
//#define tEplPtrInstance tEplInstanceInfo MEM*
-EPL_MCO_DECL_INSTANCE_VAR ()
-
-BYTE MEM abEplObdTrashObject_g[8];
+EPL_MCO_DECL_INSTANCE_VAR()
+BYTE MEM abEplObdTrashObject_g[8];
//---------------------------------------------------------------------------
// local function prototypes
//---------------------------------------------------------------------------
-EPL_MCO_DEFINE_INSTANCE_FCT ()
+EPL_MCO_DEFINE_INSTANCE_FCT()
-static tEplKernel EplObdCallObjectCallback (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdCallback fpCallback_p,
- tEplObdCbParam MEM* pCbParam_p);
+static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdCallback fpCallback_p,
+ tEplObdCbParam MEM * pCbParam_p);
-static tEplObdSize EplObdGetDataSizeIntern (tEplObdSubEntryPtr pSubIndexEntry_p);
+static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p);
-static tEplObdSize EplObdGetStrLen (void* pObjData_p,
- tEplObdSize ObjLen_p,
- tEplObdType ObjType_p);
+static tEplObdSize EplObdGetStrLen(void *pObjData_p,
+ tEplObdSize ObjLen_p, tEplObdType ObjType_p);
#if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
-static tEplKernel EplObdCheckObjectRange (
- tEplObdSubEntryPtr pSubindexEntry_p,
- void * pData_p);
+static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
+ void *pData_p);
#endif
-static tEplKernel EplObdGetVarEntry (
- tEplObdSubEntryPtr pSubindexEntry_p,
- tEplObdVarEntry MEM** ppVarEntry_p);
+static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
+ tEplObdVarEntry MEM ** ppVarEntry_p);
-static tEplKernel EplObdGetEntry (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubindex_p,
- tEplObdEntryPtr* ppObdEntry_p,
- tEplObdSubEntryPtr* ppObdSubEntry_p);
+static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubindex_p,
+ tEplObdEntryPtr * ppObdEntry_p,
+ tEplObdSubEntryPtr * ppObdSubEntry_p);
-static tEplObdSize EplObdGetObjectSize (tEplObdSubEntryPtr pSubIndexEntry_p);
+static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p);
-static tEplKernel EplObdGetIndexIntern (
- tEplObdInitParam MEM* pInitParam_p,
- unsigned int uiIndex_p,
- tEplObdEntryPtr* ppObdEntry_p);
+static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p,
+ unsigned int uiIndex_p,
+ tEplObdEntryPtr * ppObdEntry_p);
-static tEplKernel EplObdGetSubindexIntern (
- tEplObdEntryPtr pObdEntry_p,
- unsigned int uiSubIndex_p,
- tEplObdSubEntryPtr* ppObdSubEntry_p);
+static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
+ unsigned int uiSubIndex_p,
+ tEplObdSubEntryPtr * ppObdSubEntry_p);
-static tEplKernel EplObdAccessOdPartIntern (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdPart CurrentOdPart_p,
- tEplObdEntryPtr pObdEnty_p,
- tEplObdDir Direction_p);
+static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdPart CurrentOdPart_p,
+ tEplObdEntryPtr pObdEnty_p,
+ tEplObdDir Direction_p);
-static void * EplObdGetObjectDefaultPtr (tEplObdSubEntryPtr pSubIndexEntry_p);
-static void MEM* EplObdGetObjectCurrentPtr (tEplObdSubEntryPtr pSubIndexEntry_p);
+static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
+static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
- static tEplKernel EplObdCallStoreCallback (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdCbStoreParam MEM* pCbStoreParam_p);
+static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdCbStoreParam MEM *
+ pCbStoreParam_p);
#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
-static void EplObdCopyObjectData (
- void MEM* pDstData_p,
- void * pSrcData_p,
- tEplObdSize ObjSize_p,
- tEplObdType ObjType_p);
+static void EplObdCopyObjectData(void MEM * pDstData_p,
+ void *pSrcData_p,
+ tEplObdSize ObjSize_p, tEplObdType ObjType_p);
-void * EplObdGetObjectDataPtrIntern (tEplObdSubEntryPtr pSubindexEntry_p);
+void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p);
static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
- BOOL* pfEntryNumerical_p);
-
-static tEplKernel PUBLIC EplObdWriteEntryPre (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pSrcData_p,
- void** ppDstData_p,
- tEplObdSize Size_p,
- tEplObdEntryPtr* ppObdEntry_p,
- tEplObdSubEntryPtr* ppSubEntry_p,
- tEplObdCbParam MEM* pCbParam_p,
- tEplObdSize* pObdSize_p);
-
-static tEplKernel PUBLIC EplObdWriteEntryPost (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdEntryPtr pObdEntry_p,
- tEplObdSubEntryPtr pSubEntry_p,
- tEplObdCbParam MEM* pCbParam_p,
- void * pSrcData_p,
- void * pDstData_p,
- tEplObdSize ObdSize_p);
-
-
+ BOOL * pfEntryNumerical_p);
+
+static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pSrcData_p,
+ void **ppDstData_p,
+ tEplObdSize Size_p,
+ tEplObdEntryPtr * ppObdEntry_p,
+ tEplObdSubEntryPtr * ppSubEntry_p,
+ tEplObdCbParam MEM * pCbParam_p,
+ tEplObdSize * pObdSize_p);
+
+static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdEntryPtr pObdEntry_p,
+ tEplObdSubEntryPtr pSubEntry_p,
+ tEplObdCbParam MEM * pCbParam_p,
+ void *pSrcData_p,
+ void *pDstData_p,
+ tEplObdSize ObdSize_p);
//=========================================================================//
// //
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdInit (EPL_MCO_DECL_PTR_INSTANCE_PTR_
- tEplObdInitParam MEM* pInitParam_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
+ tEplObdInitParam MEM * pInitParam_p)
{
-tEplKernel Ret;
-EPL_MCO_DELETE_INSTANCE_TABLE ();
+ tEplKernel Ret;
+ EPL_MCO_DELETE_INSTANCE_TABLE();
- if (pInitParam_p == NULL)
- {
- Ret = kEplSuccessful;
- goto Exit;
- }
+ if (pInitParam_p == NULL) {
+ Ret = kEplSuccessful;
+ goto Exit;
+ }
- Ret = EplObdAddInstance (EPL_MCO_PTR_INSTANCE_PTR_
- pInitParam_p);
+ Ret = EplObdAddInstance(EPL_MCO_PTR_INSTANCE_PTR_ pInitParam_p);
-Exit:
- return Ret;
+ Exit:
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdAddInstance()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance (EPL_MCO_DECL_PTR_INSTANCE_PTR_
- tEplObdInitParam MEM* pInitParam_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
+ tEplObdInitParam MEM *
+ pInitParam_p)
{
-EPL_MCO_DECL_INSTANCE_PTR_LOCAL
-tEplKernel Ret;
+ EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
- // check if pointer to instance pointer valid
- // get free instance and set the globale instance pointer
- // set also the instance addr to parameterlist
- EPL_MCO_CHECK_PTR_INSTANCE_PTR ();
- EPL_MCO_GET_FREE_INSTANCE_PTR ();
- EPL_MCO_SET_PTR_INSTANCE_PTR ();
+ // check if pointer to instance pointer valid
+ // get free instance and set the globale instance pointer
+ // set also the instance addr to parameterlist
+ EPL_MCO_CHECK_PTR_INSTANCE_PTR();
+ EPL_MCO_GET_FREE_INSTANCE_PTR();
+ EPL_MCO_SET_PTR_INSTANCE_PTR();
- // save init parameters
- EPL_MEMCPY (&EPL_MCO_GLB_VAR (m_ObdInitParam), pInitParam_p, sizeof (tEplObdInitParam));
+ // save init parameters
+ EPL_MEMCPY(&EPL_MCO_GLB_VAR(m_ObdInitParam), pInitParam_p,
+ sizeof(tEplObdInitParam));
- // clear callback function for command LOAD and STORE
- EPL_MCO_GLB_VAR (m_fpStoreLoadObjCallback) = NULL;
+ // clear callback function for command LOAD and STORE
+ EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = NULL;
- // sign instance as used
- EPL_MCO_WRITE_INSTANCE_STATE (kStateUsed);
+ // sign instance as used
+ EPL_MCO_WRITE_INSTANCE_STATE(kStateUsed);
- // initialize object dictionary
- // so all all VarEntries will be initialized to trash object and default values will be set to current data
- Ret = EplObdAccessOdPart (EPL_MCO_INSTANCE_PTR_
- kEplObdPartAll, kEplObdDirInit);
+ // initialize object dictionary
+ // so all all VarEntries will be initialized to trash object and default values will be set to current data
+ Ret = EplObdAccessOdPart(EPL_MCO_INSTANCE_PTR_
+ kEplObdPartAll, kEplObdDirInit);
- return Ret;
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdDeleteInstance()
//
//---------------------------------------------------------------------------
#if (EPL_USE_DELETEINST_FUNC != FALSE)
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance (EPL_MCO_DECL_INSTANCE_PTR)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
{
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
- // sign instance as unused
- EPL_MCO_WRITE_INSTANCE_STATE (kStateUnused);
+ // sign instance as unused
+ EPL_MCO_WRITE_INSTANCE_STATE(kStateUnused);
- return kEplSuccessful;
+ return kEplSuccessful;
}
#endif // (EPL_USE_DELETEINST_FUNC != FALSE)
-
//---------------------------------------------------------------------------
//
// Function: EplObdWriteEntry()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pSrcData_p,
- tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pSrcData_p,
+ tEplObdSize Size_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pSubEntry;
-tEplObdCbParam MEM CbParam;
-void MEM* pDstData;
-tEplObdSize ObdSize;
-
-
- Ret = EplObdWriteEntryPre (EPL_MCO_INSTANCE_PTR_
- uiIndex_p,
- uiSubIndex_p,
- pSrcData_p,
- &pDstData,
- Size_p,
- &pObdEntry,
- &pSubEntry,
- &CbParam,
- &ObdSize);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- Ret = EplObdWriteEntryPost (EPL_MCO_INSTANCE_PTR_
- pObdEntry,
- pSubEntry,
- &CbParam,
- pSrcData_p,
- pDstData,
- ObdSize);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
-Exit:
-
- return Ret;
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pSubEntry;
+ tEplObdCbParam MEM CbParam;
+ void MEM *pDstData;
+ tEplObdSize ObdSize;
+
+ Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p,
+ uiSubIndex_p,
+ pSrcData_p,
+ &pDstData,
+ Size_p,
+ &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
+ pObdEntry,
+ pSubEntry,
+ &CbParam, pSrcData_p, pDstData, ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ Exit:
+
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdReadEntry()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pDstData_p,
- tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pDstData_p,
+ tEplObdSize * pSize_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pSubEntry;
-tEplObdCbParam MEM CbParam;
-void * pSrcData;
-tEplObdSize ObdSize;
-
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- ASSERT (pDstData_p != NULL);
- ASSERT (pSize_p != NULL);
-
- // get address of index and subindex entry
- Ret = EplObdGetEntry (EPL_MCO_INSTANCE_PTR_
- uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get pointer to object data
- pSrcData = EplObdGetObjectDataPtrIntern (pSubEntry);
-
- // check source pointer
- if (pSrcData == NULL)
- {
- Ret = kEplObdReadViolation;
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // address of source data to structure of callback parameters
- // so callback function can change this data before reading
- CbParam.m_uiIndex = uiIndex_p;
- CbParam.m_uiSubIndex= uiSubIndex_p;
- CbParam.m_pArg = pSrcData;
- CbParam.m_ObdEvent = kEplObdEvPreRead;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, &CbParam);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get size of data and check if application has reserved enough memory
- ObdSize = EplObdGetDataSizeIntern (pSubEntry);
- // check if offset given and calc correct number of bytes to read
- if (*pSize_p < ObdSize)
- {
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
-
- // read value from object
- EPL_MEMCPY (pDstData_p, pSrcData, ObdSize);
- *pSize_p = ObdSize;
-
- // write address of destination data to structure of callback parameters
- // so callback function can change this data after reading
- CbParam.m_pArg = pDstData_p;
- CbParam.m_ObdEvent = kEplObdEvPostRead;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, &CbParam);
-
-Exit:
-
- return Ret;
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pSubEntry;
+ tEplObdCbParam MEM CbParam;
+ void *pSrcData;
+ tEplObdSize ObdSize;
+
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ ASSERT(pDstData_p != NULL);
+ ASSERT(pSize_p != NULL);
+
+ // get address of index and subindex entry
+ Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get pointer to object data
+ pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
+
+ // check source pointer
+ if (pSrcData == NULL) {
+ Ret = kEplObdReadViolation;
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // address of source data to structure of callback parameters
+ // so callback function can change this data before reading
+ CbParam.m_uiIndex = uiIndex_p;
+ CbParam.m_uiSubIndex = uiSubIndex_p;
+ CbParam.m_pArg = pSrcData;
+ CbParam.m_ObdEvent = kEplObdEvPreRead;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, &CbParam);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get size of data and check if application has reserved enough memory
+ ObdSize = EplObdGetDataSizeIntern(pSubEntry);
+ // check if offset given and calc correct number of bytes to read
+ if (*pSize_p < ObdSize) {
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+ // read value from object
+ EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
+ *pSize_p = ObdSize;
+
+ // write address of destination data to structure of callback parameters
+ // so callback function can change this data after reading
+ CbParam.m_pArg = pDstData_p;
+ CbParam.m_ObdEvent = kEplObdEvPostRead;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, &CbParam);
+
+ Exit:
+
+ return Ret;
}
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdPart ObdPart_p,
- tEplObdDir Direction_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdPart ObdPart_p,
+ tEplObdDir Direction_p)
{
-tEplKernel Ret = kEplSuccessful;
-BOOL fPartFount;
-tEplObdEntryPtr pObdEntry;
-
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- // part always has to be unequal to NULL
- pObdEntry = EPL_MCO_GLB_VAR (m_ObdInitParam.m_pPart);
- ASSERTMSG (pObdEntry != NULL, "EplObdAccessOdPart(): no OD part is defined!\n");
-
- // if ObdPart_p is not valid fPartFound keeps FALSE and function returns kEplObdIllegalPart
- fPartFount = FALSE;
-
- // access to part
- if ((ObdPart_p & kEplObdPartGen) != 0)
- {
- fPartFount = TRUE;
-
- Ret = EplObdAccessOdPartIntern (EPL_MCO_INSTANCE_PTR_
- kEplObdPartGen, pObdEntry, Direction_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
-
- // access to manufacturer part
- pObdEntry = EPL_MCO_GLB_VAR (m_ObdInitParam.m_pManufacturerPart);
-
- if ( ((ObdPart_p & kEplObdPartMan) != 0) &&
- (pObdEntry != NULL) )
- {
- fPartFount = TRUE;
-
- Ret = EplObdAccessOdPartIntern (EPL_MCO_INSTANCE_PTR_
- kEplObdPartMan, pObdEntry, Direction_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
-
- // access to device part
- pObdEntry = EPL_MCO_GLB_VAR (m_ObdInitParam.m_pDevicePart);
-
- if ( ((ObdPart_p & kEplObdPartDev) != 0) &&
- (pObdEntry != NULL) )
- {
- fPartFount = TRUE;
-
- Ret = EplObdAccessOdPartIntern (EPL_MCO_INSTANCE_PTR_
- kEplObdPartDev, pObdEntry, Direction_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
-
- #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
- {
- // access to user part
- pObdEntry = EPL_MCO_GLB_VAR (m_ObdInitParam.m_pUserPart);
-
- if ( ((ObdPart_p & kEplObdPartUsr) != 0) &&
- (pObdEntry != NULL) )
- {
- fPartFount = TRUE;
-
- Ret = EplObdAccessOdPartIntern (EPL_MCO_INSTANCE_PTR_
- kEplObdPartUsr, pObdEntry, Direction_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
- }
- #endif
+ tEplKernel Ret = kEplSuccessful;
+ BOOL fPartFount;
+ tEplObdEntryPtr pObdEntry;
+
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ // part always has to be unequal to NULL
+ pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pPart);
+ ASSERTMSG(pObdEntry != NULL,
+ "EplObdAccessOdPart(): no OD part is defined!\n");
+
+ // if ObdPart_p is not valid fPartFound keeps FALSE and function returns kEplObdIllegalPart
+ fPartFount = FALSE;
+
+ // access to part
+ if ((ObdPart_p & kEplObdPartGen) != 0) {
+ fPartFount = TRUE;
+
+ Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
+ kEplObdPartGen, pObdEntry,
+ Direction_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+ // access to manufacturer part
+ pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pManufacturerPart);
+
+ if (((ObdPart_p & kEplObdPartMan) != 0) && (pObdEntry != NULL)) {
+ fPartFount = TRUE;
+
+ Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
+ kEplObdPartMan, pObdEntry,
+ Direction_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+ // access to device part
+ pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pDevicePart);
+
+ if (((ObdPart_p & kEplObdPartDev) != 0) && (pObdEntry != NULL)) {
+ fPartFount = TRUE;
+
+ Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
+ kEplObdPartDev, pObdEntry,
+ Direction_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
+ {
+ // access to user part
+ pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart);
+
+ if (((ObdPart_p & kEplObdPartUsr) != 0) && (pObdEntry != NULL)) {
+ fPartFount = TRUE;
+
+ Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
+ kEplObdPartUsr,
+ pObdEntry, Direction_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+ }
+#endif
- // no access to an OD part was done? illegal OD part was specified!
- if (fPartFount == FALSE)
- {
- Ret = kEplObdIllegalPart;
- }
+ // no access to an OD part was done? illegal OD part was specified!
+ if (fPartFount == FALSE) {
+ Ret = kEplObdIllegalPart;
+ }
-Exit:
+ Exit:
- return Ret;
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdDefineVar()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar (EPL_MCO_DECL_INSTANCE_PTR_
- tEplVarParam MEM* pVarParam_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplVarParam MEM * pVarParam_p)
{
-tEplKernel Ret;
-tEplObdVarEntry MEM* pVarEntry;
-tEplVarParamValid VarValid;
-tEplObdSubEntryPtr pSubindexEntry;
-
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- ASSERT (pVarParam_p != NULL); // is not allowed to be NULL
-
- // get address of subindex entry
- Ret = EplObdGetEntry (EPL_MCO_INSTANCE_PTR_
- pVarParam_p->m_uiIndex,
- pVarParam_p->m_uiSubindex,
- NULL, &pSubindexEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get var entry
- Ret = EplObdGetVarEntry (pSubindexEntry, &pVarEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- VarValid = pVarParam_p->m_ValidFlag;
-
- // copy only this values, which valid flag is set
- if ((VarValid & kVarValidSize) != 0)
- {
- if (pSubindexEntry->m_Type != kEplObdTypDomain)
- {
- tEplObdSize DataSize;
-
- // check passed size parameter
- DataSize = EplObdGetObjectSize(pSubindexEntry);
- if (DataSize != pVarParam_p->m_Size)
- { // size of variable does not match
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
- }
- else
- { // size can be set only for objects of type DOMAIN
- pVarEntry->m_Size = pVarParam_p->m_Size;
- }
- }
-
- if ((VarValid & kVarValidData) != 0)
- {
- pVarEntry->m_pData = pVarParam_p->m_pData;
- }
+ tEplKernel Ret;
+ tEplObdVarEntry MEM *pVarEntry;
+ tEplVarParamValid VarValid;
+ tEplObdSubEntryPtr pSubindexEntry;
+
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ ASSERT(pVarParam_p != NULL); // is not allowed to be NULL
+
+ // get address of subindex entry
+ Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
+ pVarParam_p->m_uiIndex,
+ pVarParam_p->m_uiSubindex, NULL, &pSubindexEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get var entry
+ Ret = EplObdGetVarEntry(pSubindexEntry, &pVarEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ VarValid = pVarParam_p->m_ValidFlag;
+
+ // copy only this values, which valid flag is set
+ if ((VarValid & kVarValidSize) != 0) {
+ if (pSubindexEntry->m_Type != kEplObdTypDomain) {
+ tEplObdSize DataSize;
+
+ // check passed size parameter
+ DataSize = EplObdGetObjectSize(pSubindexEntry);
+ if (DataSize != pVarParam_p->m_Size) { // size of variable does not match
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+ } else { // size can be set only for objects of type DOMAIN
+ pVarEntry->m_Size = pVarParam_p->m_Size;
+ }
+ }
+
+ if ((VarValid & kVarValidData) != 0) {
+ pVarEntry->m_pData = pVarParam_p->m_pData;
+ }
/*
#if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
{
}
#endif
*/
- // Ret is already set to kEplSuccessful from ObdGetVarIntern()
+ // Ret is already set to kEplSuccessful from ObdGetVarIntern()
-Exit:
+ Exit:
- return Ret;
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetObjectDataPtr()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT void * PUBLIC EplObdGetObjectDataPtr (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p)
- {
-tEplKernel Ret;
-void * pData;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pObdSubEntry;
-
-
- // get pointer to index structure
- Ret = EplObdGetIndexIntern (&EPL_MCO_GLB_VAR (m_ObdInitParam),
- uiIndex_p,
- &pObdEntry);
- if(Ret != kEplSuccessful)
- {
- pData = NULL;
- goto Exit;
- }
-
- // get pointer to subindex structure
- Ret = EplObdGetSubindexIntern (pObdEntry,
- uiSubIndex_p,
- &pObdSubEntry);
- if(Ret != kEplSuccessful)
- {
- pData = NULL;
- goto Exit;
- }
- // get Datapointer
- pData = EplObdGetObjectDataPtrIntern(pObdSubEntry);
-
-Exit:
- return pData;
+EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p)
+{
+ tEplKernel Ret;
+ void *pData;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pObdSubEntry;
+
+ // get pointer to index structure
+ Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
+ uiIndex_p, &pObdEntry);
+ if (Ret != kEplSuccessful) {
+ pData = NULL;
+ goto Exit;
+ }
+ // get pointer to subindex structure
+ Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
+ if (Ret != kEplSuccessful) {
+ pData = NULL;
+ goto Exit;
+ }
+ // get Datapointer
+ pData = EplObdGetObjectDataPtrIntern(pObdSubEntry);
+
+ Exit:
+ return pData;
}
-
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
//---------------------------------------------------------------------------
// State:
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdEntryPtr pUserOd_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdEntryPtr pUserOd_p)
{
- EPL_MCO_CHECK_INSTANCE_STATE ();
+ EPL_MCO_CHECK_INSTANCE_STATE();
- EPL_MCO_GLB_VAR (m_ObdInitParam.m_pUserPart) = pUserOd_p;
+ EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart) = pUserOd_p;
- return kEplSuccessful;
+ return kEplSuccessful;
}
#endif
-
//---------------------------------------------------------------------------
//
// Function: EplObdInitVarEntry()
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT void PUBLIC EplObdInitVarEntry (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdVarEntry MEM* pVarEntry_p,
- tEplObdType Type_p, tEplObdSize ObdSize_p)
+EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdVarEntry MEM * pVarEntry_p,
+ tEplObdType Type_p,
+ tEplObdSize ObdSize_p)
{
/*
#if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
*/
// 10-dec-2004 r.d.: this function will not be used for strings
- if ((Type_p == kEplObdTypDomain))
+ if ((Type_p == kEplObdTypDomain))
// (bType_p == kEplObdTypVString) /* ||
// (bType_p == kEplObdTypOString) ||
// (bType_p == kEplObdTypUString) */ )
- {
- // variables which are defined as DOMAIN or VSTRING should not point to
- // trash object, because this trash object contains only 8 bytes. DOMAINS or
- // STRINGS can be longer.
- pVarEntry_p->m_pData = NULL;
- pVarEntry_p->m_Size = 0;
- }
- else
- {
- // set address to variable data to trash object
- // This prevents an access violation if user forgets to call EplObdDefineVar()
- // for this variable but mappes it in a PDO.
- pVarEntry_p->m_pData = &abEplObdTrashObject_g[0];
- pVarEntry_p->m_Size = ObdSize_p;
- }
+ {
+ // variables which are defined as DOMAIN or VSTRING should not point to
+ // trash object, because this trash object contains only 8 bytes. DOMAINS or
+ // STRINGS can be longer.
+ pVarEntry_p->m_pData = NULL;
+ pVarEntry_p->m_Size = 0;
+ } else {
+ // set address to variable data to trash object
+ // This prevents an access violation if user forgets to call EplObdDefineVar()
+ // for this variable but mappes it in a PDO.
+ pVarEntry_p->m_pData = &abEplObdTrashObject_g[0];
+ pVarEntry_p->m_Size = ObdSize_p;
+ }
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetDataSize()
//
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p)
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p)
{
-tEplKernel Ret;
-tEplObdSize ObdSize;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pObdSubEntry;
-
-
- // get pointer to index structure
- Ret = EplObdGetIndexIntern (&EPL_MCO_GLB_VAR (m_ObdInitParam),
- uiIndex_p,
- &pObdEntry);
- if(Ret != kEplSuccessful)
- {
- ObdSize = 0;
- goto Exit;
- }
-
- // get pointer to subindex structure
- Ret = EplObdGetSubindexIntern (pObdEntry,
- uiSubIndex_p,
- &pObdSubEntry);
- if(Ret != kEplSuccessful)
- {
- ObdSize = 0;
- goto Exit;
- }
-
- // get size
- ObdSize = EplObdGetDataSizeIntern (pObdSubEntry);
-Exit:
- return ObdSize;
+ tEplKernel Ret;
+ tEplObdSize ObdSize;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pObdSubEntry;
+
+ // get pointer to index structure
+ Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
+ uiIndex_p, &pObdEntry);
+ if (Ret != kEplSuccessful) {
+ ObdSize = 0;
+ goto Exit;
+ }
+ // get pointer to subindex structure
+ Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
+ if (Ret != kEplSuccessful) {
+ ObdSize = 0;
+ goto Exit;
+ }
+ // get size
+ ObdSize = EplObdGetDataSizeIntern(pObdSubEntry);
+ Exit:
+ return ObdSize;
}
+
//---------------------------------------------------------------------------
//
// Function: EplObdGetNodeId()
//---------------------------------------------------------------------------
EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
{
-tEplKernel Ret;
-tEplObdSize ObdSize;
-BYTE bNodeId;
-
- bNodeId = 0;
- ObdSize = sizeof(bNodeId);
- Ret = EplObdReadEntry(EPL_MCO_PTR_INSTANCE_PTR_
- EPL_OBD_NODE_ID_INDEX,
- EPL_OBD_NODE_ID_SUBINDEX,
- &bNodeId,
- &ObdSize);
- if(Ret != kEplSuccessful)
- {
- bNodeId = EPL_C_ADR_INVALID;
- goto Exit;
- }
-
-Exit:
- return (unsigned int) bNodeId;
+ tEplKernel Ret;
+ tEplObdSize ObdSize;
+ BYTE bNodeId;
+
+ bNodeId = 0;
+ ObdSize = sizeof(bNodeId);
+ Ret = EplObdReadEntry(EPL_MCO_PTR_INSTANCE_PTR_
+ EPL_OBD_NODE_ID_INDEX,
+ EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, &ObdSize);
+ if (Ret != kEplSuccessful) {
+ bNodeId = EPL_C_ADR_INVALID;
+ goto Exit;
+ }
+
+ Exit:
+ return (unsigned int)bNodeId;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdSetNodeId()
//
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_
- unsigned int uiNodeId_p,
- tEplObdNodeIdType NodeIdType_p)
+ unsigned int uiNodeId_p,
+ tEplObdNodeIdType NodeIdType_p)
{
-tEplKernel Ret;
-tEplObdSize ObdSize;
-BYTE fHwBool;
-BYTE bNodeId;
-
- // check Node Id
- if(uiNodeId_p == EPL_C_ADR_INVALID)
- {
- Ret = kEplInvalidNodeId;
- goto Exit;
- }
- bNodeId = (BYTE)uiNodeId_p;
- ObdSize = sizeof(BYTE);
- // write NodeId to OD entry
- Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR_
- EPL_OBD_NODE_ID_INDEX,
- EPL_OBD_NODE_ID_SUBINDEX,
- &bNodeId,
- ObdSize);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // set HWBOOL-Flag in Subindex EPL_OBD_NODE_ID_HWBOOL_SUBINDEX
- switch (NodeIdType_p)
- {
- // type unknown
- case kEplObdNodeIdUnknown:
- {
- fHwBool = OBD_FALSE;
- break;
- }
-
- case kEplObdNodeIdSoftware:
- {
- fHwBool = OBD_FALSE;
- break;
- }
-
- case kEplObdNodeIdHardware:
- {
- fHwBool = OBD_TRUE;
- break;
- }
-
- default:
- {
- fHwBool = OBD_FALSE;
- }
-
- } // end of switch (NodeIdType_p)
-
- // write flag
- ObdSize = sizeof(fHwBool);
- Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR
- EPL_OBD_NODE_ID_INDEX,
- EPL_OBD_NODE_ID_HWBOOL_SUBINDEX,
- &fHwBool,
- ObdSize);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
-Exit:
- return Ret;
+ tEplKernel Ret;
+ tEplObdSize ObdSize;
+ BYTE fHwBool;
+ BYTE bNodeId;
+
+ // check Node Id
+ if (uiNodeId_p == EPL_C_ADR_INVALID) {
+ Ret = kEplInvalidNodeId;
+ goto Exit;
+ }
+ bNodeId = (BYTE) uiNodeId_p;
+ ObdSize = sizeof(BYTE);
+ // write NodeId to OD entry
+ Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR_
+ EPL_OBD_NODE_ID_INDEX,
+ EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // set HWBOOL-Flag in Subindex EPL_OBD_NODE_ID_HWBOOL_SUBINDEX
+ switch (NodeIdType_p) {
+ // type unknown
+ case kEplObdNodeIdUnknown:
+ {
+ fHwBool = OBD_FALSE;
+ break;
+ }
+
+ case kEplObdNodeIdSoftware:
+ {
+ fHwBool = OBD_FALSE;
+ break;
+ }
+
+ case kEplObdNodeIdHardware:
+ {
+ fHwBool = OBD_TRUE;
+ break;
+ }
+
+ default:
+ {
+ fHwBool = OBD_FALSE;
+ }
+
+ } // end of switch (NodeIdType_p)
+
+ // write flag
+ ObdSize = sizeof(fHwBool);
+ Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR
+ EPL_OBD_NODE_ID_INDEX,
+ EPL_OBD_NODE_ID_HWBOOL_SUBINDEX,
+ &fHwBool, ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ Exit:
+ return Ret;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- BOOL* pfEntryNumerical_p)
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ BOOL * pfEntryNumerical_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pObdSubEntry;
-
-
- // get pointer to index structure
- Ret = EplObdGetIndexIntern (&EPL_MCO_GLB_VAR (m_ObdInitParam),
- uiIndex_p,
- &pObdEntry);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get pointer to subindex structure
- Ret = EplObdGetSubindexIntern (pObdEntry,
- uiSubIndex_p,
- &pObdSubEntry);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- Ret = EplObdIsNumericalIntern(pObdSubEntry, pfEntryNumerical_p);
-
-
-Exit:
- return Ret;
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pObdSubEntry;
+
+ // get pointer to index structure
+ Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
+ uiIndex_p, &pObdEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get pointer to subindex structure
+ Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ Ret = EplObdIsNumericalIntern(pObdSubEntry, pfEntryNumerical_p);
+
+ Exit:
+ return Ret;
}
// State:
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pDstData_p,
- tEplObdSize * pSize_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pDstData_p,
+ tEplObdSize * pSize_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pSubEntry;
-tEplObdCbParam MEM CbParam;
-void * pSrcData;
-tEplObdSize ObdSize;
-
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- ASSERT (pDstData_p != NULL);
- ASSERT (pSize_p != NULL);
-
- // get address of index and subindex entry
- Ret = EplObdGetEntry (EPL_MCO_INSTANCE_PTR_
- uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get pointer to object data
- pSrcData = EplObdGetObjectDataPtrIntern (pSubEntry);
-
- // check source pointer
- if (pSrcData == NULL)
- {
- Ret = kEplObdReadViolation;
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // address of source data to structure of callback parameters
- // so callback function can change this data before reading
- CbParam.m_uiIndex = uiIndex_p;
- CbParam.m_uiSubIndex= uiSubIndex_p;
- CbParam.m_pArg = pSrcData;
- CbParam.m_ObdEvent = kEplObdEvPreRead;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, &CbParam);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get size of data and check if application has reserved enough memory
- ObdSize = EplObdGetDataSizeIntern (pSubEntry);
- // check if offset given and calc correct number of bytes to read
- if (*pSize_p < ObdSize)
- {
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
-
- // check if numerical type
- switch(pSubEntry->m_Type)
- {
- //-----------------------------------------------
- // types without ami
- case kEplObdTypVString:
- case kEplObdTypOString:
- case kEplObdTypDomain:
- default:
- {
- // read value from object
- EPL_MEMCPY (pDstData_p, pSrcData, ObdSize);
- break;
- }
-
- //-----------------------------------------------
- // numerical type which needs ami-write
- // 8 bit or smaller values
- case kEplObdTypBool:
- case kEplObdTypInt8:
- case kEplObdTypUInt8:
- {
- AmiSetByteToLe(pDstData_p, *((BYTE*)pSrcData));
- break;
- }
-
- // 16 bit values
- case kEplObdTypInt16:
- case kEplObdTypUInt16:
- {
- AmiSetWordToLe(pDstData_p, *((WORD*)pSrcData));
- break;
- }
-
- // 24 bit values
- case kEplObdTypInt24:
- case kEplObdTypUInt24:
- {
- AmiSetDword24ToLe(pDstData_p, *((DWORD*)pSrcData));
- break;
- }
-
- // 32 bit values
- case kEplObdTypInt32:
- case kEplObdTypUInt32:
- case kEplObdTypReal32:
- {
- AmiSetDwordToLe(pDstData_p, *((DWORD*)pSrcData));
- break;
- }
-
- // 40 bit values
- case kEplObdTypInt40:
- case kEplObdTypUInt40:
- {
- AmiSetQword40ToLe(pDstData_p, *((QWORD*)pSrcData));
- break;
- }
-
- // 48 bit values
- case kEplObdTypInt48:
- case kEplObdTypUInt48:
- {
- AmiSetQword48ToLe(pDstData_p, *((QWORD*)pSrcData));
- break;
- }
-
- // 56 bit values
- case kEplObdTypInt56:
- case kEplObdTypUInt56:
- {
- AmiSetQword56ToLe(pDstData_p, *((QWORD*)pSrcData));
- break;
- }
-
- // 64 bit values
- case kEplObdTypInt64:
- case kEplObdTypUInt64:
- case kEplObdTypReal64:
- {
- AmiSetQword64ToLe(pDstData_p, *((QWORD*)pSrcData));
- break;
- }
-
- // time of day
- case kEplObdTypTimeOfDay:
- case kEplObdTypTimeDiff:
- {
- AmiSetTimeOfDay(pDstData_p, ((tTimeOfDay*)pSrcData));
- break;
- }
-
- }// end of switch(pSubEntry->m_Type)
-
- *pSize_p = ObdSize;
-
-
- // write address of destination data to structure of callback parameters
- // so callback function can change this data after reading
- CbParam.m_pArg = pDstData_p;
- CbParam.m_ObdEvent = kEplObdEvPostRead;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, &CbParam);
-
-Exit:
-
- return Ret;
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pSubEntry;
+ tEplObdCbParam MEM CbParam;
+ void *pSrcData;
+ tEplObdSize ObdSize;
+
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ ASSERT(pDstData_p != NULL);
+ ASSERT(pSize_p != NULL);
+
+ // get address of index and subindex entry
+ Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get pointer to object data
+ pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
+
+ // check source pointer
+ if (pSrcData == NULL) {
+ Ret = kEplObdReadViolation;
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // address of source data to structure of callback parameters
+ // so callback function can change this data before reading
+ CbParam.m_uiIndex = uiIndex_p;
+ CbParam.m_uiSubIndex = uiSubIndex_p;
+ CbParam.m_pArg = pSrcData;
+ CbParam.m_ObdEvent = kEplObdEvPreRead;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, &CbParam);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get size of data and check if application has reserved enough memory
+ ObdSize = EplObdGetDataSizeIntern(pSubEntry);
+ // check if offset given and calc correct number of bytes to read
+ if (*pSize_p < ObdSize) {
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+ // check if numerical type
+ switch (pSubEntry->m_Type) {
+ //-----------------------------------------------
+ // types without ami
+ case kEplObdTypVString:
+ case kEplObdTypOString:
+ case kEplObdTypDomain:
+ default:
+ {
+ // read value from object
+ EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
+ break;
+ }
+
+ //-----------------------------------------------
+ // numerical type which needs ami-write
+ // 8 bit or smaller values
+ case kEplObdTypBool:
+ case kEplObdTypInt8:
+ case kEplObdTypUInt8:
+ {
+ AmiSetByteToLe(pDstData_p, *((BYTE *) pSrcData));
+ break;
+ }
+
+ // 16 bit values
+ case kEplObdTypInt16:
+ case kEplObdTypUInt16:
+ {
+ AmiSetWordToLe(pDstData_p, *((WORD *) pSrcData));
+ break;
+ }
+
+ // 24 bit values
+ case kEplObdTypInt24:
+ case kEplObdTypUInt24:
+ {
+ AmiSetDword24ToLe(pDstData_p, *((DWORD *) pSrcData));
+ break;
+ }
+
+ // 32 bit values
+ case kEplObdTypInt32:
+ case kEplObdTypUInt32:
+ case kEplObdTypReal32:
+ {
+ AmiSetDwordToLe(pDstData_p, *((DWORD *) pSrcData));
+ break;
+ }
+
+ // 40 bit values
+ case kEplObdTypInt40:
+ case kEplObdTypUInt40:
+ {
+ AmiSetQword40ToLe(pDstData_p, *((QWORD *) pSrcData));
+ break;
+ }
+
+ // 48 bit values
+ case kEplObdTypInt48:
+ case kEplObdTypUInt48:
+ {
+ AmiSetQword48ToLe(pDstData_p, *((QWORD *) pSrcData));
+ break;
+ }
+
+ // 56 bit values
+ case kEplObdTypInt56:
+ case kEplObdTypUInt56:
+ {
+ AmiSetQword56ToLe(pDstData_p, *((QWORD *) pSrcData));
+ break;
+ }
+
+ // 64 bit values
+ case kEplObdTypInt64:
+ case kEplObdTypUInt64:
+ case kEplObdTypReal64:
+ {
+ AmiSetQword64ToLe(pDstData_p, *((QWORD *) pSrcData));
+ break;
+ }
+
+ // time of day
+ case kEplObdTypTimeOfDay:
+ case kEplObdTypTimeDiff:
+ {
+ AmiSetTimeOfDay(pDstData_p, ((tTimeOfDay *) pSrcData));
+ break;
+ }
+
+ } // end of switch(pSubEntry->m_Type)
+
+ *pSize_p = ObdSize;
+
+ // write address of destination data to structure of callback parameters
+ // so callback function can change this data after reading
+ CbParam.m_pArg = pDstData_p;
+ CbParam.m_ObdEvent = kEplObdEvPostRead;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, &CbParam);
+
+ Exit:
+
+ return Ret;
}
// State:
//
//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pSrcData_p,
- tEplObdSize Size_p)
+EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pSrcData_p,
+ tEplObdSize Size_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pSubEntry;
-tEplObdCbParam MEM CbParam;
-void MEM* pDstData;
-tEplObdSize ObdSize;
-QWORD qwBuffer;
-void* pBuffer = &qwBuffer;
-
-
- Ret = EplObdWriteEntryPre (EPL_MCO_INSTANCE_PTR_
- uiIndex_p,
- uiSubIndex_p,
- pSrcData_p,
- &pDstData,
- Size_p,
- &pObdEntry,
- &pSubEntry,
- &CbParam,
- &ObdSize);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
-
- // check if numerical type
- switch(pSubEntry->m_Type)
- {
- //-----------------------------------------------
- // types without ami
- default:
- { // do nothing, i.e. use the given source pointer
- pBuffer = pSrcData_p;
- break;
- }
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pSubEntry;
+ tEplObdCbParam MEM CbParam;
+ void MEM *pDstData;
+ tEplObdSize ObdSize;
+ QWORD qwBuffer;
+ void *pBuffer = &qwBuffer;
+
+ Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p,
+ uiSubIndex_p,
+ pSrcData_p,
+ &pDstData,
+ Size_p,
+ &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ // check if numerical type
+ switch (pSubEntry->m_Type) {
+ //-----------------------------------------------
+ // types without ami
+ default:
+ { // do nothing, i.e. use the given source pointer
+ pBuffer = pSrcData_p;
+ break;
+ }
+
+ //-----------------------------------------------
+ // numerical type which needs ami-write
+ // 8 bit or smaller values
+ case kEplObdTypBool:
+ case kEplObdTypInt8:
+ case kEplObdTypUInt8:
+ {
+ *((BYTE *) pBuffer) = AmiGetByteFromLe(pSrcData_p);
+ break;
+ }
+
+ // 16 bit values
+ case kEplObdTypInt16:
+ case kEplObdTypUInt16:
+ {
+ *((WORD *) pBuffer) = AmiGetWordFromLe(pSrcData_p);
+ break;
+ }
+
+ // 24 bit values
+ case kEplObdTypInt24:
+ case kEplObdTypUInt24:
+ {
+ *((DWORD *) pBuffer) = AmiGetDword24FromLe(pSrcData_p);
+ break;
+ }
+
+ // 32 bit values
+ case kEplObdTypInt32:
+ case kEplObdTypUInt32:
+ case kEplObdTypReal32:
+ {
+ *((DWORD *) pBuffer) = AmiGetDwordFromLe(pSrcData_p);
+ break;
+ }
+
+ // 40 bit values
+ case kEplObdTypInt40:
+ case kEplObdTypUInt40:
+ {
+ *((QWORD *) pBuffer) = AmiGetQword40FromLe(pSrcData_p);
+ break;
+ }
+
+ // 48 bit values
+ case kEplObdTypInt48:
+ case kEplObdTypUInt48:
+ {
+ *((QWORD *) pBuffer) = AmiGetQword48FromLe(pSrcData_p);
+ break;
+ }
+
+ // 56 bit values
+ case kEplObdTypInt56:
+ case kEplObdTypUInt56:
+ {
+ *((QWORD *) pBuffer) = AmiGetQword56FromLe(pSrcData_p);
+ break;
+ }
+
+ // 64 bit values
+ case kEplObdTypInt64:
+ case kEplObdTypUInt64:
+ case kEplObdTypReal64:
+ {
+ *((QWORD *) pBuffer) = AmiGetQword64FromLe(pSrcData_p);
+ break;
+ }
+
+ // time of day
+ case kEplObdTypTimeOfDay:
+ case kEplObdTypTimeDiff:
+ {
+ AmiGetTimeOfDay(pBuffer, ((tTimeOfDay *) pSrcData_p));
+ break;
+ }
+
+ } // end of switch(pSubEntry->m_Type)
+
+ Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
+ pObdEntry,
+ pSubEntry,
+ &CbParam, pBuffer, pDstData, ObdSize);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ Exit:
+
+ return Ret;
- //-----------------------------------------------
- // numerical type which needs ami-write
- // 8 bit or smaller values
- case kEplObdTypBool:
- case kEplObdTypInt8:
- case kEplObdTypUInt8:
- {
- *((BYTE*)pBuffer) = AmiGetByteFromLe(pSrcData_p);
- break;
- }
-
- // 16 bit values
- case kEplObdTypInt16:
- case kEplObdTypUInt16:
- {
- *((WORD*)pBuffer) = AmiGetWordFromLe(pSrcData_p);
- break;
- }
-
- // 24 bit values
- case kEplObdTypInt24:
- case kEplObdTypUInt24:
- {
- *((DWORD*)pBuffer) = AmiGetDword24FromLe(pSrcData_p);
- break;
- }
+}
- // 32 bit values
- case kEplObdTypInt32:
- case kEplObdTypUInt32:
- case kEplObdTypReal32:
- {
- *((DWORD*)pBuffer) = AmiGetDwordFromLe(pSrcData_p);
- break;
- }
-
- // 40 bit values
- case kEplObdTypInt40:
- case kEplObdTypUInt40:
- {
- *((QWORD*)pBuffer) = AmiGetQword40FromLe(pSrcData_p);
- break;
- }
-
- // 48 bit values
- case kEplObdTypInt48:
- case kEplObdTypUInt48:
- {
- *((QWORD*)pBuffer) = AmiGetQword48FromLe(pSrcData_p);
- break;
- }
-
- // 56 bit values
- case kEplObdTypInt56:
- case kEplObdTypUInt56:
- {
- *((QWORD*)pBuffer) = AmiGetQword56FromLe(pSrcData_p);
- break;
- }
-
- // 64 bit values
- case kEplObdTypInt64:
- case kEplObdTypUInt64:
- case kEplObdTypReal64:
- {
- *((QWORD*)pBuffer) = AmiGetQword64FromLe(pSrcData_p);
- break;
- }
-
- // time of day
- case kEplObdTypTimeOfDay:
- case kEplObdTypTimeDiff:
- {
- AmiGetTimeOfDay(pBuffer, ((tTimeOfDay*)pSrcData_p));
- break;
- }
-
- }// end of switch(pSubEntry->m_Type)
-
-
- Ret = EplObdWriteEntryPost (EPL_MCO_INSTANCE_PTR_
- pObdEntry,
- pSubEntry,
- &CbParam,
- pBuffer,
- pDstData,
- ObdSize);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
-Exit:
-
- return Ret;
-
-}
-
-//---------------------------------------------------------------------------
-//
-// Function: EplObdGetAccessType()
-//
-// Description: Function returns accesstype of the entry
-//
-// Parameters: EPL_MCO_DECL_INSTANCE_PTR_
-// uiIndex_p = Index of the OD entry
-// uiSubIndex_p = Subindex of the OD Entry
-// pAccessTyp_p = pointer to buffer to store accesstype
-//
-// Return: tEplKernel = errorcode
-//
-//
-// State:
-//
-//---------------------------------------------------------------------------
-EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- tEplObdAccess* pAccessTyp_p)
-
-{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pObdSubEntry;
-
-
- // get pointer to index structure
- Ret = EplObdGetIndexIntern (&EPL_MCO_GLB_VAR (m_ObdInitParam),
- uiIndex_p,
- &pObdEntry);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get pointer to subindex structure
- Ret = EplObdGetSubindexIntern (pObdEntry,
- uiSubIndex_p,
- &pObdSubEntry);
- if(Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get accessType
- *pAccessTyp_p = pObdSubEntry->m_Access;
-
-
-Exit:
- return Ret;
-}
+//---------------------------------------------------------------------------
+//
+// Function: EplObdGetAccessType()
+//
+// Description: Function returns accesstype of the entry
+//
+// Parameters: EPL_MCO_DECL_INSTANCE_PTR_
+// uiIndex_p = Index of the OD entry
+// uiSubIndex_p = Subindex of the OD Entry
+// pAccessTyp_p = pointer to buffer to store accesstype
+//
+// Return: tEplKernel = errorcode
+//
+//
+// State:
+//
+//---------------------------------------------------------------------------
+EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ tEplObdAccess * pAccessTyp_p)
+{
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pObdSubEntry;
+
+ // get pointer to index structure
+ Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
+ uiIndex_p, &pObdEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get pointer to subindex structure
+ Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get accessType
+ *pAccessTyp_p = pObdSubEntry->m_Access;
+
+ Exit:
+ return Ret;
+}
//---------------------------------------------------------------------------
//
//
//---------------------------------------------------------------------------
-tEplKernel PUBLIC EplObdSearchVarEntry (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubindex_p,
- tEplObdVarEntry MEM** ppVarEntry_p)
+tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubindex_p,
+ tEplObdVarEntry MEM ** ppVarEntry_p)
{
-tEplKernel Ret;
-tEplObdSubEntryPtr pSubindexEntry;
+ tEplKernel Ret;
+ tEplObdSubEntryPtr pSubindexEntry;
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
- // get address of subindex entry
- Ret = EplObdGetEntry (EPL_MCO_INSTANCE_PTR_
- uiIndex_p, uiSubindex_p, NULL, &pSubindexEntry);
- if (Ret == kEplSuccessful)
- {
- // get var entry
- Ret = EplObdGetVarEntry (pSubindexEntry, ppVarEntry_p);
- }
+ // get address of subindex entry
+ Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p, uiSubindex_p, NULL, &pSubindexEntry);
+ if (Ret == kEplSuccessful) {
+ // get var entry
+ Ret = EplObdGetVarEntry(pSubindexEntry, ppVarEntry_p);
+ }
- return Ret;
+ return Ret;
}
+
//=========================================================================//
// //
// P R I V A T E D E F I N I T I O N S //
// //
//=========================================================================//
-EPL_MCO_DECL_INSTANCE_FCT ()
+EPL_MCO_DECL_INSTANCE_FCT()
//---------------------------------------------------------------------------
//
// Function: EplObdCallObjectCallback()
// State:
//
//---------------------------------------------------------------------------
-
-static tEplKernel EplObdCallObjectCallback (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdCallback fpCallback_p,
- tEplObdCbParam MEM* pCbParam_p)
+static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdCallback fpCallback_p,
+ tEplObdCbParam MEM * pCbParam_p)
{
-tEplKernel Ret;
-tEplObdCallback MEM fpCallback;
+ tEplKernel Ret;
+ tEplObdCallback MEM fpCallback;
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
- ASSERT (pCbParam_p != NULL);
+ ASSERT(pCbParam_p != NULL);
- Ret = kEplSuccessful;
+ Ret = kEplSuccessful;
- // check address of callback function before calling it
- if (fpCallback_p != NULL)
- {
- // KEIL C51 V6.01 has a bug.
- // Therefore the parameter fpCallback_p has to be copied in local variable fpCallback.
- fpCallback = fpCallback_p;
+ // check address of callback function before calling it
+ if (fpCallback_p != NULL) {
+ // KEIL C51 V6.01 has a bug.
+ // Therefore the parameter fpCallback_p has to be copied in local variable fpCallback.
+ fpCallback = fpCallback_p;
- // call callback function for this object
- Ret = fpCallback (EPL_MCO_INSTANCE_PARAM_IDX_()
- pCbParam_p);
- }
+ // call callback function for this object
+ Ret = fpCallback(EPL_MCO_INSTANCE_PARAM_IDX_()
+ pCbParam_p);
+ }
- return Ret;
+ return Ret;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
-static tEplObdSize EplObdGetDataSizeIntern (tEplObdSubEntryPtr pSubIndexEntry_p)
+static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p)
{
-tEplObdSize DataSize;
-void MEM* pData;
+ tEplObdSize DataSize;
+ void MEM *pData;
- // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
- // then the current pointer is always NULL. The function
- // returns the length of default string.
- DataSize = EplObdGetObjectSize (pSubIndexEntry_p);
+ // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
+ // then the current pointer is always NULL. The function
+ // returns the length of default string.
+ DataSize = EplObdGetObjectSize(pSubIndexEntry_p);
- if (pSubIndexEntry_p->m_Type == kEplObdTypVString)
- {
- // The pointer to current value can be received from EplObdGetObjectCurrentPtr()
- pData = ((void MEM*) EplObdGetObjectCurrentPtr (pSubIndexEntry_p));
- if (pData != NULL)
- {
- DataSize = EplObdGetStrLen ((void *) pData, DataSize, pSubIndexEntry_p->m_Type);
- }
+ if (pSubIndexEntry_p->m_Type == kEplObdTypVString) {
+ // The pointer to current value can be received from EplObdGetObjectCurrentPtr()
+ pData =
+ ((void MEM *)EplObdGetObjectCurrentPtr(pSubIndexEntry_p));
+ if (pData != NULL) {
+ DataSize =
+ EplObdGetStrLen((void *)pData, DataSize,
+ pSubIndexEntry_p->m_Type);
+ }
- }
+ }
- return DataSize;
+ return DataSize;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetStrLen()
//
//---------------------------------------------------------------------------
-static tEplObdSize EplObdGetStrLen (void * pObjData_p,
- tEplObdSize ObjLen_p,
- tEplObdType ObjType_p)
+static tEplObdSize EplObdGetStrLen(void *pObjData_p,
+ tEplObdSize ObjLen_p, tEplObdType ObjType_p)
{
-tEplObdSize StrLen = 0;
-BYTE * pbString;
-
- if (pObjData_p == NULL)
- {
- goto Exit;
- }
-
- //----------------------------------------
- // Visible String: data format byte
- if (ObjType_p == kEplObdTypVString)
- {
- pbString = pObjData_p;
+ tEplObdSize StrLen = 0;
+ BYTE *pbString;
- for (StrLen = 0; StrLen < ObjLen_p; StrLen++)
- {
- if (*pbString == '\0')
- {
- StrLen++;
- break;
- }
+ if (pObjData_p == NULL) {
+ goto Exit;
+ }
+ //----------------------------------------
+ // Visible String: data format byte
+ if (ObjType_p == kEplObdTypVString) {
+ pbString = pObjData_p;
- pbString++;
- }
- }
+ for (StrLen = 0; StrLen < ObjLen_p; StrLen++) {
+ if (*pbString == '\0') {
+ StrLen++;
+ break;
+ }
- //----------------------------------------
- // other string types ...
+ pbString++;
+ }
+ }
+ //----------------------------------------
+ // other string types ...
-Exit:
- return (StrLen);
+ Exit:
+ return (StrLen);
}
-
-
#if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdCheckObjectRange (
- tEplObdSubEntryPtr pSubindexEntry_p,
- void * pData_p)
+static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
+ void *pData_p)
{
-tEplKernel Ret;
-void * pRangeData;
-
- ASSERTMSG (pSubindexEntry_p != NULL,
- "EplObdCheckObjectRange(): no address to subindex struct!\n");
-
- Ret = kEplSuccessful;
-
- // check if data range has to be checked
- if ((pSubindexEntry_p->m_Access & kEplObdAccRange) == 0)
- {
- goto Exit;
- }
-
- // get address of default data
- pRangeData = pSubindexEntry_p->m_pDefault;
-
- // jump to called object type
- switch ((tEplObdType) pSubindexEntry_p->m_Type)
- {
- // -----------------------------------------------------------------
- // ObdType kEplObdTypBool will not be checked because there are only
- // two possible values 0 or 1.
-
- // -----------------------------------------------------------------
- // ObdTypes which has to be check up because numerical values
- case kEplObdTypInt8:
-
- // switch to lower limit
- pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdInteger8 *) pData_p) < *((tEplObdInteger8 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdInteger8 *) pData_p) > *((tEplObdInteger8 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypUInt8:
-
- // switch to lower limit
- pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdUnsigned8 *) pData_p) < *((tEplObdUnsigned8 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdUnsigned8*) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdUnsigned8 *) pData_p) > *((tEplObdUnsigned8 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypInt16:
-
- // switch to lower limit
- pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdInteger16 *) pData_p) < *((tEplObdInteger16 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdInteger16 *) pData_p) > *((tEplObdInteger16 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypUInt16:
-
- // switch to lower limit
- pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdUnsigned16 *) pData_p) < *((tEplObdUnsigned16 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdUnsigned16 *) pData_p) > *((tEplObdUnsigned16 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypInt32:
-
- // switch to lower limit
- pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdInteger32 *) pData_p) < *((tEplObdInteger32 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdInteger32 *) pData_p) > *((tEplObdInteger32 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypUInt32:
-
- // switch to lower limit
- pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdUnsigned32 *) pData_p) < *((tEplObdUnsigned32 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdUnsigned32 *) pData_p) > *((tEplObdUnsigned32 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- case kEplObdTypReal32:
-
- // switch to lower limit
- pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdReal32 *) pData_p) < *((tEplObdReal32 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdReal32 *) pData_p) > *((tEplObdReal32 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt40:
- case kEplObdTypInt48:
- case kEplObdTypInt56:
- case kEplObdTypInt64:
-
- // switch to lower limit
- pRangeData = ((signed QWORD *) pRangeData) + 1;
-
- // check if value is to low
- if (*((signed QWORD *) pData_p) < *((signed QWORD *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((signed QWORD *) pRangeData) + 1;
-
- // check if value is to high
- if (*((signed QWORD *) pData_p) > *((signed QWORD *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypUInt40:
- case kEplObdTypUInt48:
- case kEplObdTypUInt56:
- case kEplObdTypUInt64:
-
- // switch to lower limit
- pRangeData = ((unsigned QWORD *) pRangeData) + 1;
-
- // check if value is to low
- if (*((unsigned QWORD *) pData_p) < *((unsigned QWORD *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((unsigned QWORD *) pRangeData) + 1;
-
- // check if value is to high
- if (*((unsigned QWORD *) pData_p) > *((unsigned QWORD *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypReal64:
-
- // switch to lower limit
- pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
-
- // check if value is to low
- if (*((tEplObdReal64 *) pData_p) < *((tEplObdReal64 *) pRangeData))
- {
- Ret = kEplObdValueTooLow;
- break;
- }
-
- // switch to higher limit
- pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
-
- // check if value is to high
- if (*((tEplObdReal64 *) pData_p) > *((tEplObdReal64 *) pRangeData))
- {
- Ret = kEplObdValueTooHigh;
- }
-
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypTimeOfDay:
- case kEplObdTypTimeDiff:
- break;
-
- // -----------------------------------------------------------------
- // ObdTypes kEplObdTypXString and kEplObdTypDomain can not be checkt because
- // they have no numerical value.
- default:
-
- Ret = kEplObdUnknownObjectType;
- break;
- }
-
-Exit:
-
- return Ret;
+ tEplKernel Ret;
+ void *pRangeData;
+
+ ASSERTMSG(pSubindexEntry_p != NULL,
+ "EplObdCheckObjectRange(): no address to subindex struct!\n");
+
+ Ret = kEplSuccessful;
+
+ // check if data range has to be checked
+ if ((pSubindexEntry_p->m_Access & kEplObdAccRange) == 0) {
+ goto Exit;
+ }
+ // get address of default data
+ pRangeData = pSubindexEntry_p->m_pDefault;
+
+ // jump to called object type
+ switch ((tEplObdType) pSubindexEntry_p->m_Type) {
+ // -----------------------------------------------------------------
+ // ObdType kEplObdTypBool will not be checked because there are only
+ // two possible values 0 or 1.
+
+ // -----------------------------------------------------------------
+ // ObdTypes which has to be check up because numerical values
+ case kEplObdTypInt8:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdInteger8 *) pData_p) <
+ *((tEplObdInteger8 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdInteger8 *) pData_p) >
+ *((tEplObdInteger8 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypUInt8:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdUnsigned8 *) pData_p) <
+ *((tEplObdUnsigned8 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdUnsigned8 *) pData_p) >
+ *((tEplObdUnsigned8 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypInt16:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdInteger16 *) pData_p) <
+ *((tEplObdInteger16 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdInteger16 *) pData_p) >
+ *((tEplObdInteger16 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypUInt16:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdUnsigned16 *) pData_p) <
+ *((tEplObdUnsigned16 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdUnsigned16 *) pData_p) >
+ *((tEplObdUnsigned16 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypInt32:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdInteger32 *) pData_p) <
+ *((tEplObdInteger32 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdInteger32 *) pData_p) >
+ *((tEplObdInteger32 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypUInt32:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdUnsigned32 *) pData_p) <
+ *((tEplObdUnsigned32 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdUnsigned32 *) pData_p) >
+ *((tEplObdUnsigned32 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ case kEplObdTypReal32:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdReal32 *) pData_p) <
+ *((tEplObdReal32 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdReal32 *) pData_p) >
+ *((tEplObdReal32 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt40:
+ case kEplObdTypInt48:
+ case kEplObdTypInt56:
+ case kEplObdTypInt64:
+
+ // switch to lower limit
+ pRangeData = ((signed QWORD *)pRangeData) + 1;
+
+ // check if value is to low
+ if (*((signed QWORD *)pData_p) < *((signed QWORD *)pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((signed QWORD *)pRangeData) + 1;
+
+ // check if value is to high
+ if (*((signed QWORD *)pData_p) > *((signed QWORD *)pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypUInt40:
+ case kEplObdTypUInt48:
+ case kEplObdTypUInt56:
+ case kEplObdTypUInt64:
+
+ // switch to lower limit
+ pRangeData = ((unsigned QWORD *)pRangeData) + 1;
+
+ // check if value is to low
+ if (*((unsigned QWORD *)pData_p) <
+ *((unsigned QWORD *)pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((unsigned QWORD *)pRangeData) + 1;
+
+ // check if value is to high
+ if (*((unsigned QWORD *)pData_p) >
+ *((unsigned QWORD *)pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypReal64:
+
+ // switch to lower limit
+ pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
+
+ // check if value is to low
+ if (*((tEplObdReal64 *) pData_p) <
+ *((tEplObdReal64 *) pRangeData)) {
+ Ret = kEplObdValueTooLow;
+ break;
+ }
+ // switch to higher limit
+ pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
+
+ // check if value is to high
+ if (*((tEplObdReal64 *) pData_p) >
+ *((tEplObdReal64 *) pRangeData)) {
+ Ret = kEplObdValueTooHigh;
+ }
+
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypTimeOfDay:
+ case kEplObdTypTimeDiff:
+ break;
+
+ // -----------------------------------------------------------------
+ // ObdTypes kEplObdTypXString and kEplObdTypDomain can not be checkt because
+ // they have no numerical value.
+ default:
+
+ Ret = kEplObdUnknownObjectType;
+ break;
+ }
+
+ Exit:
+
+ return Ret;
}
#endif // (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
//
//---------------------------------------------------------------------------
-static tEplKernel PUBLIC EplObdWriteEntryPre (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubIndex_p,
- void * pSrcData_p,
- void** ppDstData_p,
- tEplObdSize Size_p,
- tEplObdEntryPtr* ppObdEntry_p,
- tEplObdSubEntryPtr* ppSubEntry_p,
- tEplObdCbParam MEM* pCbParam_p,
- tEplObdSize* pObdSize_p)
+static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubIndex_p,
+ void *pSrcData_p,
+ void **ppDstData_p,
+ tEplObdSize Size_p,
+ tEplObdEntryPtr * ppObdEntry_p,
+ tEplObdSubEntryPtr * ppSubEntry_p,
+ tEplObdCbParam MEM * pCbParam_p,
+ tEplObdSize * pObdSize_p)
{
-tEplKernel Ret;
-tEplObdEntryPtr pObdEntry;
-tEplObdSubEntryPtr pSubEntry;
-tEplObdAccess Access;
-void MEM* pDstData;
-tEplObdSize ObdSize;
-BOOL fEntryNumerical;
+ tEplKernel Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdSubEntryPtr pSubEntry;
+ tEplObdAccess Access;
+ void MEM *pDstData;
+ tEplObdSize ObdSize;
+ BOOL fEntryNumerical;
#if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
- tEplObdVStringDomain MEM MemVStringDomain;
- void MEM* pCurrData;
+ tEplObdVStringDomain MEM MemVStringDomain;
+ void MEM *pCurrData;
#endif
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- ASSERT (pSrcData_p != NULL); // should never be NULL
-
- //------------------------------------------------------------------------
- // get address of index and subindex entry
- Ret = EplObdGetEntry (EPL_MCO_INSTANCE_PTR_
- uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // get pointer to object data
- pDstData = (void MEM*) EplObdGetObjectDataPtrIntern (pSubEntry);
-
- Access = (tEplObdAccess) pSubEntry->m_Access;
-
- // check access for write
- // access violation if adress to current value is NULL
- if ( ((Access & kEplObdAccConst) != 0) ||
- (pDstData == NULL) )
- {
- Ret = kEplObdAccessViolation;
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // get size of object
- // -as ObdSize = ObdGetObjectSize (pSubEntry);
-
- //------------------------------------------------------------------------
- // To use the same callback function for ObdWriteEntry as well as for
- // an SDO download call at first (kEplObdEvPre...) the callback function
- // with the argument pointer to object size.
- pCbParam_p->m_uiIndex = uiIndex_p;
- pCbParam_p->m_uiSubIndex = uiSubIndex_p;
-
- // Because object size and object pointer are
- // adapted by user callback function, re-read
- // this values.
- ObdSize = EplObdGetObjectSize (pSubEntry);
- pDstData = (void MEM*) EplObdGetObjectDataPtrIntern (pSubEntry);
-
- // 09-dec-2004 r.d.:
- // Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain
- // for String or Domain which lets called module directly change
- // the data pointer or size. This prevents a recursive call to
- // the callback function if it calls EplObdGetEntry().
- #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
- if ( (pSubEntry->m_Type == kEplObdTypVString) ||
- (pSubEntry->m_Type == kEplObdTypDomain) ||
- (pSubEntry->m_Type == kEplObdTypOString))
- {
- if (pSubEntry->m_Type == kEplObdTypVString)
- {
- // reserve one byte for 0-termination
- // -as ObdSize -= 1;
- Size_p += 1;
- }
-
- // fill out new arg-struct
- MemVStringDomain.m_DownloadSize = Size_p;
- MemVStringDomain.m_ObjSize = ObdSize;
- MemVStringDomain.m_pData = pDstData;
-
- pCbParam_p->m_ObdEvent = kEplObdEvWrStringDomain;
- pCbParam_p->m_pArg = &MemVStringDomain;
- // call user callback
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, pCbParam_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // write back new settings
- pCurrData = pSubEntry->m_pCurrent;
- if ((pSubEntry->m_Type == kEplObdTypVString)
- ||(pSubEntry->m_Type == kEplObdTypOString))
- {
- ((tEplObdVString MEM*) pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
- ((tEplObdVString MEM*) pCurrData)->m_pString = MemVStringDomain.m_pData;
- }
- else // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain)
- {
- ((tEplObdVarEntry MEM*) pCurrData)->m_Size = MemVStringDomain.m_ObjSize;
- ((tEplObdVarEntry MEM*) pCurrData)->m_pData = (void MEM*) MemVStringDomain.m_pData;
- }
-
- // Because object size and object pointer are
- // adapted by user callback function, re-read
- // this values.
- ObdSize = MemVStringDomain.m_ObjSize;
- pDstData = (void MEM*) MemVStringDomain.m_pData;
- }
- #endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
-
- // 07-dec-2004 r.d.: size from application is needed because callback function can change the object size
- // -as 16.11.04 CbParam.m_pArg = &ObdSize;
- // 09-dec-2004 r.d.: CbParam.m_pArg = &Size_p;
- pCbParam_p->m_pArg = &ObdSize;
- pCbParam_p->m_ObdEvent = kEplObdEvInitWrite;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, pCbParam_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- if (Size_p > ObdSize)
- {
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
-
- if (pSubEntry->m_Type == kEplObdTypVString)
- {
- if (((char MEM*) pSrcData_p)[Size_p - 1] == '\0')
- { // last byte of source string contains null character
-
- // reserve one byte in destination for 0-termination
- Size_p -= 1;
- }
- else if (Size_p >= ObdSize)
- { // source string is not 0-terminated
- // and destination buffer is too short
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
- }
-
- Ret = EplObdIsNumericalIntern(pSubEntry, &fEntryNumerical);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- if ((fEntryNumerical != FALSE)
- && (Size_p != ObdSize))
- {
- // type is numerical, therefor size has to fit, but it does not.
- Ret = kEplObdValueLengthError;
- goto Exit;
- }
-
- // use given size, because non-numerical objects can be written with shorter values
- ObdSize = Size_p;
-
- // set output parameters
- *pObdSize_p = ObdSize;
- *ppObdEntry_p = pObdEntry;
- *ppSubEntry_p = pSubEntry;
- *ppDstData_p = pDstData;
-
- // all checks are done
- // the caller may now convert the numerial source value to platform byte order in a temporary buffer
-
-Exit:
-
- return Ret;
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ ASSERT(pSrcData_p != NULL); // should never be NULL
+
+ //------------------------------------------------------------------------
+ // get address of index and subindex entry
+ Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
+ uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // get pointer to object data
+ pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry);
+
+ Access = (tEplObdAccess) pSubEntry->m_Access;
+
+ // check access for write
+ // access violation if adress to current value is NULL
+ if (((Access & kEplObdAccConst) != 0) || (pDstData == NULL)) {
+ Ret = kEplObdAccessViolation;
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // get size of object
+ // -as ObdSize = ObdGetObjectSize (pSubEntry);
+
+ //------------------------------------------------------------------------
+ // To use the same callback function for ObdWriteEntry as well as for
+ // an SDO download call at first (kEplObdEvPre...) the callback function
+ // with the argument pointer to object size.
+ pCbParam_p->m_uiIndex = uiIndex_p;
+ pCbParam_p->m_uiSubIndex = uiSubIndex_p;
+
+ // Because object size and object pointer are
+ // adapted by user callback function, re-read
+ // this values.
+ ObdSize = EplObdGetObjectSize(pSubEntry);
+ pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry);
+
+ // 09-dec-2004 r.d.:
+ // Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain
+ // for String or Domain which lets called module directly change
+ // the data pointer or size. This prevents a recursive call to
+ // the callback function if it calls EplObdGetEntry().
+#if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
+ if ((pSubEntry->m_Type == kEplObdTypVString) ||
+ (pSubEntry->m_Type == kEplObdTypDomain) ||
+ (pSubEntry->m_Type == kEplObdTypOString)) {
+ if (pSubEntry->m_Type == kEplObdTypVString) {
+ // reserve one byte for 0-termination
+ // -as ObdSize -= 1;
+ Size_p += 1;
+ }
+ // fill out new arg-struct
+ MemVStringDomain.m_DownloadSize = Size_p;
+ MemVStringDomain.m_ObjSize = ObdSize;
+ MemVStringDomain.m_pData = pDstData;
+
+ pCbParam_p->m_ObdEvent = kEplObdEvWrStringDomain;
+ pCbParam_p->m_pArg = &MemVStringDomain;
+ // call user callback
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback,
+ pCbParam_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // write back new settings
+ pCurrData = pSubEntry->m_pCurrent;
+ if ((pSubEntry->m_Type == kEplObdTypVString)
+ || (pSubEntry->m_Type == kEplObdTypOString)) {
+ ((tEplObdVString MEM *) pCurrData)->m_Size =
+ MemVStringDomain.m_ObjSize;
+ ((tEplObdVString MEM *) pCurrData)->m_pString =
+ MemVStringDomain.m_pData;
+ } else // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain)
+ {
+ ((tEplObdVarEntry MEM *) pCurrData)->m_Size =
+ MemVStringDomain.m_ObjSize;
+ ((tEplObdVarEntry MEM *) pCurrData)->m_pData =
+ (void MEM *)MemVStringDomain.m_pData;
+ }
+
+ // Because object size and object pointer are
+ // adapted by user callback function, re-read
+ // this values.
+ ObdSize = MemVStringDomain.m_ObjSize;
+ pDstData = (void MEM *)MemVStringDomain.m_pData;
+ }
+#endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
+
+ // 07-dec-2004 r.d.: size from application is needed because callback function can change the object size
+ // -as 16.11.04 CbParam.m_pArg = &ObdSize;
+ // 09-dec-2004 r.d.: CbParam.m_pArg = &Size_p;
+ pCbParam_p->m_pArg = &ObdSize;
+ pCbParam_p->m_ObdEvent = kEplObdEvInitWrite;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, pCbParam_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ if (Size_p > ObdSize) {
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+
+ if (pSubEntry->m_Type == kEplObdTypVString) {
+ if (((char MEM *)pSrcData_p)[Size_p - 1] == '\0') { // last byte of source string contains null character
+
+ // reserve one byte in destination for 0-termination
+ Size_p -= 1;
+ } else if (Size_p >= ObdSize) { // source string is not 0-terminated
+ // and destination buffer is too short
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+ }
+
+ Ret = EplObdIsNumericalIntern(pSubEntry, &fEntryNumerical);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+
+ if ((fEntryNumerical != FALSE)
+ && (Size_p != ObdSize)) {
+ // type is numerical, therefor size has to fit, but it does not.
+ Ret = kEplObdValueLengthError;
+ goto Exit;
+ }
+ // use given size, because non-numerical objects can be written with shorter values
+ ObdSize = Size_p;
+
+ // set output parameters
+ *pObdSize_p = ObdSize;
+ *ppObdEntry_p = pObdEntry;
+ *ppSubEntry_p = pSubEntry;
+ *ppDstData_p = pDstData;
+
+ // all checks are done
+ // the caller may now convert the numerial source value to platform byte order in a temporary buffer
+
+ Exit:
+
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdWriteEntryPost()
//
//---------------------------------------------------------------------------
-static tEplKernel PUBLIC EplObdWriteEntryPost (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdEntryPtr pObdEntry_p,
- tEplObdSubEntryPtr pSubEntry_p,
- tEplObdCbParam MEM* pCbParam_p,
- void * pSrcData_p,
- void * pDstData_p,
- tEplObdSize ObdSize_p)
+static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdEntryPtr pObdEntry_p,
+ tEplObdSubEntryPtr pSubEntry_p,
+ tEplObdCbParam MEM * pCbParam_p,
+ void *pSrcData_p,
+ void *pDstData_p,
+ tEplObdSize ObdSize_p)
{
-tEplKernel Ret;
-
-
- // caller converted the source value to platform byte order
- // now the range of the value may be checked
-
- #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
- {
- // check data range
- Ret = EplObdCheckObjectRange (pSubEntry_p, pSrcData_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
- #endif
-
- // now call user callback function to check value
- // write address of source data to structure of callback parameters
- // so callback function can check this data
- pCbParam_p->m_pArg = pSrcData_p;
- pCbParam_p->m_ObdEvent = kEplObdEvPreWrite;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry_p->m_fpCallback, pCbParam_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // copy object data to OBD
- EPL_MEMCPY (pDstData_p, pSrcData_p, ObdSize_p);
-
- // terminate string with 0
- if (pSubEntry_p->m_Type == kEplObdTypVString)
- {
- ((char MEM*) pDstData_p)[ObdSize_p] = '\0';
- }
+ tEplKernel Ret;
- // write address of destination to structure of callback parameters
- // so callback function can change data subsequently
- pCbParam_p->m_pArg = pDstData_p;
- pCbParam_p->m_ObdEvent = kEplObdEvPostWrite;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry_p->m_fpCallback, pCbParam_p);
+ // caller converted the source value to platform byte order
+ // now the range of the value may be checked
-Exit:
+#if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
+ {
+ // check data range
+ Ret = EplObdCheckObjectRange(pSubEntry_p, pSrcData_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+#endif
- return Ret;
+ // now call user callback function to check value
+ // write address of source data to structure of callback parameters
+ // so callback function can check this data
+ pCbParam_p->m_pArg = pSrcData_p;
+ pCbParam_p->m_ObdEvent = kEplObdEvPreWrite;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry_p->m_fpCallback, pCbParam_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // copy object data to OBD
+ EPL_MEMCPY(pDstData_p, pSrcData_p, ObdSize_p);
+
+ // terminate string with 0
+ if (pSubEntry_p->m_Type == kEplObdTypVString) {
+ ((char MEM *)pDstData_p)[ObdSize_p] = '\0';
+ }
+ // write address of destination to structure of callback parameters
+ // so callback function can change data subsequently
+ pCbParam_p->m_pArg = pDstData_p;
+ pCbParam_p->m_ObdEvent = kEplObdEvPostWrite;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry_p->m_fpCallback, pCbParam_p);
+
+ Exit:
+
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetObjectSize()
//
//---------------------------------------------------------------------------
-static tEplObdSize EplObdGetObjectSize (tEplObdSubEntryPtr pSubIndexEntry_p)
+static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
{
-tEplObdSize DataSize = 0;
-void * pData;
-
- switch (pSubIndexEntry_p->m_Type)
- {
- // -----------------------------------------------------------------
- case kEplObdTypBool:
-
- DataSize = 1;
- break;
-
- // -----------------------------------------------------------------
- // ObdTypes which has to be check because numerical values
- case kEplObdTypInt8:
- DataSize = sizeof (tEplObdInteger8);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypUInt8:
- DataSize = sizeof (tEplObdUnsigned8);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt16:
- DataSize = sizeof (tEplObdInteger16);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypUInt16:
- DataSize = sizeof (tEplObdUnsigned16);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt32:
- DataSize = sizeof (tEplObdInteger32);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypUInt32:
- DataSize = sizeof (tEplObdUnsigned32);
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypReal32:
- DataSize = sizeof (tEplObdReal32);
- break;
-
- // -----------------------------------------------------------------
- // ObdTypes which has to be not checked because not NUM values
- case kEplObdTypDomain:
-
- pData = (void *) pSubIndexEntry_p->m_pCurrent;
- if ((void MEM*) pData != (void MEM*) NULL)
- {
- DataSize = ((tEplObdVarEntry MEM*) pData)->m_Size;
- }
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypVString:
- //case kEplObdTypUString:
-
- // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
- // then the current pointer is always NULL. The function
- // returns the length of default string.
- pData = (void *) pSubIndexEntry_p->m_pCurrent;
- if ((void MEM*) pData != (void MEM*) NULL)
- {
- // The max. size of strings defined by STRING-Macro is stored in
- // tEplObdVString of current value.
- // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
- DataSize = ((tEplObdVString MEM*) pData)->m_Size;
- }
- else
- {
- // The current position is not decleared. The string
- // is located in ROM, therefor use default pointer.
- pData = (void *) pSubIndexEntry_p->m_pDefault;
- if ((CONST void ROM*) pData != (CONST void ROM*) NULL)
- {
- // The max. size of strings defined by STRING-Macro is stored in
- // tEplObdVString of default value.
- DataSize = ((CONST tEplObdVString ROM*) pData)->m_Size;
- }
- }
-
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypOString:
-
- pData = (void *) pSubIndexEntry_p->m_pCurrent;
- if ((void MEM*) pData != (void MEM*) NULL)
- {
- // The max. size of strings defined by STRING-Macro is stored in
- // tEplObdVString of current value.
- // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
- DataSize = ((tEplObdOString MEM*) pData)->m_Size;
- }
- else
- {
- // The current position is not decleared. The string
- // is located in ROM, therefor use default pointer.
- pData = (void *) pSubIndexEntry_p->m_pDefault;
- if ((CONST void ROM*) pData != (CONST void ROM*) NULL)
- {
- // The max. size of strings defined by STRING-Macro is stored in
- // tEplObdVString of default value.
- DataSize = ((CONST tEplObdOString ROM*) pData)->m_Size;
- }
- }
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt24:
- case kEplObdTypUInt24:
-
- DataSize = 3;
- break;
-
-
- // -----------------------------------------------------------------
- case kEplObdTypInt40:
- case kEplObdTypUInt40:
-
- DataSize = 5;
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt48:
- case kEplObdTypUInt48:
-
- DataSize = 6;
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt56:
- case kEplObdTypUInt56:
-
- DataSize = 7;
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypInt64:
- case kEplObdTypUInt64:
- case kEplObdTypReal64:
-
- DataSize = 8;
- break;
-
- // -----------------------------------------------------------------
- case kEplObdTypTimeOfDay:
- case kEplObdTypTimeDiff:
-
- DataSize = 6;
- break;
-
- // -----------------------------------------------------------------
- default:
- break;
- }
-
- return DataSize;
+ tEplObdSize DataSize = 0;
+ void *pData;
+
+ switch (pSubIndexEntry_p->m_Type) {
+ // -----------------------------------------------------------------
+ case kEplObdTypBool:
+
+ DataSize = 1;
+ break;
+
+ // -----------------------------------------------------------------
+ // ObdTypes which has to be check because numerical values
+ case kEplObdTypInt8:
+ DataSize = sizeof(tEplObdInteger8);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypUInt8:
+ DataSize = sizeof(tEplObdUnsigned8);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt16:
+ DataSize = sizeof(tEplObdInteger16);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypUInt16:
+ DataSize = sizeof(tEplObdUnsigned16);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt32:
+ DataSize = sizeof(tEplObdInteger32);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypUInt32:
+ DataSize = sizeof(tEplObdUnsigned32);
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypReal32:
+ DataSize = sizeof(tEplObdReal32);
+ break;
+
+ // -----------------------------------------------------------------
+ // ObdTypes which has to be not checked because not NUM values
+ case kEplObdTypDomain:
+
+ pData = (void *)pSubIndexEntry_p->m_pCurrent;
+ if ((void MEM *)pData != (void MEM *)NULL) {
+ DataSize = ((tEplObdVarEntry MEM *) pData)->m_Size;
+ }
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypVString:
+ //case kEplObdTypUString:
+
+ // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
+ // then the current pointer is always NULL. The function
+ // returns the length of default string.
+ pData = (void *)pSubIndexEntry_p->m_pCurrent;
+ if ((void MEM *)pData != (void MEM *)NULL) {
+ // The max. size of strings defined by STRING-Macro is stored in
+ // tEplObdVString of current value.
+ // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
+ DataSize = ((tEplObdVString MEM *) pData)->m_Size;
+ } else {
+ // The current position is not decleared. The string
+ // is located in ROM, therefor use default pointer.
+ pData = (void *)pSubIndexEntry_p->m_pDefault;
+ if ((CONST void ROM *)pData != (CONST void ROM *)NULL) {
+ // The max. size of strings defined by STRING-Macro is stored in
+ // tEplObdVString of default value.
+ DataSize =
+ ((CONST tEplObdVString ROM *) pData)->
+ m_Size;
+ }
+ }
+
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypOString:
+
+ pData = (void *)pSubIndexEntry_p->m_pCurrent;
+ if ((void MEM *)pData != (void MEM *)NULL) {
+ // The max. size of strings defined by STRING-Macro is stored in
+ // tEplObdVString of current value.
+ // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
+ DataSize = ((tEplObdOString MEM *) pData)->m_Size;
+ } else {
+ // The current position is not decleared. The string
+ // is located in ROM, therefor use default pointer.
+ pData = (void *)pSubIndexEntry_p->m_pDefault;
+ if ((CONST void ROM *)pData != (CONST void ROM *)NULL) {
+ // The max. size of strings defined by STRING-Macro is stored in
+ // tEplObdVString of default value.
+ DataSize =
+ ((CONST tEplObdOString ROM *) pData)->
+ m_Size;
+ }
+ }
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt24:
+ case kEplObdTypUInt24:
+
+ DataSize = 3;
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt40:
+ case kEplObdTypUInt40:
+
+ DataSize = 5;
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt48:
+ case kEplObdTypUInt48:
+
+ DataSize = 6;
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt56:
+ case kEplObdTypUInt56:
+
+ DataSize = 7;
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypInt64:
+ case kEplObdTypUInt64:
+ case kEplObdTypReal64:
+
+ DataSize = 8;
+ break;
+
+ // -----------------------------------------------------------------
+ case kEplObdTypTimeOfDay:
+ case kEplObdTypTimeDiff:
+
+ DataSize = 6;
+ break;
+
+ // -----------------------------------------------------------------
+ default:
+ break;
+ }
+
+ return DataSize;
}
//---------------------------------------------------------------------------
//
//---------------------------------------------------------------------------
-static void * EplObdGetObjectDefaultPtr (tEplObdSubEntryPtr pSubIndexEntry_p)
+static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
{
-void * pDefault;
-tEplObdType Type;
-
- ASSERTMSG (pSubIndexEntry_p != NULL, "EplObdGetObjectDefaultPtr(): pointer to SubEntry not valid!\n");
-
- // get address to default data from default pointer
- pDefault = pSubIndexEntry_p->m_pDefault;
- if (pDefault != NULL)
- {
- // there are some special types, whose default pointer always is NULL or has to get from other structure
- // get type from subindex structure
- Type = pSubIndexEntry_p->m_Type;
-
- // check if object type is a string value
- if ((Type == kEplObdTypVString) /* ||
- (Type == kEplObdTypUString) */ )
- {
-
- // EPL_OBD_SUBINDEX_RAM_VSTRING
- // tEplObdSize m_Size; --> size of default string
- // char * m_pDefString; --> pointer to default string
- // char * m_pString; --> pointer to string in RAM
- //
- pDefault = (void *) ((tEplObdVString *) pDefault)->m_pString;
- }
- else if(Type == kEplObdTypOString)
- {
- pDefault = (void *) ((tEplObdOString *) pDefault)->m_pString;
- }
- }
-
- return pDefault;
+ void *pDefault;
+ tEplObdType Type;
+
+ ASSERTMSG(pSubIndexEntry_p != NULL,
+ "EplObdGetObjectDefaultPtr(): pointer to SubEntry not valid!\n");
+
+ // get address to default data from default pointer
+ pDefault = pSubIndexEntry_p->m_pDefault;
+ if (pDefault != NULL) {
+ // there are some special types, whose default pointer always is NULL or has to get from other structure
+ // get type from subindex structure
+ Type = pSubIndexEntry_p->m_Type;
+
+ // check if object type is a string value
+ if ((Type == kEplObdTypVString) /* ||
+ (Type == kEplObdTypUString) */ ) {
+
+ // EPL_OBD_SUBINDEX_RAM_VSTRING
+ // tEplObdSize m_Size; --> size of default string
+ // char * m_pDefString; --> pointer to default string
+ // char * m_pString; --> pointer to string in RAM
+ //
+ pDefault =
+ (void *)((tEplObdVString *) pDefault)->m_pString;
+ } else if (Type == kEplObdTypOString) {
+ pDefault =
+ (void *)((tEplObdOString *) pDefault)->m_pString;
+ }
+ }
+
+ return pDefault;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetVarEntry()
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdGetVarEntry (
- tEplObdSubEntryPtr pSubindexEntry_p,
- tEplObdVarEntry MEM** ppVarEntry_p)
+static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
+ tEplObdVarEntry MEM ** ppVarEntry_p)
{
-tEplKernel Ret = kEplObdVarEntryNotExist;
+ tEplKernel Ret = kEplObdVarEntryNotExist;
- ASSERT (ppVarEntry_p != NULL); // is not allowed to be NULL
- ASSERT (pSubindexEntry_p != NULL);
+ ASSERT(ppVarEntry_p != NULL); // is not allowed to be NULL
+ ASSERT(pSubindexEntry_p != NULL);
- // check VAR-Flag - only this object points to variables
- if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0)
- {
- // check if object is an array
- if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0)
- {
- *ppVarEntry_p = &((tEplObdVarEntry MEM*) pSubindexEntry_p->m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
- }
- else
- {
- *ppVarEntry_p = (tEplObdVarEntry MEM*) pSubindexEntry_p->m_pCurrent;
- }
+ // check VAR-Flag - only this object points to variables
+ if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0) {
+ // check if object is an array
+ if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0) {
+ *ppVarEntry_p =
+ &((tEplObdVarEntry MEM *) pSubindexEntry_p->
+ m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
+ } else {
+ *ppVarEntry_p =
+ (tEplObdVarEntry MEM *) pSubindexEntry_p->
+ m_pCurrent;
+ }
- Ret = kEplSuccessful;
- }
+ Ret = kEplSuccessful;
+ }
- return Ret;
+ return Ret;
}
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdGetEntry (EPL_MCO_DECL_INSTANCE_PTR_
- unsigned int uiIndex_p,
- unsigned int uiSubindex_p,
- tEplObdEntryPtr* ppObdEntry_p,
- tEplObdSubEntryPtr* ppObdSubEntry_p)
+static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
+ unsigned int uiIndex_p,
+ unsigned int uiSubindex_p,
+ tEplObdEntryPtr * ppObdEntry_p,
+ tEplObdSubEntryPtr * ppObdSubEntry_p)
{
-tEplObdEntryPtr pObdEntry;
-tEplObdCbParam MEM CbParam;
-tEplKernel Ret;
-
- // check for all API function if instance is valid
- EPL_MCO_CHECK_INSTANCE_STATE ();
-
- //------------------------------------------------------------------------
- // get address of entry of index
- Ret = EplObdGetIndexIntern (&EPL_MCO_GLB_VAR (m_ObdInitParam), uiIndex_p, &pObdEntry);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // get address of entry of subindex
- Ret = EplObdGetSubindexIntern (pObdEntry, uiSubindex_p, ppObdSubEntry_p);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // call callback function to inform user/stack that an object will be searched
- // if the called module returnes an error then we abort the searching with kEplObdIndexNotExist
- CbParam.m_uiIndex = uiIndex_p;
- CbParam.m_uiSubIndex = uiSubindex_p;
- CbParam.m_pArg = NULL;
- CbParam.m_ObdEvent = kEplObdEvCheckExist;
- Ret = EplObdCallObjectCallback (EPL_MCO_INSTANCE_PTR_
- pObdEntry->m_fpCallback, &CbParam);
- if (Ret != kEplSuccessful)
- {
- Ret = kEplObdIndexNotExist;
- goto Exit;
- }
-
- //------------------------------------------------------------------------
- // it is allowed to set ppObdEntry_p to NULL
- // if so, no address will be written to calling function
- if (ppObdEntry_p != NULL)
- {
- *ppObdEntry_p = pObdEntry;
- }
-
-Exit:
-
- return Ret;
+ tEplObdEntryPtr pObdEntry;
+ tEplObdCbParam MEM CbParam;
+ tEplKernel Ret;
+
+ // check for all API function if instance is valid
+ EPL_MCO_CHECK_INSTANCE_STATE();
+
+ //------------------------------------------------------------------------
+ // get address of entry of index
+ Ret =
+ EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam), uiIndex_p,
+ &pObdEntry);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // get address of entry of subindex
+ Ret = EplObdGetSubindexIntern(pObdEntry, uiSubindex_p, ppObdSubEntry_p);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // call callback function to inform user/stack that an object will be searched
+ // if the called module returnes an error then we abort the searching with kEplObdIndexNotExist
+ CbParam.m_uiIndex = uiIndex_p;
+ CbParam.m_uiSubIndex = uiSubindex_p;
+ CbParam.m_pArg = NULL;
+ CbParam.m_ObdEvent = kEplObdEvCheckExist;
+ Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
+ pObdEntry->m_fpCallback, &CbParam);
+ if (Ret != kEplSuccessful) {
+ Ret = kEplObdIndexNotExist;
+ goto Exit;
+ }
+ //------------------------------------------------------------------------
+ // it is allowed to set ppObdEntry_p to NULL
+ // if so, no address will be written to calling function
+ if (ppObdEntry_p != NULL) {
+ *ppObdEntry_p = pObdEntry;
+ }
+
+ Exit:
+
+ return Ret;
}
+
//---------------------------------------------------------------------------
//
// Function: EplObdGetObjectCurrentPtr()
//
//---------------------------------------------------------------------------
-static void MEM* EplObdGetObjectCurrentPtr (tEplObdSubEntryPtr pSubIndexEntry_p)
+static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
{
-void MEM* pData;
-unsigned int uiArrayIndex;
-tEplObdSize Size;
-
- pData = pSubIndexEntry_p->m_pCurrent;
-
- // check if constant object
- if (pData != NULL)
- {
- // check if object is an array
- if ((pSubIndexEntry_p->m_Access & kEplObdAccArray) != 0)
- {
- // calculate correct data pointer
- uiArrayIndex = pSubIndexEntry_p->m_uiSubIndex - 1;
- if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0)
- {
- Size = sizeof (tEplObdVarEntry);
- }
- else
- {
- Size = EplObdGetObjectSize (pSubIndexEntry_p);
- }
- pData = ((BYTE MEM*) pData) + (Size * uiArrayIndex);
- }
-
- // check if VarEntry
- if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0)
- {
- // The data pointer is stored in VarEntry->pData
- pData = ((tEplObdVarEntry MEM*) pData)->m_pData;
- }
-
- // the default pointer is stored for strings in tEplObdVString
- else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString) /* ||
- (pSubIndexEntry_p->m_Type == kEplObdTypUString) */ )
- {
- pData = (void MEM*) ((tEplObdVString MEM*) pData)->m_pString;
- }
- else if (pSubIndexEntry_p->m_Type == kEplObdTypOString)
- {
- pData = (void MEM*) ((tEplObdOString MEM*) pData)->m_pString;
- }
- }
-
- return pData;
+ void MEM *pData;
+ unsigned int uiArrayIndex;
+ tEplObdSize Size;
+
+ pData = pSubIndexEntry_p->m_pCurrent;
+
+ // check if constant object
+ if (pData != NULL) {
+ // check if object is an array
+ if ((pSubIndexEntry_p->m_Access & kEplObdAccArray) != 0) {
+ // calculate correct data pointer
+ uiArrayIndex = pSubIndexEntry_p->m_uiSubIndex - 1;
+ if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
+ Size = sizeof(tEplObdVarEntry);
+ } else {
+ Size = EplObdGetObjectSize(pSubIndexEntry_p);
+ }
+ pData = ((BYTE MEM *) pData) + (Size * uiArrayIndex);
+ }
+ // check if VarEntry
+ if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
+ // The data pointer is stored in VarEntry->pData
+ pData = ((tEplObdVarEntry MEM *) pData)->m_pData;
+ }
+ // the default pointer is stored for strings in tEplObdVString
+ else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString) /* ||
+ (pSubIndexEntry_p->m_Type == kEplObdTypUString) */
+ ) {
+ pData =
+ (void MEM *)((tEplObdVString MEM *) pData)->
+ m_pString;
+ } else if (pSubIndexEntry_p->m_Type == kEplObdTypOString) {
+ pData =
+ (void MEM *)((tEplObdOString MEM *) pData)->
+ m_pString;
+ }
+ }
+
+ return pData;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetIndexIntern()
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdGetIndexIntern (
- tEplObdInitParam MEM* pInitParam_p,
- unsigned int uiIndex_p,
- tEplObdEntryPtr* ppObdEntry_p)
+static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p,
+ unsigned int uiIndex_p,
+ tEplObdEntryPtr * ppObdEntry_p)
{
-tEplObdEntryPtr pObdEntry;
-tEplKernel Ret;
-unsigned int uiIndex;
+ tEplObdEntryPtr pObdEntry;
+ tEplKernel Ret;
+ unsigned int uiIndex;
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
-unsigned int nLoop;
+ unsigned int nLoop;
- // if user OD is used then objekts also has to be searched in user OD
- // there is less code need if we do this in a loop
- nLoop = 2;
+ // if user OD is used then objekts also has to be searched in user OD
+ // there is less code need if we do this in a loop
+ nLoop = 2;
#endif
- ASSERTMSG (ppObdEntry_p != NULL, "EplObdGetIndexIntern(): pointer to index entry is NULL!\n");
-
- Ret = kEplObdIndexNotExist;
-
- // get start address of OD part
- // start address depends on object index because
- // object dictionary is divided in 3 parts
- if ((uiIndex_p >= 0x1000) && (uiIndex_p < 0x2000))
- {
- pObdEntry = pInitParam_p->m_pPart;
- }
- else if ((uiIndex_p >= 0x2000) && (uiIndex_p < 0x6000))
- {
- pObdEntry = pInitParam_p->m_pManufacturerPart;
- }
-
- // index range 0xA000 to 0xFFFF is reserved for DSP-405
- // DS-301 defines that range 0x6000 to 0x9FFF (!!!) is stored if "store" was written to 0x1010/3.
- // Therefore default configuration is OBD_INCLUDE_A000_TO_DEVICE_PART = FALSE.
- // But a CANopen Application which does not implement dynamic OD or user-OD but wants to use static objets 0xA000...
- // should set OBD_INCLUDE_A000_TO_DEVICE_PART to TRUE.
+ ASSERTMSG(ppObdEntry_p != NULL,
+ "EplObdGetIndexIntern(): pointer to index entry is NULL!\n");
+
+ Ret = kEplObdIndexNotExist;
+
+ // get start address of OD part
+ // start address depends on object index because
+ // object dictionary is divided in 3 parts
+ if ((uiIndex_p >= 0x1000) && (uiIndex_p < 0x2000)) {
+ pObdEntry = pInitParam_p->m_pPart;
+ } else if ((uiIndex_p >= 0x2000) && (uiIndex_p < 0x6000)) {
+ pObdEntry = pInitParam_p->m_pManufacturerPart;
+ }
+ // index range 0xA000 to 0xFFFF is reserved for DSP-405
+ // DS-301 defines that range 0x6000 to 0x9FFF (!!!) is stored if "store" was written to 0x1010/3.
+ // Therefore default configuration is OBD_INCLUDE_A000_TO_DEVICE_PART = FALSE.
+ // But a CANopen Application which does not implement dynamic OD or user-OD but wants to use static objets 0xA000...
+ // should set OBD_INCLUDE_A000_TO_DEVICE_PART to TRUE.
#if (EPL_OBD_INCLUDE_A000_TO_DEVICE_PART == FALSE)
- else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0x9FFF))
+ else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0x9FFF))
#else
- else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0xFFFF))
+ else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0xFFFF))
#endif
- {
- pObdEntry = pInitParam_p->m_pDevicePart;
- }
-
+ {
+ pObdEntry = pInitParam_p->m_pDevicePart;
+ }
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
- // if index does not match in static OD then index only has to be searched in user OD
- else
- {
- // begin from first entry of user OD part
- pObdEntry = pInitParam_p->m_pUserPart;
-
- // no user OD is available
- if (pObdEntry == NULL)
- {
- goto Exit;
- }
+ // if index does not match in static OD then index only has to be searched in user OD
+ else {
+ // begin from first entry of user OD part
+ pObdEntry = pInitParam_p->m_pUserPart;
- // loop must only run once
- nLoop = 1;
- }
+ // no user OD is available
+ if (pObdEntry == NULL) {
+ goto Exit;
+ }
+ // loop must only run once
+ nLoop = 1;
+ }
- do
- {
+ do {
#else
- // no user OD is available
- // so other object can be found in OD
- else
- {
- Ret = kEplObdIllegalPart;
- goto Exit;
- }
+ // no user OD is available
+ // so other object can be found in OD
+ else {
+ Ret = kEplObdIllegalPart;
+ goto Exit;
+ }
#endif
- // note:
- // The end of Index table is marked with m_uiIndex = 0xFFFF.
- // If this function will be called with wIndex_p = 0xFFFF, entry
- // should not be found. Therefor it is important to use
- // while{} instead of do{}while !!!
-
- // get first index of index table
- uiIndex = pObdEntry->m_uiIndex;
-
- // search Index in OD part
- while (uiIndex != EPL_OBD_TABLE_INDEX_END)
- {
- // go to the end of this function if index is found
- if (uiIndex_p == uiIndex)
- {
- // write address of OD entry to calling function
- *ppObdEntry_p = pObdEntry;
- Ret = kEplSuccessful;
- goto Exit;
- }
-
- // objects are sorted in OD
- // if the current index in OD is greater than the index which is to search then break loop
- // in this case user OD has to be search too
- if (uiIndex_p < uiIndex)
- {
- break;
- }
-
- // next entry in index table
- pObdEntry++;
-
- // get next index of index table
- uiIndex = pObdEntry->m_uiIndex;
- }
+ // note:
+ // The end of Index table is marked with m_uiIndex = 0xFFFF.
+ // If this function will be called with wIndex_p = 0xFFFF, entry
+ // should not be found. Therefor it is important to use
+ // while{} instead of do{}while !!!
+
+ // get first index of index table
+ uiIndex = pObdEntry->m_uiIndex;
+
+ // search Index in OD part
+ while (uiIndex != EPL_OBD_TABLE_INDEX_END) {
+ // go to the end of this function if index is found
+ if (uiIndex_p == uiIndex) {
+ // write address of OD entry to calling function
+ *ppObdEntry_p = pObdEntry;
+ Ret = kEplSuccessful;
+ goto Exit;
+ }
+ // objects are sorted in OD
+ // if the current index in OD is greater than the index which is to search then break loop
+ // in this case user OD has to be search too
+ if (uiIndex_p < uiIndex) {
+ break;
+ }
+ // next entry in index table
+ pObdEntry++;
+
+ // get next index of index table
+ uiIndex = pObdEntry->m_uiIndex;
+ }
#if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
- // begin from first entry of user OD part
- pObdEntry = pInitParam_p->m_pUserPart;
+ // begin from first entry of user OD part
+ pObdEntry = pInitParam_p->m_pUserPart;
- // no user OD is available
- if (pObdEntry == NULL)
- {
- goto Exit;
- }
+ // no user OD is available
+ if (pObdEntry == NULL) {
+ goto Exit;
+ }
+ // switch next loop for user OD
+ nLoop--;
- // switch next loop for user OD
- nLoop--;
+}
- } while (nLoop > 0);
+while (nLoop > 0) ;
#endif
Exit:
- return Ret;
+return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdGetSubindexIntern()
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdGetSubindexIntern (
- tEplObdEntryPtr pObdEntry_p,
- unsigned int uiSubIndex_p,
- tEplObdSubEntryPtr* ppObdSubEntry_p)
+static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
+ unsigned int uiSubIndex_p,
+ tEplObdSubEntryPtr * ppObdSubEntry_p)
{
-tEplObdSubEntryPtr pSubEntry;
-unsigned int nSubIndexCount;
-tEplKernel Ret;
-
- ASSERTMSG (pObdEntry_p != NULL, "EplObdGetSubindexIntern(): pointer to index is NULL!\n");
- ASSERTMSG (ppObdSubEntry_p != NULL, "EplObdGetSubindexIntern(): pointer to subindex is NULL!\n");
-
- Ret = kEplObdSubindexNotExist;
-
- // get start address of subindex table and count of subindices
- pSubEntry = pObdEntry_p->m_pSubIndex;
- nSubIndexCount = pObdEntry_p->m_uiCount;
- ASSERTMSG ((pSubEntry != NULL) && (nSubIndexCount > 0),
- "ObdGetSubindexIntern(): invalid subindex table within index table!\n"); // should never be NULL
-
- // search subindex in subindex table
- while (nSubIndexCount > 0)
- {
- // check if array is found
- if ((pSubEntry->m_Access & kEplObdAccArray) != 0)
- {
- // check if subindex is in range
- if (uiSubIndex_p < pObdEntry_p->m_uiCount)
- {
- // update subindex number (subindex entry of an array is always in RAM !!!)
- pSubEntry->m_uiSubIndex = uiSubIndex_p;
- *ppObdSubEntry_p = pSubEntry;
- Ret = kEplSuccessful;
- goto Exit;
- }
- }
-
- // go to the end of this function if subindex is found
- else if (uiSubIndex_p == pSubEntry->m_uiSubIndex)
- {
- *ppObdSubEntry_p = pSubEntry;
- Ret = kEplSuccessful;
- goto Exit;
- }
-
- // objects are sorted in OD
- // if the current subindex in OD is greater than the subindex which is to search then break loop
- // in this case user OD has to be search too
- if (uiSubIndex_p < pSubEntry->m_uiSubIndex)
- {
- break;
- }
-
- pSubEntry++;
- nSubIndexCount--;
- }
-
- // in this line SubIndex was not fount
-
-Exit:
-
- return Ret;
+ tEplObdSubEntryPtr pSubEntry;
+ unsigned int nSubIndexCount;
+ tEplKernel Ret;
+
+ ASSERTMSG(pObdEntry_p != NULL,
+ "EplObdGetSubindexIntern(): pointer to index is NULL!\n");
+ ASSERTMSG(ppObdSubEntry_p != NULL,
+ "EplObdGetSubindexIntern(): pointer to subindex is NULL!\n");
+
+ Ret = kEplObdSubindexNotExist;
+
+ // get start address of subindex table and count of subindices
+ pSubEntry = pObdEntry_p->m_pSubIndex;
+ nSubIndexCount = pObdEntry_p->m_uiCount;
+ ASSERTMSG((pSubEntry != NULL) && (nSubIndexCount > 0), "ObdGetSubindexIntern(): invalid subindex table within index table!\n"); // should never be NULL
+
+ // search subindex in subindex table
+ while (nSubIndexCount > 0) {
+ // check if array is found
+ if ((pSubEntry->m_Access & kEplObdAccArray) != 0) {
+ // check if subindex is in range
+ if (uiSubIndex_p < pObdEntry_p->m_uiCount) {
+ // update subindex number (subindex entry of an array is always in RAM !!!)
+ pSubEntry->m_uiSubIndex = uiSubIndex_p;
+ *ppObdSubEntry_p = pSubEntry;
+ Ret = kEplSuccessful;
+ goto Exit;
+ }
+ }
+ // go to the end of this function if subindex is found
+ else if (uiSubIndex_p == pSubEntry->m_uiSubIndex) {
+ *ppObdSubEntry_p = pSubEntry;
+ Ret = kEplSuccessful;
+ goto Exit;
+ }
+ // objects are sorted in OD
+ // if the current subindex in OD is greater than the subindex which is to search then break loop
+ // in this case user OD has to be search too
+ if (uiSubIndex_p < pSubEntry->m_uiSubIndex) {
+ break;
+ }
+
+ pSubEntry++;
+ nSubIndexCount--;
+ }
+
+ // in this line SubIndex was not fount
+
+ Exit:
+
+ return Ret;
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdSetStoreLoadObjCallback()
//
//---------------------------------------------------------------------------
#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
-EPLDLLEXPORT tEplKernel PUBLIC EplObdSetStoreLoadObjCallback (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdStoreLoadObjCallback fpCallback_p)
+EPLDLLEXPORT tEplKernel PUBLIC
+EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdStoreLoadObjCallback fpCallback_p)
{
- EPL_MCO_CHECK_INSTANCE_STATE ();
+ EPL_MCO_CHECK_INSTANCE_STATE();
- // set new address of callback function
- EPL_MCO_GLB_VAR (m_fpStoreLoadObjCallback) = fpCallback_p;
+ // set new address of callback function
+ EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = fpCallback_p;
- return kEplSuccessful;
+ return kEplSuccessful;
}
#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
-
//---------------------------------------------------------------------------
//
// Function: EplObdAccessOdPartIntern()
//
//---------------------------------------------------------------------------
-static tEplKernel EplObdAccessOdPartIntern (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdPart CurrentOdPart_p,
- tEplObdEntryPtr pObdEnty_p,
- tEplObdDir Direction_p)
+static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdPart CurrentOdPart_p,
+ tEplObdEntryPtr pObdEnty_p,
+ tEplObdDir Direction_p)
{
-tEplObdSubEntryPtr pSubIndex;
-unsigned int nSubIndexCount;
-tEplObdAccess Access;
-void MEM* pDstData;
-void * pDefault;
-tEplObdSize ObjSize;
-tEplKernel Ret;
-tEplObdCbStoreParam MEM CbStore;
-tEplObdVarEntry MEM* pVarEntry;
-
- ASSERT (pObdEnty_p != NULL);
-
- Ret = kEplSuccessful;
+ tEplObdSubEntryPtr pSubIndex;
+ unsigned int nSubIndexCount;
+ tEplObdAccess Access;
+ void MEM *pDstData;
+ void *pDefault;
+ tEplObdSize ObjSize;
+ tEplKernel Ret;
+ tEplObdCbStoreParam MEM CbStore;
+ tEplObdVarEntry MEM *pVarEntry;
- // prepare structure for STORE RESTORE callback function
- CbStore.m_bCurrentOdPart = (BYTE) CurrentOdPart_p;
- CbStore.m_pData = NULL;
- CbStore.m_ObjSize = 0;
+ ASSERT(pObdEnty_p != NULL);
- // command of first action depends on direction to access
- #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
- if (Direction_p == kEplObdDirLoad)
- {
- CbStore.m_bCommand = (BYTE) kEplObdCommOpenRead;
+ Ret = kEplSuccessful;
- // call callback function for previous command
- Ret = EplObdCallStoreCallback (EPL_MCO_INSTANCE_PTR_
- &CbStore);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
+ // prepare structure for STORE RESTORE callback function
+ CbStore.m_bCurrentOdPart = (BYTE) CurrentOdPart_p;
+ CbStore.m_pData = NULL;
+ CbStore.m_ObjSize = 0;
- // set command for index and subindex loop
- CbStore.m_bCommand = (BYTE) kEplObdCommReadObj;
- }
- else if (Direction_p == kEplObdDirStore)
- {
- CbStore.m_bCommand = (BYTE) kEplObdCommOpenWrite;
-
- // call callback function for previous command
- Ret = EplObdCallStoreCallback (EPL_MCO_INSTANCE_PTR_
- &CbStore);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
-
- // set command for index and subindex loop
- CbStore.m_bCommand = (BYTE) kEplObdCommWriteObj;
- }
- #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ // command of first action depends on direction to access
+#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ if (Direction_p == kEplObdDirLoad) {
+ CbStore.m_bCommand = (BYTE) kEplObdCommOpenRead;
+
+ // call callback function for previous command
+ Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // set command for index and subindex loop
+ CbStore.m_bCommand = (BYTE) kEplObdCommReadObj;
+ } else if (Direction_p == kEplObdDirStore) {
+ CbStore.m_bCommand = (BYTE) kEplObdCommOpenWrite;
+
+ // call callback function for previous command
+ Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ // set command for index and subindex loop
+ CbStore.m_bCommand = (BYTE) kEplObdCommWriteObj;
+ }
+#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
- // we should not restore the OD values here
- // the next NMT command "Reset Node" or "Reset Communication" resets the OD data
- if (Direction_p != kEplObdDirRestore)
- {
- // walk through OD part till end is found
- while (pObdEnty_p->m_uiIndex != EPL_OBD_TABLE_INDEX_END)
- {
- // get address to subindex table and count of subindices
- pSubIndex = pObdEnty_p->m_pSubIndex;
- nSubIndexCount = pObdEnty_p->m_uiCount;
- ASSERT ((pSubIndex != NULL) && (nSubIndexCount > 0)); // should never be NULL
-
- // walk through subindex table till all subinices were restored
- while (nSubIndexCount != 0)
- {
- Access = (tEplObdAccess) pSubIndex->m_Access;
-
- // get pointer to current and default data
- pDefault = EplObdGetObjectDefaultPtr (pSubIndex);
- pDstData = EplObdGetObjectCurrentPtr (pSubIndex);
-
- // NOTE (for kEplObdTypVString):
- // The function returnes the max. number of bytes for a
- // current string.
- // r.d.: For stings the default-size will be read in other lines following (kEplObdDirInit).
- ObjSize = EplObdGetObjectSize (pSubIndex);
-
- // switch direction of OD access
- switch (Direction_p)
- {
- // --------------------------------------------------------------------------
- // VarEntry structures has to be initialized
- case kEplObdDirInit:
-
- // If VAR-Flag is set, m_pCurrent means not address of data
- // but address of tEplObdVarEntry. Address of data has to be get from
- // this structure.
- if ((Access & kEplObdAccVar) != 0)
- {
- EplObdGetVarEntry (pSubIndex, &pVarEntry);
- EplObdInitVarEntry (pVarEntry, pSubIndex->m_Type, ObjSize);
+ // we should not restore the OD values here
+ // the next NMT command "Reset Node" or "Reset Communication" resets the OD data
+ if (Direction_p != kEplObdDirRestore) {
+ // walk through OD part till end is found
+ while (pObdEnty_p->m_uiIndex != EPL_OBD_TABLE_INDEX_END) {
+ // get address to subindex table and count of subindices
+ pSubIndex = pObdEnty_p->m_pSubIndex;
+ nSubIndexCount = pObdEnty_p->m_uiCount;
+ ASSERT((pSubIndex != NULL) && (nSubIndexCount > 0)); // should never be NULL
+
+ // walk through subindex table till all subinices were restored
+ while (nSubIndexCount != 0) {
+ Access = (tEplObdAccess) pSubIndex->m_Access;
+
+ // get pointer to current and default data
+ pDefault = EplObdGetObjectDefaultPtr(pSubIndex);
+ pDstData = EplObdGetObjectCurrentPtr(pSubIndex);
+
+ // NOTE (for kEplObdTypVString):
+ // The function returnes the max. number of bytes for a
+ // current string.
+ // r.d.: For stings the default-size will be read in other lines following (kEplObdDirInit).
+ ObjSize = EplObdGetObjectSize(pSubIndex);
+
+ // switch direction of OD access
+ switch (Direction_p) {
+ // --------------------------------------------------------------------------
+ // VarEntry structures has to be initialized
+ case kEplObdDirInit:
+
+ // If VAR-Flag is set, m_pCurrent means not address of data
+ // but address of tEplObdVarEntry. Address of data has to be get from
+ // this structure.
+ if ((Access & kEplObdAccVar) != 0) {
+ EplObdGetVarEntry(pSubIndex,
+ &pVarEntry);
+ EplObdInitVarEntry(pVarEntry,
+ pSubIndex->
+ m_Type,
+ ObjSize);
/*
if ((Access & kEplObdAccArray) == 0)
{
pSubIndex->m_Type, ObjSize);
}
*/
- // at this time no application variable is defined !!!
- // therefore data can not be copied.
- break;
- }
- else if (pSubIndex->m_Type == kEplObdTypVString)
- {
- // If pointer m_pCurrent is not equal to NULL then the
- // string was defined with EPL_OBD_SUBINDEX_RAM_VSTRING. The current
- // pointer points to struct tEplObdVString located in MEM.
- // The element size includes the max. number of
- // bytes. The element m_pString includes the pointer
- // to string in MEM. The memory location of default string
- // must be copied to memory location of current string.
-
- pDstData = pSubIndex->m_pCurrent;
- if (pDstData != NULL)
- {
- // 08-dec-2004: code optimization !!!
- // entries ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_pString
- // and ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
- // twice. thats not necessary!
-
- // For copying data we have to set the destination pointer to the real RAM string. This
- // pointer to RAM string is located in default string info structure. (translated r.d.)
- pDstData = (void MEM*) ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_pString;
- ObjSize = ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_Size;
-
-
- ((tEplObdVString MEM*) pSubIndex->m_pCurrent)->m_pString = pDstData;
- ((tEplObdVString MEM*) pSubIndex->m_pCurrent)->m_Size = ObjSize;
- }
-
- }
- else if(pSubIndex->m_Type == kEplObdTypOString)
- {
- pDstData = pSubIndex->m_pCurrent;
- if (pDstData != NULL)
- {
- // 08-dec-2004: code optimization !!!
- // entries ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_pString
- // and ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
- // twice. thats not necessary!
-
- // For copying data we have to set the destination pointer to the real RAM string. This
- // pointer to RAM string is located in default string info structure. (translated r.d.)
- pDstData = (void MEM*) ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_pString;
- ObjSize = ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_Size;
-
-
- ((tEplObdOString MEM*) pSubIndex->m_pCurrent)->m_pString = pDstData;
- ((tEplObdOString MEM*) pSubIndex->m_pCurrent)->m_Size = ObjSize;
- }
-
- }
-
-
- // no break !! because copy of data has to done too.
-
- // --------------------------------------------------------------------------
- // all objects has to be restored with default values
- case kEplObdDirRestore:
-
- // 09-dec-2004 r.d.: optimization! the same code for kEplObdDirRestore and kEplObdDirLoad
- // is replaced to function ObdCopyObjectData() with a new parameter.
-
-
- // restore object data for init phase
- EplObdCopyObjectData (pDstData, pDefault, ObjSize, pSubIndex->m_Type);
- break;
-
- // --------------------------------------------------------------------------
- // objects with attribute kEplObdAccStore has to be load from EEPROM or from a file
- case kEplObdDirLoad:
-
- // restore object data for init phase
- EplObdCopyObjectData (pDstData, pDefault, ObjSize, pSubIndex->m_Type);
-
- // no break !! because callback function has to be called too.
-
- // --------------------------------------------------------------------------
- // objects with attribute kEplObdAccStore has to be stored in EEPROM or in a file
- case kEplObdDirStore:
-
- // when attribute kEplObdAccStore is set, then call callback function
- #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
- if ((Access & kEplObdAccStore) != 0)
- {
- // fill out data pointer and size of data
- CbStore.m_pData = pDstData;
- CbStore.m_ObjSize = ObjSize;
-
- // call callback function for read or write object
- Ret = ObdCallStoreCallback (EPL_MCO_INSTANCE_PTR_
- &CbStore);
- if (Ret != kEplSuccessful)
- {
- goto Exit;
- }
- }
- #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
- break;
-
-
- // --------------------------------------------------------------------------
- // if OD Builder key has to be checked no access to subindex and data should be made
- case kEplObdDirOBKCheck:
-
- // no break !! because we want to break the second loop too.
-
-
- // --------------------------------------------------------------------------
- // unknown Direction
- default:
-
- // so we can break the second loop earler
- nSubIndexCount = 1;
- break;
- }
-
- nSubIndexCount--;
-
- // next subindex entry
- if ((Access & kEplObdAccArray) == 0)
- {
- pSubIndex++;
- if ((nSubIndexCount > 0)
- && ((pSubIndex->m_Access & kEplObdAccArray) != 0))
- {
- // next subindex points to an array
- // reset subindex number
- pSubIndex->m_uiSubIndex = 1;
- }
- }
- else
- {
- if (nSubIndexCount > 0)
- {
- // next subindex points to an array
- // increment subindex number
- pSubIndex->m_uiSubIndex++;
- }
- }
- }
-
- // next index entry
- pObdEnty_p++;
- }
- }
-
- // -----------------------------------------------------------------------------------------
- // command of last action depends on direction to access
- if (Direction_p == kEplObdDirOBKCheck)
- {
-
- goto Exit;
- }
- #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
- else
- {
- if (Direction_p == kEplObdDirLoad)
- {
- CbStore.m_bCommand = (BYTE) kEplObdCommCloseRead;
- }
- else if (Direction_p == kEplObdDirStore)
- {
- CbStore.m_bCommand = (BYTE) kEplObdCommCloseWrite;
- }
- else if (Direction_p == kEplObdDirRestore)
- {
- CbStore.m_bCommand = (BYTE) kEplObdCommClear;
- }
- else
- {
- goto Exit;
- }
-
- // call callback function for last command
- Ret = EplObdCallStoreCallback (EPL_MCO_INSTANCE_PTR_
- &CbStore);
- }
- #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ // at this time no application variable is defined !!!
+ // therefore data can not be copied.
+ break;
+ } else if (pSubIndex->m_Type ==
+ kEplObdTypVString) {
+ // If pointer m_pCurrent is not equal to NULL then the
+ // string was defined with EPL_OBD_SUBINDEX_RAM_VSTRING. The current
+ // pointer points to struct tEplObdVString located in MEM.
+ // The element size includes the max. number of
+ // bytes. The element m_pString includes the pointer
+ // to string in MEM. The memory location of default string
+ // must be copied to memory location of current string.
+
+ pDstData =
+ pSubIndex->m_pCurrent;
+ if (pDstData != NULL) {
+ // 08-dec-2004: code optimization !!!
+ // entries ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_pString
+ // and ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
+ // twice. thats not necessary!
+
+ // For copying data we have to set the destination pointer to the real RAM string. This
+ // pointer to RAM string is located in default string info structure. (translated r.d.)
+ pDstData =
+ (void MEM
+ *)((tEplObdVStringDef ROM *) pSubIndex->m_pDefault)->m_pString;
+ ObjSize =
+ ((tEplObdVStringDef
+ ROM *) pSubIndex->
+ m_pDefault)->
+ m_Size;
+
+ ((tEplObdVString MEM *)
+ pSubIndex->
+ m_pCurrent)->
+ m_pString = pDstData;
+ ((tEplObdVString MEM *)
+ pSubIndex->
+ m_pCurrent)->m_Size =
+ ObjSize;
+ }
+
+ } else if (pSubIndex->m_Type ==
+ kEplObdTypOString) {
+ pDstData =
+ pSubIndex->m_pCurrent;
+ if (pDstData != NULL) {
+ // 08-dec-2004: code optimization !!!
+ // entries ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_pString
+ // and ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
+ // twice. thats not necessary!
+
+ // For copying data we have to set the destination pointer to the real RAM string. This
+ // pointer to RAM string is located in default string info structure. (translated r.d.)
+ pDstData =
+ (void MEM
+ *)((tEplObdOStringDef ROM *) pSubIndex->m_pDefault)->m_pString;
+ ObjSize =
+ ((tEplObdOStringDef
+ ROM *) pSubIndex->
+ m_pDefault)->
+ m_Size;
+
+ ((tEplObdOString MEM *)
+ pSubIndex->
+ m_pCurrent)->
+ m_pString = pDstData;
+ ((tEplObdOString MEM *)
+ pSubIndex->
+ m_pCurrent)->m_Size =
+ ObjSize;
+ }
+
+ }
+
+ // no break !! because copy of data has to done too.
+
+ // --------------------------------------------------------------------------
+ // all objects has to be restored with default values
+ case kEplObdDirRestore:
+
+ // 09-dec-2004 r.d.: optimization! the same code for kEplObdDirRestore and kEplObdDirLoad
+ // is replaced to function ObdCopyObjectData() with a new parameter.
+
+ // restore object data for init phase
+ EplObdCopyObjectData(pDstData, pDefault,
+ ObjSize,
+ pSubIndex->m_Type);
+ break;
+
+ // --------------------------------------------------------------------------
+ // objects with attribute kEplObdAccStore has to be load from EEPROM or from a file
+ case kEplObdDirLoad:
+
+ // restore object data for init phase
+ EplObdCopyObjectData(pDstData, pDefault,
+ ObjSize,
+ pSubIndex->m_Type);
+
+ // no break !! because callback function has to be called too.
+
+ // --------------------------------------------------------------------------
+ // objects with attribute kEplObdAccStore has to be stored in EEPROM or in a file
+ case kEplObdDirStore:
+
+ // when attribute kEplObdAccStore is set, then call callback function
+#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ if ((Access & kEplObdAccStore) != 0) {
+ // fill out data pointer and size of data
+ CbStore.m_pData = pDstData;
+ CbStore.m_ObjSize = ObjSize;
+
+ // call callback function for read or write object
+ Ret =
+ ObdCallStoreCallback
+ (EPL_MCO_INSTANCE_PTR_ &
+ CbStore);
+ if (Ret != kEplSuccessful) {
+ goto Exit;
+ }
+ }
+#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ break;
+
+ // --------------------------------------------------------------------------
+ // if OD Builder key has to be checked no access to subindex and data should be made
+ case kEplObdDirOBKCheck:
+
+ // no break !! because we want to break the second loop too.
+
+ // --------------------------------------------------------------------------
+ // unknown Direction
+ default:
+
+ // so we can break the second loop earler
+ nSubIndexCount = 1;
+ break;
+ }
+
+ nSubIndexCount--;
+
+ // next subindex entry
+ if ((Access & kEplObdAccArray) == 0) {
+ pSubIndex++;
+ if ((nSubIndexCount > 0)
+ &&
+ ((pSubIndex->
+ m_Access & kEplObdAccArray) !=
+ 0)) {
+ // next subindex points to an array
+ // reset subindex number
+ pSubIndex->m_uiSubIndex = 1;
+ }
+ } else {
+ if (nSubIndexCount > 0) {
+ // next subindex points to an array
+ // increment subindex number
+ pSubIndex->m_uiSubIndex++;
+ }
+ }
+ }
+
+ // next index entry
+ pObdEnty_p++;
+ }
+ }
+ // -----------------------------------------------------------------------------------------
+ // command of last action depends on direction to access
+ if (Direction_p == kEplObdDirOBKCheck) {
+
+ goto Exit;
+ }
+#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
+ else {
+ if (Direction_p == kEplObdDirLoad) {
+ CbStore.m_bCommand = (BYTE) kEplObdCommCloseRead;
+ } else if (Direction_p == kEplObdDirStore) {
+ CbStore.m_bCommand = (BYTE) kEplObdCommCloseWrite;
+ } else if (Direction_p == kEplObdDirRestore) {
+ CbStore.m_bCommand = (BYTE) kEplObdCommClear;
+ } else {
+ goto Exit;
+ }
+
+ // call callback function for last command
+ Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
+ }
+#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
// goto Exit;
-Exit:
+ Exit:
- return Ret;
+ return Ret;
}
-
// ----------------------------------------------------------------------------
// Function: EplObdCopyObjectData()
//
// Returns: tEplKernel = error code
// ----------------------------------------------------------------------------
-static void EplObdCopyObjectData (
- void MEM* pDstData_p,
- void * pSrcData_p,
- tEplObdSize ObjSize_p,
- tEplObdType ObjType_p)
+static void EplObdCopyObjectData(void MEM * pDstData_p,
+ void *pSrcData_p,
+ tEplObdSize ObjSize_p, tEplObdType ObjType_p)
{
-
-tEplObdSize StrSize = 0;
-
-
- // it is allowed to set default and current address to NULL (nothing to copy)
- if (pDstData_p != NULL)
- {
-
- if (ObjType_p == kEplObdTypVString)
- {
- // The function calculates the really number of characters of string. The
- // object entry size can be bigger as string size of default string.
- // The '\0'-termination is included. A string with no characters has a
- // size of 1.
- StrSize = EplObdGetStrLen ((void *) pSrcData_p, ObjSize_p, kEplObdTypVString);
-
- // If the string length is greater than or equal to the entry size in OD then only copy
- // entry size - 1 and always set the '\0'-termination.
- if (StrSize >= ObjSize_p)
- {
- StrSize = ObjSize_p - 1;
- }
- }
-
- if (pSrcData_p != NULL)
- {
- // copy data
- EPL_MEMCPY (pDstData_p, pSrcData_p, ObjSize_p);
-
- if (ObjType_p == kEplObdTypVString)
- {
- ((char MEM*) pDstData_p)[StrSize] = '\0';
- }
- }
- }
+ tEplObdSize StrSize = 0;
+
+ // it is allowed to set default and current address to NULL (nothing to copy)
+ if (pDstData_p != NULL) {
+
+ if (ObjType_p == kEplObdTypVString) {
+ // The function calculates the really number of characters of string. The
+ // object entry size can be bigger as string size of default string.
+ // The '\0'-termination is included. A string with no characters has a
+ // size of 1.
+ StrSize =
+ EplObdGetStrLen((void *)pSrcData_p, ObjSize_p,
+ kEplObdTypVString);
+
+ // If the string length is greater than or equal to the entry size in OD then only copy
+ // entry size - 1 and always set the '\0'-termination.
+ if (StrSize >= ObjSize_p) {
+ StrSize = ObjSize_p - 1;
+ }
+ }
+
+ if (pSrcData_p != NULL) {
+ // copy data
+ EPL_MEMCPY(pDstData_p, pSrcData_p, ObjSize_p);
+
+ if (ObjType_p == kEplObdTypVString) {
+ ((char MEM *)pDstData_p)[StrSize] = '\0';
+ }
+ }
+ }
}
-
//---------------------------------------------------------------------------
//
// Function: EplObdIsNumericalIntern()
//
//---------------------------------------------------------------------------
static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
- BOOL* pfEntryNumerical_p)
+ BOOL * pfEntryNumerical_p)
{
-tEplKernel Ret = kEplSuccessful;
-
+ tEplKernel Ret = kEplSuccessful;
- // get Type
- if((pObdSubEntry_p->m_Type == kEplObdTypVString)
- || (pObdSubEntry_p->m_Type == kEplObdTypOString)
- || (pObdSubEntry_p->m_Type == kEplObdTypDomain))
- { // not numerical types
- *pfEntryNumerical_p = FALSE;
- }
- else
- { // numerical types
- *pfEntryNumerical_p = TRUE;
- }
+ // get Type
+ if ((pObdSubEntry_p->m_Type == kEplObdTypVString)
+ || (pObdSubEntry_p->m_Type == kEplObdTypOString)
+ || (pObdSubEntry_p->m_Type == kEplObdTypDomain)) { // not numerical types
+ *pfEntryNumerical_p = FALSE;
+ } else { // numerical types
+ *pfEntryNumerical_p = TRUE;
+ }
- return Ret;
+ return Ret;
}
-
// -------------------------------------------------------------------------
// function to classify object type (fixed/non fixed)
// -------------------------------------------------------------------------
// Returns: tEplKernel = error code
// ----------------------------------------------------------------------------
#if (EPL_OBD_USE_STORE_RESTORE != FALSE)
-static tEplKernel EplObdCallStoreCallback (EPL_MCO_DECL_INSTANCE_PTR_
- tEplObdCbStoreParam MEM* pCbStoreParam_p)
+static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
+ tEplObdCbStoreParam MEM *
+ pCbStoreParam_p)
{
-tEplKernel Ret = kEplSuccessful;
+ tEplKernel Ret = kEplSuccessful;
- ASSERT (pCbStoreParam_p != NULL);
+ ASSERT(pCbStoreParam_p != NULL);
- // check if function pointer is NULL - if so, no callback should be called
- if (EPL_MCO_GLB_VAR (m_fpStoreLoadObjCallback) != NULL)
- {
- Ret = EPL_MCO_GLB_VAR (m_fpStoreLoadObjCallback) (EPL_MCO_INSTANCE_PARAM_IDX_()
- pCbStoreParam_p);
- }
+ // check if function pointer is NULL - if so, no callback should be called
+ if (EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) != NULL) {
+ Ret =
+ EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback)
+ (EPL_MCO_INSTANCE_PARAM_IDX_()
+ pCbStoreParam_p);
+ }
- return Ret;
+ return Ret;
}
#endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
//
//---------------------------------------------------------------------------
-void * EplObdGetObjectDataPtrIntern (tEplObdSubEntryPtr pSubindexEntry_p)
+void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p)
{
-void * pData;
-tEplObdAccess Access;
+ void *pData;
+ tEplObdAccess Access;
- ASSERTMSG (pSubindexEntry_p != NULL, "EplObdGetObjectDataPtrIntern(): pointer to SubEntry not valid!\n");
+ ASSERTMSG(pSubindexEntry_p != NULL,
+ "EplObdGetObjectDataPtrIntern(): pointer to SubEntry not valid!\n");
- // there are are some objects whose data pointer has to get from other structure
- // get access type for this object
- Access = pSubindexEntry_p->m_Access;
+ // there are are some objects whose data pointer has to get from other structure
+ // get access type for this object
+ Access = pSubindexEntry_p->m_Access;
- // If object has access type = const,
- // for data only exists default values.
- if ((Access & kEplObdAccConst) != 0)
- {
- // The pointer to defualt value can be received from ObdGetObjectDefaultPtr()
- pData = ((void *) EplObdGetObjectDefaultPtr (pSubindexEntry_p));
- }
- else
- {
- // The pointer to current value can be received from ObdGetObjectCurrentPtr()
- pData = ((void *) EplObdGetObjectCurrentPtr (pSubindexEntry_p));
- }
+ // If object has access type = const,
+ // for data only exists default values.
+ if ((Access & kEplObdAccConst) != 0) {
+ // The pointer to defualt value can be received from ObdGetObjectDefaultPtr()
+ pData = ((void *)EplObdGetObjectDefaultPtr(pSubindexEntry_p));
+ } else {
+ // The pointer to current value can be received from ObdGetObjectCurrentPtr()
+ pData = ((void *)EplObdGetObjectCurrentPtr(pSubindexEntry_p));
+ }
- return pData;
+ return pData;
}
#endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
// EOF
-
projects / linux-2.6-omap-h63xx.git / blobdiff