git.oblomov.eu Git - linux-2.6/blob - drivers/staging/epl/EplObd.c

   1 /****************************************************************************
   2
   3   (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
   4       www.systec-electronic.com
   5
   6   Project:      openPOWERLINK
   7
   8   Description:  source file for api function of EplOBD-Module
   9
  10   License:
  11
  12     Redistribution and use in source and binary forms, with or without
  13     modification, are permitted provided that the following conditions
  14     are met:
  15
  16     1. Redistributions of source code must retain the above copyright
  17        notice, this list of conditions and the following disclaimer.
  18
  19     2. Redistributions in binary form must reproduce the above copyright
  20        notice, this list of conditions and the following disclaimer in the
  21        documentation and/or other materials provided with the distribution.
  22
  23     3. Neither the name of SYSTEC electronic GmbH nor the names of its
  24        contributors may be used to endorse or promote products derived
  25        from this software without prior written permission. For written
  26        permission, please contact info@systec-electronic.com.
  27
  28     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  31     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  32     COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  33     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  34     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  35     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  36     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  38     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39     POSSIBILITY OF SUCH DAMAGE.
  40
  41     Severability Clause:
  42
  43         If a provision of this License is or becomes illegal, invalid or
  44         unenforceable in any jurisdiction, that shall not affect:
  45         1. the validity or enforceability in that jurisdiction of any other
  46            provision of this License; or
  47         2. the validity or enforceability in other jurisdictions of that or
  48            any other provision of this License.
  49
  50   -------------------------------------------------------------------------
  51
  52                 $RCSfile: EplObd.c,v $
  53
  54                 $Author: D.Krueger $
  55
  56                 $Revision: 1.12 $  $Date: 2008/10/17 15:32:32 $
  57
  58                 $State: Exp $
  59
  60                 Build Environment:
  61                 Microsoft VC7
  62
  63   -------------------------------------------------------------------------
  64
  65   Revision History:
  66
  67   2006/06/02 k.t.:   start of the implementation, version 1.00
  68                      ->based on CANopen OBD-Modul
  69
  70 ****************************************************************************/
  71
  72 #include "EplInc.h"
  73 #include "kernel/EplObdk.h"     // function prototyps of the EplOBD-Modul
  74
  75 #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
  76
  77 /***************************************************************************/
  78 /*                                                                         */
  79 /*                                                                         */
  80 /*          G L O B A L   D E F I N I T I O N S                            */
  81 /*                                                                         */
  82 /*                                                                         */
  83 /***************************************************************************/
  84
  85 //---------------------------------------------------------------------------
  86 // const defines
  87 //---------------------------------------------------------------------------
  88
  89 // float definitions and macros
  90 #define _SHIFTED_EXPONENT_MASK_SP   0xff
  91 #define _BIAS_SP                    126
  92 #define T_SP                        23
  93 #define EXPONENT_DENORM_SP          (-_BIAS_SP)
  94 #define BASE_TO_THE_T_SP            ((float) 8388608.0)
  95 #define GET_EXPONENT_SP(x)          ((((x) >> T_SP) & _SHIFTED_EXPONENT_MASK_SP) - _BIAS_SP)
  96
  97 //---------------------------------------------------------------------------
  98 // local types
  99 //---------------------------------------------------------------------------
 100
 101 // struct for instance table
 102 INSTANCE_TYPE_BEGIN EPL_MCO_DECL_INSTANCE_MEMBER()
 103
 104 STATIC tEplObdInitParam INST_FAR m_ObdInitParam;
 105 STATIC tEplObdStoreLoadObjCallback INST_NEAR m_fpStoreLoadObjCallback;
 106
 107 INSTANCE_TYPE_END
 108 // decomposition of float
 109 typedef union {
 110         tEplObdReal32 m_flRealPart;
 111         int m_nIntegerPart;
 112
 113 } tEplObdRealParts;
 114
 115 //---------------------------------------------------------------------------
 116 // modul globale vars
 117 //---------------------------------------------------------------------------
 118
 119 // This macro replace the unspecific pointer to an instance through
 120 // the modul specific type for the local instance table. This macro
 121 // must defined in each modul.
 122 //#define tEplPtrInstance             tEplInstanceInfo MEM*
 123
 124 EPL_MCO_DECL_INSTANCE_VAR()
 125
 126 BYTE MEM abEplObdTrashObject_g[8];
 127
 128 //---------------------------------------------------------------------------
 129 // local function prototypes
 130 //---------------------------------------------------------------------------
 131
 132 EPL_MCO_DEFINE_INSTANCE_FCT()
 133
 134 static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
 135                                            tEplObdCallback fpCallback_p,
 136                                            tEplObdCbParam MEM * pCbParam_p);
 137
 138 static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p);
 139
 140 static tEplObdSize EplObdGetStrLen(void *pObjData_p,
 141                                    tEplObdSize ObjLen_p, tEplObdType ObjType_p);
 142
 143 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
 144 static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
 145                                          void *pData_p);
 146 #endif
 147
 148 static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
 149                                     tEplObdVarEntry MEM ** ppVarEntry_p);
 150
 151 static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
 152                                  unsigned int uiIndex_p,
 153                                  unsigned int uiSubindex_p,
 154                                  tEplObdEntryPtr * ppObdEntry_p,
 155                                  tEplObdSubEntryPtr * ppObdSubEntry_p);
 156
 157 static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p);
 158
 159 static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p,
 160                                        unsigned int uiIndex_p,
 161                                        tEplObdEntryPtr * ppObdEntry_p);
 162
 163 static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
 164                                           unsigned int uiSubIndex_p,
 165                                           tEplObdSubEntryPtr * ppObdSubEntry_p);
 166
 167 static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
 168                                            tEplObdPart CurrentOdPart_p,
 169                                            tEplObdEntryPtr pObdEnty_p,
 170                                            tEplObdDir Direction_p);
 171
 172 static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
 173 static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p);
 174
 175 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
 176
 177 static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
 178                                           tEplObdCbStoreParam MEM *
 179                                           pCbStoreParam_p);
 180
 181 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
 182
 183 static void EplObdCopyObjectData(void MEM * pDstData_p,
 184                                  void *pSrcData_p,
 185                                  tEplObdSize ObjSize_p, tEplObdType ObjType_p);
 186
 187 void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p);
 188
 189 static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
 190                                           BOOL * pfEntryNumerical_p);
 191
 192 static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
 193                                              unsigned int uiIndex_p,
 194                                              unsigned int uiSubIndex_p,
 195                                              void *pSrcData_p,
 196                                              void **ppDstData_p,
 197                                              tEplObdSize Size_p,
 198                                              tEplObdEntryPtr * ppObdEntry_p,
 199                                              tEplObdSubEntryPtr * ppSubEntry_p,
 200                                              tEplObdCbParam MEM * pCbParam_p,
 201                                              tEplObdSize * pObdSize_p);
 202
 203 static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
 204                                               tEplObdEntryPtr pObdEntry_p,
 205                                               tEplObdSubEntryPtr pSubEntry_p,
 206                                               tEplObdCbParam MEM * pCbParam_p,
 207                                               void *pSrcData_p,
 208                                               void *pDstData_p,
 209                                               tEplObdSize ObdSize_p);
 210
 211 //=========================================================================//
 212 //                                                                         //
 213 //          P U B L I C   F U N C T I O N S                                //
 214 //                                                                         //
 215 //=========================================================================//
 216
 217 //---------------------------------------------------------------------------
 218 //
 219 // Function:    EplObdInit()
 220 //
 221 // Description: initializes the first instance
 222 //
 223 // Parameters:  pInitParam_p    = init parameter
 224 //
 225 // Return:      tEplKernel      =   errorcode
 226 //
 227 // State:
 228 //
 229 //---------------------------------------------------------------------------
 230
 231 EPLDLLEXPORT tEplKernel PUBLIC EplObdInit(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 232                                           tEplObdInitParam MEM * pInitParam_p)
 233 {
 234
 235         tEplKernel Ret;
 236         EPL_MCO_DELETE_INSTANCE_TABLE();
 237
 238         if (pInitParam_p == NULL) {
 239                 Ret = kEplSuccessful;
 240                 goto Exit;
 241         }
 242
 243         Ret = EplObdAddInstance(EPL_MCO_PTR_INSTANCE_PTR_ pInitParam_p);
 244
 245       Exit:
 246         return Ret;
 247
 248 }
 249
 250 //---------------------------------------------------------------------------
 251 //
 252 // Function:    EplObdAddInstance()
 253 //
 254 // Description: adds a new instance
 255 //
 256 // Parameters:  pInitParam_p
 257 //
 258 // Return:      tEplKernel
 259 //
 260 // State:
 261 //
 262 //---------------------------------------------------------------------------
 263
 264 EPLDLLEXPORT tEplKernel PUBLIC EplObdAddInstance(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 265                                                  tEplObdInitParam MEM *
 266                                                  pInitParam_p)
 267 {
 268
 269         EPL_MCO_DECL_INSTANCE_PTR_LOCAL tEplKernel Ret;
 270
 271         // check if pointer to instance pointer valid
 272         // get free instance and set the globale instance pointer
 273         // set also the instance addr to parameterlist
 274         EPL_MCO_CHECK_PTR_INSTANCE_PTR();
 275         EPL_MCO_GET_FREE_INSTANCE_PTR();
 276         EPL_MCO_SET_PTR_INSTANCE_PTR();
 277
 278         // save init parameters
 279         EPL_MEMCPY(&EPL_MCO_GLB_VAR(m_ObdInitParam), pInitParam_p,
 280                    sizeof(tEplObdInitParam));
 281
 282         // clear callback function for command LOAD and STORE
 283         EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = NULL;
 284
 285         // sign instance as used
 286         EPL_MCO_WRITE_INSTANCE_STATE(kStateUsed);
 287
 288         // initialize object dictionary
 289         // so all all VarEntries will be initialized to trash object and default values will be set to current data
 290         Ret = EplObdAccessOdPart(EPL_MCO_INSTANCE_PTR_
 291                                  kEplObdPartAll, kEplObdDirInit);
 292
 293         return Ret;
 294
 295 }
 296
 297 //---------------------------------------------------------------------------
 298 //
 299 // Function:    EplObdDeleteInstance()
 300 //
 301 // Description: delete instance
 302 //
 303 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR
 304 //
 305 // Return:      tEplKernel
 306 //
 307 // State:
 308 //
 309 //---------------------------------------------------------------------------
 310 #if (EPL_USE_DELETEINST_FUNC != FALSE)
 311 EPLDLLEXPORT tEplKernel PUBLIC EplObdDeleteInstance(EPL_MCO_DECL_INSTANCE_PTR)
 312 {
 313         // check for all API function if instance is valid
 314         EPL_MCO_CHECK_INSTANCE_STATE();
 315
 316         // sign instance as unused
 317         EPL_MCO_WRITE_INSTANCE_STATE(kStateUnused);
 318
 319         return kEplSuccessful;
 320
 321 }
 322 #endif // (EPL_USE_DELETEINST_FUNC != FALSE)
 323
 324 //---------------------------------------------------------------------------
 325 //
 326 // Function:    EplObdWriteEntry()
 327 //
 328 // Description: Function writes data to an OBD entry. Strings
 329 //              are stored with added '\0' character.
 330 //
 331 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
 332 //              uiIndex_p       =   Index of the OD entry
 333 //              uiSubIndex_p    =   Subindex of the OD Entry
 334 //              pSrcData_p      =   Pointer to the data to write
 335 //              Size_p          =   Size of the data in Byte
 336 //
 337 // Return:      tEplKernel      =   Errorcode
 338 //
 339 //
 340 // State:
 341 //
 342 //---------------------------------------------------------------------------
 343
 344 EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntry(EPL_MCO_DECL_INSTANCE_PTR_
 345                                                 unsigned int uiIndex_p,
 346                                                 unsigned int uiSubIndex_p,
 347                                                 void *pSrcData_p,
 348                                                 tEplObdSize Size_p)
 349 {
 350
 351         tEplKernel Ret;
 352         tEplObdEntryPtr pObdEntry;
 353         tEplObdSubEntryPtr pSubEntry;
 354         tEplObdCbParam MEM CbParam;
 355         void MEM *pDstData;
 356         tEplObdSize ObdSize;
 357
 358         Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
 359                                   uiIndex_p,
 360                                   uiSubIndex_p,
 361                                   pSrcData_p,
 362                                   &pDstData,
 363                                   Size_p,
 364                                   &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
 365         if (Ret != kEplSuccessful) {
 366                 goto Exit;
 367         }
 368
 369         Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
 370                                    pObdEntry,
 371                                    pSubEntry,
 372                                    &CbParam, pSrcData_p, pDstData, ObdSize);
 373         if (Ret != kEplSuccessful) {
 374                 goto Exit;
 375         }
 376
 377       Exit:
 378
 379         return Ret;
 380
 381 }
 382
 383 //---------------------------------------------------------------------------
 384 //
 385 // Function:    EplObdReadEntry()
 386 //
 387 // Description: The function reads an object entry. The application
 388 //              can always read the data even if attrib kEplObdAccRead
 389 //              is not set. The attrib is only checked up for SDO transfer.
 390 //
 391 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
 392 //              uiIndex_p       = Index oof the OD entry to read
 393 //              uiSubIndex_p    = Subindex to read
 394 //              pDstData_p      = pointer to the buffer for data
 395 //              Offset_p        = offset in data for read access
 396 //              pSize_p         = IN: Size of the buffer
 397 //                                OUT: number of readed Bytes
 398 //
 399 // Return:      tEplKernel
 400 //
 401 // State:
 402 //
 403 //---------------------------------------------------------------------------
 404
 405 EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntry(EPL_MCO_DECL_INSTANCE_PTR_
 406                                                unsigned int uiIndex_p,
 407                                                unsigned int uiSubIndex_p,
 408                                                void *pDstData_p,
 409                                                tEplObdSize * pSize_p)
 410 {
 411
 412         tEplKernel Ret;
 413         tEplObdEntryPtr pObdEntry;
 414         tEplObdSubEntryPtr pSubEntry;
 415         tEplObdCbParam MEM CbParam;
 416         void *pSrcData;
 417         tEplObdSize ObdSize;
 418
 419         // check for all API function if instance is valid
 420         EPL_MCO_CHECK_INSTANCE_STATE();
 421
 422         ASSERT(pDstData_p != NULL);
 423         ASSERT(pSize_p != NULL);
 424
 425         // get address of index and subindex entry
 426         Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
 427                              uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
 428         if (Ret != kEplSuccessful) {
 429                 goto Exit;
 430         }
 431         // get pointer to object data
 432         pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
 433
 434         // check source pointer
 435         if (pSrcData == NULL) {
 436                 Ret = kEplObdReadViolation;
 437                 goto Exit;
 438         }
 439         //------------------------------------------------------------------------
 440         // address of source data to structure of callback parameters
 441         // so callback function can change this data before reading
 442         CbParam.m_uiIndex = uiIndex_p;
 443         CbParam.m_uiSubIndex = uiSubIndex_p;
 444         CbParam.m_pArg = pSrcData;
 445         CbParam.m_ObdEvent = kEplObdEvPreRead;
 446         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
 447                                        pObdEntry->m_fpCallback, &CbParam);
 448         if (Ret != kEplSuccessful) {
 449                 goto Exit;
 450         }
 451         // get size of data and check if application has reserved enough memory
 452         ObdSize = EplObdGetDataSizeIntern(pSubEntry);
 453         // check if offset given and calc correct number of bytes to read
 454         if (*pSize_p < ObdSize) {
 455                 Ret = kEplObdValueLengthError;
 456                 goto Exit;
 457         }
 458         // read value from object
 459         EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
 460         *pSize_p = ObdSize;
 461
 462         // write address of destination data to structure of callback parameters
 463         // so callback function can change this data after reading
 464         CbParam.m_pArg = pDstData_p;
 465         CbParam.m_ObdEvent = kEplObdEvPostRead;
 466         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
 467                                        pObdEntry->m_fpCallback, &CbParam);
 468
 469       Exit:
 470
 471         return Ret;
 472
 473 }
 474
 475 //---------------------------------------------------------------------------
 476 //
 477 // Function:    EplObdAccessOdPart()
 478 //
 479 // Description: restores default values of one part of OD
 480 //
 481 // Parameters:  ObdPart_p
 482 //              Direction_p
 483 //
 484 // Return:      tEplKernel
 485 //
 486 // State:
 487 //
 488 //---------------------------------------------------------------------------
 489
 490 EPLDLLEXPORT tEplKernel PUBLIC EplObdAccessOdPart(EPL_MCO_DECL_INSTANCE_PTR_
 491                                                   tEplObdPart ObdPart_p,
 492                                                   tEplObdDir Direction_p)
 493 {
 494
 495         tEplKernel Ret = kEplSuccessful;
 496         BOOL fPartFount;
 497         tEplObdEntryPtr pObdEntry;
 498
 499         // check for all API function if instance is valid
 500         EPL_MCO_CHECK_INSTANCE_STATE();
 501
 502         //  part always has to be unequal to NULL
 503         pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pPart);
 504         ASSERTMSG(pObdEntry != NULL,
 505                   "EplObdAccessOdPart(): no  OD part is defined!\n");
 506
 507         // if ObdPart_p is not valid fPartFound keeps FALSE and function returns kEplObdIllegalPart
 508         fPartFount = FALSE;
 509
 510         // access to  part
 511         if ((ObdPart_p & kEplObdPartGen) != 0) {
 512                 fPartFount = TRUE;
 513
 514                 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
 515                                                kEplObdPartGen, pObdEntry,
 516                                                Direction_p);
 517                 if (Ret != kEplSuccessful) {
 518                         goto Exit;
 519                 }
 520         }
 521         // access to manufacturer part
 522         pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pManufacturerPart);
 523
 524         if (((ObdPart_p & kEplObdPartMan) != 0) && (pObdEntry != NULL)) {
 525                 fPartFount = TRUE;
 526
 527                 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
 528                                                kEplObdPartMan, pObdEntry,
 529                                                Direction_p);
 530                 if (Ret != kEplSuccessful) {
 531                         goto Exit;
 532                 }
 533         }
 534         // access to device part
 535         pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pDevicePart);
 536
 537         if (((ObdPart_p & kEplObdPartDev) != 0) && (pObdEntry != NULL)) {
 538                 fPartFount = TRUE;
 539
 540                 Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
 541                                                kEplObdPartDev, pObdEntry,
 542                                                Direction_p);
 543                 if (Ret != kEplSuccessful) {
 544                         goto Exit;
 545                 }
 546         }
 547 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
 548         {
 549                 // access to user part
 550                 pObdEntry = EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart);
 551
 552                 if (((ObdPart_p & kEplObdPartUsr) != 0) && (pObdEntry != NULL)) {
 553                         fPartFount = TRUE;
 554
 555                         Ret = EplObdAccessOdPartIntern(EPL_MCO_INSTANCE_PTR_
 556                                                        kEplObdPartUsr,
 557                                                        pObdEntry, Direction_p);
 558                         if (Ret != kEplSuccessful) {
 559                                 goto Exit;
 560                         }
 561                 }
 562         }
 563 #endif
 564
 565         // no access to an OD part was done? illegal OD part was specified!
 566         if (fPartFount == FALSE) {
 567                 Ret = kEplObdIllegalPart;
 568         }
 569
 570       Exit:
 571
 572         return Ret;
 573
 574 }
 575
 576 //---------------------------------------------------------------------------
 577 //
 578 // Function:    EplObdDefineVar()
 579 //
 580 // Description: defines a variable in OD
 581 //
 582 // Parameters:  pEplVarParam_p
 583 //
 584 // Return:      tEplKernel
 585 //
 586 // State:
 587 //
 588 //---------------------------------------------------------------------------
 589
 590 EPLDLLEXPORT tEplKernel PUBLIC EplObdDefineVar(EPL_MCO_DECL_INSTANCE_PTR_
 591                                                tEplVarParam MEM * pVarParam_p)
 592 {
 593
 594         tEplKernel Ret;
 595         tEplObdVarEntry MEM *pVarEntry;
 596         tEplVarParamValid VarValid;
 597         tEplObdSubEntryPtr pSubindexEntry;
 598
 599         // check for all API function if instance is valid
 600         EPL_MCO_CHECK_INSTANCE_STATE();
 601
 602         ASSERT(pVarParam_p != NULL);    // is not allowed to be NULL
 603
 604         // get address of subindex entry
 605         Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
 606                              pVarParam_p->m_uiIndex,
 607                              pVarParam_p->m_uiSubindex, NULL, &pSubindexEntry);
 608         if (Ret != kEplSuccessful) {
 609                 goto Exit;
 610         }
 611         // get var entry
 612         Ret = EplObdGetVarEntry(pSubindexEntry, &pVarEntry);
 613         if (Ret != kEplSuccessful) {
 614                 goto Exit;
 615         }
 616
 617         VarValid = pVarParam_p->m_ValidFlag;
 618
 619         // copy only this values, which valid flag is set
 620         if ((VarValid & kVarValidSize) != 0) {
 621                 if (pSubindexEntry->m_Type != kEplObdTypDomain) {
 622                         tEplObdSize DataSize;
 623
 624                         // check passed size parameter
 625                         DataSize = EplObdGetObjectSize(pSubindexEntry);
 626                         if (DataSize != pVarParam_p->m_Size) {  // size of variable does not match
 627                                 Ret = kEplObdValueLengthError;
 628                                 goto Exit;
 629                         }
 630                 } else {        // size can be set only for objects of type DOMAIN
 631                         pVarEntry->m_Size = pVarParam_p->m_Size;
 632                 }
 633         }
 634
 635         if ((VarValid & kVarValidData) != 0) {
 636                 pVarEntry->m_pData = pVarParam_p->m_pData;
 637         }
 638 /*
 639     #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
 640     {
 641         if ((VarValid & kVarValidCallback) != 0)
 642         {
 643            pVarEntry->m_fpCallback = pVarParam_p->m_fpCallback;
 644         }
 645
 646         if ((VarValid & kVarValidArg) != 0)
 647         {
 648            pVarEntry->m_pArg = pVarParam_p->m_pArg;
 649         }
 650     }
 651     #endif
 652 */
 653         // Ret is already set to kEplSuccessful from ObdGetVarIntern()
 654
 655       Exit:
 656
 657         return Ret;
 658
 659 }
 660
 661 //---------------------------------------------------------------------------
 662 //
 663 // Function:    EplObdGetObjectDataPtr()
 664 //
 665 // Description: It returnes the current data pointer. But if object is an
 666 //              constant object it returnes the default pointer.
 667 //
 668 // Parameters:  uiIndex_p    =   Index of the entry
 669 //              uiSubindex_p =   Subindex of the entry
 670 //
 671 // Return:      void *    = pointer to object data
 672 //
 673 // State:
 674 //
 675 //---------------------------------------------------------------------------
 676
 677 EPLDLLEXPORT void *PUBLIC EplObdGetObjectDataPtr(EPL_MCO_DECL_INSTANCE_PTR_
 678                                                  unsigned int uiIndex_p,
 679                                                  unsigned int uiSubIndex_p)
 680 {
 681         tEplKernel Ret;
 682         void *pData;
 683         tEplObdEntryPtr pObdEntry;
 684         tEplObdSubEntryPtr pObdSubEntry;
 685
 686         // get pointer to index structure
 687         Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
 688                                    uiIndex_p, &pObdEntry);
 689         if (Ret != kEplSuccessful) {
 690                 pData = NULL;
 691                 goto Exit;
 692         }
 693         // get pointer to subindex structure
 694         Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
 695         if (Ret != kEplSuccessful) {
 696                 pData = NULL;
 697                 goto Exit;
 698         }
 699         // get Datapointer
 700         pData = EplObdGetObjectDataPtrIntern(pObdSubEntry);
 701
 702       Exit:
 703         return pData;
 704
 705 }
 706
 707 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
 708
 709 //---------------------------------------------------------------------------
 710 //
 711 // Function:    EplObdRegisterUserOd()
 712 //
 713 // Description: function registers the user OD
 714 //
 715 // Parameters:  pUserOd_p   =pointer to user ODd
 716 //
 717 // Return:     tEplKernel = errorcode
 718 //
 719 // State:
 720 //
 721 //---------------------------------------------------------------------------
 722 EPLDLLEXPORT tEplKernel PUBLIC EplObdRegisterUserOd(EPL_MCO_DECL_INSTANCE_PTR_
 723                                                     tEplObdEntryPtr pUserOd_p)
 724 {
 725
 726         EPL_MCO_CHECK_INSTANCE_STATE();
 727
 728         EPL_MCO_GLB_VAR(m_ObdInitParam.m_pUserPart) = pUserOd_p;
 729
 730         return kEplSuccessful;
 731
 732 }
 733
 734 #endif
 735
 736 //---------------------------------------------------------------------------
 737 //
 738 // Function:    EplObdInitVarEntry()
 739 //
 740 // Description: function to initialize VarEntry dependened on object type
 741 //
 742 // Parameters:  pVarEntry_p = pointer to var entry structure
 743 //              Type_p      = object type
 744 //              ObdSize_p   = size of object data
 745 //
 746 // Returns:     none
 747 //
 748 // State:
 749 //
 750 //---------------------------------------------------------------------------
 751
 752 EPLDLLEXPORT void PUBLIC EplObdInitVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
 753                                             tEplObdVarEntry MEM * pVarEntry_p,
 754                                             tEplObdType Type_p,
 755                                             tEplObdSize ObdSize_p)
 756 {
 757 /*
 758     #if (EPL_PDO_USE_STATIC_MAPPING == FALSE)
 759     {
 760         // reset pointer to VAR callback and argument
 761         pVarEntry_p->m_fpCallback  = NULL;
 762         pVarEntry_p->m_pArg = NULL;
 763     }
 764     #endif
 765 */
 766
 767 // 10-dec-2004 r.d.: this function will not be used for strings
 768         if ((Type_p == kEplObdTypDomain))
 769 //         (bType_p == kEplObdTypVString) /* ||
 770 //         (bType_p == kEplObdTypOString) ||
 771 //         (bType_p == kEplObdTypUString)    */ )
 772         {
 773                 // variables which are defined as DOMAIN or VSTRING should not point to
 774                 // trash object, because this trash object contains only 8 bytes. DOMAINS or
 775                 // STRINGS can be longer.
 776                 pVarEntry_p->m_pData = NULL;
 777                 pVarEntry_p->m_Size = 0;
 778         } else {
 779                 // set address to variable data to trash object
 780                 // This prevents an access violation if user forgets to call EplObdDefineVar()
 781                 // for this variable but mappes it in a PDO.
 782                 pVarEntry_p->m_pData = &abEplObdTrashObject_g[0];
 783                 pVarEntry_p->m_Size = ObdSize_p;
 784         }
 785
 786 }
 787
 788 //---------------------------------------------------------------------------
 789 //
 790 // Function:    EplObdGetDataSize()
 791 //
 792 // Description: function to initialize VarEntry dependened on object type
 793 //
 794 //              gets the data size of an object
 795 //              for string objects it returnes the string length
 796 //
 797 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
 798 //              uiIndex_p   =   Index
 799 //              uiSubIndex_p=   Subindex
 800 //
 801 // Return:      tEplObdSize
 802 //
 803 // State:
 804 //
 805 //---------------------------------------------------------------------------
 806 EPLDLLEXPORT tEplObdSize PUBLIC EplObdGetDataSize(EPL_MCO_DECL_INSTANCE_PTR_
 807                                                   unsigned int uiIndex_p,
 808                                                   unsigned int uiSubIndex_p)
 809 {
 810         tEplKernel Ret;
 811         tEplObdSize ObdSize;
 812         tEplObdEntryPtr pObdEntry;
 813         tEplObdSubEntryPtr pObdSubEntry;
 814
 815         // get pointer to index structure
 816         Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
 817                                    uiIndex_p, &pObdEntry);
 818         if (Ret != kEplSuccessful) {
 819                 ObdSize = 0;
 820                 goto Exit;
 821         }
 822         // get pointer to subindex structure
 823         Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
 824         if (Ret != kEplSuccessful) {
 825                 ObdSize = 0;
 826                 goto Exit;
 827         }
 828         // get size
 829         ObdSize = EplObdGetDataSizeIntern(pObdSubEntry);
 830       Exit:
 831         return ObdSize;
 832 }
 833
 834 //---------------------------------------------------------------------------
 835 //
 836 // Function:    EplObdGetNodeId()
 837 //
 838 // Description: function returns nodeid from entry 0x1F93
 839 //
 840 //
 841 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR = Instancepointer
 842 //
 843 // Return:      unsigned int = Node Id
 844 //
 845 // State:
 846 //
 847 //---------------------------------------------------------------------------
 848 EPLDLLEXPORT unsigned int PUBLIC EplObdGetNodeId(EPL_MCO_DECL_INSTANCE_PTR)
 849 {
 850         tEplKernel Ret;
 851         tEplObdSize ObdSize;
 852         BYTE bNodeId;
 853
 854         bNodeId = 0;
 855         ObdSize = sizeof(bNodeId);
 856         Ret = EplObdReadEntry(EPL_MCO_PTR_INSTANCE_PTR_
 857                               EPL_OBD_NODE_ID_INDEX,
 858                               EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, &ObdSize);
 859         if (Ret != kEplSuccessful) {
 860                 bNodeId = EPL_C_ADR_INVALID;
 861                 goto Exit;
 862         }
 863
 864       Exit:
 865         return (unsigned int)bNodeId;
 866
 867 }
 868
 869 //---------------------------------------------------------------------------
 870 //
 871 // Function:    EplObdSetNodeId()
 872 //
 873 // Description: function sets nodeid in entry 0x1F93
 874 //
 875 //
 876 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
 877 //              uiNodeId_p  =   Node Id to set
 878 //              NodeIdType_p=   Type on which way the Node Id was set
 879 //
 880 // Return:      tEplKernel = Errorcode
 881 //
 882 // State:
 883 //
 884 //---------------------------------------------------------------------------
 885 EPLDLLEXPORT tEplKernel PUBLIC EplObdSetNodeId(EPL_MCO_DECL_PTR_INSTANCE_PTR_
 886                                                unsigned int uiNodeId_p,
 887                                                tEplObdNodeIdType NodeIdType_p)
 888 {
 889         tEplKernel Ret;
 890         tEplObdSize ObdSize;
 891         BYTE fHwBool;
 892         BYTE bNodeId;
 893
 894         // check Node Id
 895         if (uiNodeId_p == EPL_C_ADR_INVALID) {
 896                 Ret = kEplInvalidNodeId;
 897                 goto Exit;
 898         }
 899         bNodeId = (BYTE) uiNodeId_p;
 900         ObdSize = sizeof(BYTE);
 901         // write NodeId to OD entry
 902         Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR_
 903                                EPL_OBD_NODE_ID_INDEX,
 904                                EPL_OBD_NODE_ID_SUBINDEX, &bNodeId, ObdSize);
 905         if (Ret != kEplSuccessful) {
 906                 goto Exit;
 907         }
 908         // set HWBOOL-Flag in Subindex EPL_OBD_NODE_ID_HWBOOL_SUBINDEX
 909         switch (NodeIdType_p) {
 910                 // type unknown
 911         case kEplObdNodeIdUnknown:
 912                 {
 913                         fHwBool = OBD_FALSE;
 914                         break;
 915                 }
 916
 917         case kEplObdNodeIdSoftware:
 918                 {
 919                         fHwBool = OBD_FALSE;
 920                         break;
 921                 }
 922
 923         case kEplObdNodeIdHardware:
 924                 {
 925                         fHwBool = OBD_TRUE;
 926                         break;
 927                 }
 928
 929         default:
 930                 {
 931                         fHwBool = OBD_FALSE;
 932                 }
 933
 934         }                       // end of switch (NodeIdType_p)
 935
 936         // write flag
 937         ObdSize = sizeof(fHwBool);
 938         Ret = EplObdWriteEntry(EPL_MCO_PTR_INSTANCE_PTR
 939                                EPL_OBD_NODE_ID_INDEX,
 940                                EPL_OBD_NODE_ID_HWBOOL_SUBINDEX,
 941                                &fHwBool, ObdSize);
 942         if (Ret != kEplSuccessful) {
 943                 goto Exit;
 944         }
 945
 946       Exit:
 947         return Ret;
 948 }
 949
 950 //---------------------------------------------------------------------------
 951 //
 952 // Function:    EplObdIsNumerical()
 953 //
 954 // Description: function checks if a entry is numerical or not
 955 //
 956 //
 957 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
 958 //              uiIndex_p           = Index
 959 //              uiSubIndex_p        = Subindex
 960 //              pfEntryNumerical_p  = pointer to BOOL for returnvalue
 961 //                                  -> TRUE if entry a numerical value
 962 //                                  -> FALSE if entry not a numerical value
 963 //
 964 // Return:      tEplKernel = Errorcode
 965 //
 966 // State:
 967 //
 968 //---------------------------------------------------------------------------
 969 EPLDLLEXPORT tEplKernel PUBLIC EplObdIsNumerical(EPL_MCO_DECL_INSTANCE_PTR_
 970                                                  unsigned int uiIndex_p,
 971                                                  unsigned int uiSubIndex_p,
 972                                                  BOOL * pfEntryNumerical_p)
 973 {
 974         tEplKernel Ret;
 975         tEplObdEntryPtr pObdEntry;
 976         tEplObdSubEntryPtr pObdSubEntry;
 977
 978         // get pointer to index structure
 979         Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
 980                                    uiIndex_p, &pObdEntry);
 981         if (Ret != kEplSuccessful) {
 982                 goto Exit;
 983         }
 984         // get pointer to subindex structure
 985         Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
 986         if (Ret != kEplSuccessful) {
 987                 goto Exit;
 988         }
 989
 990         Ret = EplObdIsNumericalIntern(pObdSubEntry, pfEntryNumerical_p);
 991
 992       Exit:
 993         return Ret;
 994
 995 }
 996
 997 //---------------------------------------------------------------------------
 998 //
 999 // Function:    EplObdReadEntryToLe()
1000 //
1001 // Description: The function reads an object entry from the byteoder
1002 //              of the system to the little endian byteorder for numerical values.
1003 //              For other types a normal read will be processed. This is usefull for
1004 //              the PDO and SDO module. The application
1005 //              can always read the data even if attrib kEplObdAccRead
1006 //              is not set. The attrib is only checked up for SDO transfer.
1007 //
1008 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
1009 //              uiIndex_p       = Index of the OD entry to read
1010 //              uiSubIndex_p    = Subindex to read
1011 //              pDstData_p      = pointer to the buffer for data
1012 //              Offset_p        = offset in data for read access
1013 //              pSize_p         = IN: Size of the buffer
1014 //                                OUT: number of readed Bytes
1015 //
1016 // Return:      tEplKernel
1017 //
1018 // State:
1019 //
1020 //---------------------------------------------------------------------------
1021 EPLDLLEXPORT tEplKernel PUBLIC EplObdReadEntryToLe(EPL_MCO_DECL_INSTANCE_PTR_
1022                                                    unsigned int uiIndex_p,
1023                                                    unsigned int uiSubIndex_p,
1024                                                    void *pDstData_p,
1025                                                    tEplObdSize * pSize_p)
1026 {
1027         tEplKernel Ret;
1028         tEplObdEntryPtr pObdEntry;
1029         tEplObdSubEntryPtr pSubEntry;
1030         tEplObdCbParam MEM CbParam;
1031         void *pSrcData;
1032         tEplObdSize ObdSize;
1033
1034         // check for all API function if instance is valid
1035         EPL_MCO_CHECK_INSTANCE_STATE();
1036
1037         ASSERT(pDstData_p != NULL);
1038         ASSERT(pSize_p != NULL);
1039
1040         // get address of index and subindex entry
1041         Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1042                              uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
1043         if (Ret != kEplSuccessful) {
1044                 goto Exit;
1045         }
1046         // get pointer to object data
1047         pSrcData = EplObdGetObjectDataPtrIntern(pSubEntry);
1048
1049         // check source pointer
1050         if (pSrcData == NULL) {
1051                 Ret = kEplObdReadViolation;
1052                 goto Exit;
1053         }
1054         //------------------------------------------------------------------------
1055         // address of source data to structure of callback parameters
1056         // so callback function can change this data before reading
1057         CbParam.m_uiIndex = uiIndex_p;
1058         CbParam.m_uiSubIndex = uiSubIndex_p;
1059         CbParam.m_pArg = pSrcData;
1060         CbParam.m_ObdEvent = kEplObdEvPreRead;
1061         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1062                                        pObdEntry->m_fpCallback, &CbParam);
1063         if (Ret != kEplSuccessful) {
1064                 goto Exit;
1065         }
1066         // get size of data and check if application has reserved enough memory
1067         ObdSize = EplObdGetDataSizeIntern(pSubEntry);
1068         // check if offset given and calc correct number of bytes to read
1069         if (*pSize_p < ObdSize) {
1070                 Ret = kEplObdValueLengthError;
1071                 goto Exit;
1072         }
1073         // check if numerical type
1074         switch (pSubEntry->m_Type) {
1075                 //-----------------------------------------------
1076                 // types without ami
1077         case kEplObdTypVString:
1078         case kEplObdTypOString:
1079         case kEplObdTypDomain:
1080         default:
1081                 {
1082                         // read value from object
1083                         EPL_MEMCPY(pDstData_p, pSrcData, ObdSize);
1084                         break;
1085                 }
1086
1087                 //-----------------------------------------------
1088                 // numerical type which needs ami-write
1089                 // 8 bit or smaller values
1090         case kEplObdTypBool:
1091         case kEplObdTypInt8:
1092         case kEplObdTypUInt8:
1093                 {
1094                         AmiSetByteToLe(pDstData_p, *((BYTE *) pSrcData));
1095                         break;
1096                 }
1097
1098                 // 16 bit values
1099         case kEplObdTypInt16:
1100         case kEplObdTypUInt16:
1101                 {
1102                         AmiSetWordToLe(pDstData_p, *((WORD *) pSrcData));
1103                         break;
1104                 }
1105
1106                 // 24 bit values
1107         case kEplObdTypInt24:
1108         case kEplObdTypUInt24:
1109                 {
1110                         AmiSetDword24ToLe(pDstData_p, *((DWORD *) pSrcData));
1111                         break;
1112                 }
1113
1114                 // 32 bit values
1115         case kEplObdTypInt32:
1116         case kEplObdTypUInt32:
1117         case kEplObdTypReal32:
1118                 {
1119                         AmiSetDwordToLe(pDstData_p, *((DWORD *) pSrcData));
1120                         break;
1121                 }
1122
1123                 // 40 bit values
1124         case kEplObdTypInt40:
1125         case kEplObdTypUInt40:
1126                 {
1127                         AmiSetQword40ToLe(pDstData_p, *((QWORD *) pSrcData));
1128                         break;
1129                 }
1130
1131                 // 48 bit values
1132         case kEplObdTypInt48:
1133         case kEplObdTypUInt48:
1134                 {
1135                         AmiSetQword48ToLe(pDstData_p, *((QWORD *) pSrcData));
1136                         break;
1137                 }
1138
1139                 // 56 bit values
1140         case kEplObdTypInt56:
1141         case kEplObdTypUInt56:
1142                 {
1143                         AmiSetQword56ToLe(pDstData_p, *((QWORD *) pSrcData));
1144                         break;
1145                 }
1146
1147                 // 64 bit values
1148         case kEplObdTypInt64:
1149         case kEplObdTypUInt64:
1150         case kEplObdTypReal64:
1151                 {
1152                         AmiSetQword64ToLe(pDstData_p, *((QWORD *) pSrcData));
1153                         break;
1154                 }
1155
1156                 // time of day
1157         case kEplObdTypTimeOfDay:
1158         case kEplObdTypTimeDiff:
1159                 {
1160                         AmiSetTimeOfDay(pDstData_p, ((tTimeOfDay *) pSrcData));
1161                         break;
1162                 }
1163
1164         }                       // end of switch(pSubEntry->m_Type)
1165
1166         *pSize_p = ObdSize;
1167
1168         // write address of destination data to structure of callback parameters
1169         // so callback function can change this data after reading
1170         CbParam.m_pArg = pDstData_p;
1171         CbParam.m_ObdEvent = kEplObdEvPostRead;
1172         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1173                                        pObdEntry->m_fpCallback, &CbParam);
1174
1175       Exit:
1176
1177         return Ret;
1178
1179 }
1180
1181 //---------------------------------------------------------------------------
1182 //
1183 // Function:    EplObdWriteEntryFromLe()
1184 //
1185 // Description: Function writes data to an OBD entry from a source with
1186 //              little endian byteorder to the od with system specuific
1187 //              byteorder. Not numerical values will only by copied. Strings
1188 //              are stored with added '\0' character.
1189 //
1190 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
1191 //              uiIndex_p       =   Index of the OD entry
1192 //              uiSubIndex_p    =   Subindex of the OD Entry
1193 //              pSrcData_p      =   Pointer to the data to write
1194 //              Size_p          =   Size of the data in Byte
1195 //
1196 // Return:      tEplKernel      =   Errorcode
1197 //
1198 //
1199 // State:
1200 //
1201 //---------------------------------------------------------------------------
1202 EPLDLLEXPORT tEplKernel PUBLIC EplObdWriteEntryFromLe(EPL_MCO_DECL_INSTANCE_PTR_
1203                                                       unsigned int uiIndex_p,
1204                                                       unsigned int uiSubIndex_p,
1205                                                       void *pSrcData_p,
1206                                                       tEplObdSize Size_p)
1207 {
1208         tEplKernel Ret;
1209         tEplObdEntryPtr pObdEntry;
1210         tEplObdSubEntryPtr pSubEntry;
1211         tEplObdCbParam MEM CbParam;
1212         void MEM *pDstData;
1213         tEplObdSize ObdSize;
1214         QWORD qwBuffer;
1215         void *pBuffer = &qwBuffer;
1216
1217         Ret = EplObdWriteEntryPre(EPL_MCO_INSTANCE_PTR_
1218                                   uiIndex_p,
1219                                   uiSubIndex_p,
1220                                   pSrcData_p,
1221                                   &pDstData,
1222                                   Size_p,
1223                                   &pObdEntry, &pSubEntry, &CbParam, &ObdSize);
1224         if (Ret != kEplSuccessful) {
1225                 goto Exit;
1226         }
1227
1228         // check if numerical type
1229         switch (pSubEntry->m_Type) {
1230                 //-----------------------------------------------
1231                 // types without ami
1232         default:
1233                 {               // do nothing, i.e. use the given source pointer
1234                         pBuffer = pSrcData_p;
1235                         break;
1236                 }
1237
1238                 //-----------------------------------------------
1239                 // numerical type which needs ami-write
1240                 // 8 bit or smaller values
1241         case kEplObdTypBool:
1242         case kEplObdTypInt8:
1243         case kEplObdTypUInt8:
1244                 {
1245                         *((BYTE *) pBuffer) = AmiGetByteFromLe(pSrcData_p);
1246                         break;
1247                 }
1248
1249                 // 16 bit values
1250         case kEplObdTypInt16:
1251         case kEplObdTypUInt16:
1252                 {
1253                         *((WORD *) pBuffer) = AmiGetWordFromLe(pSrcData_p);
1254                         break;
1255                 }
1256
1257                 // 24 bit values
1258         case kEplObdTypInt24:
1259         case kEplObdTypUInt24:
1260                 {
1261                         *((DWORD *) pBuffer) = AmiGetDword24FromLe(pSrcData_p);
1262                         break;
1263                 }
1264
1265                 // 32 bit values
1266         case kEplObdTypInt32:
1267         case kEplObdTypUInt32:
1268         case kEplObdTypReal32:
1269                 {
1270                         *((DWORD *) pBuffer) = AmiGetDwordFromLe(pSrcData_p);
1271                         break;
1272                 }
1273
1274                 // 40 bit values
1275         case kEplObdTypInt40:
1276         case kEplObdTypUInt40:
1277                 {
1278                         *((QWORD *) pBuffer) = AmiGetQword40FromLe(pSrcData_p);
1279                         break;
1280                 }
1281
1282                 // 48 bit values
1283         case kEplObdTypInt48:
1284         case kEplObdTypUInt48:
1285                 {
1286                         *((QWORD *) pBuffer) = AmiGetQword48FromLe(pSrcData_p);
1287                         break;
1288                 }
1289
1290                 // 56 bit values
1291         case kEplObdTypInt56:
1292         case kEplObdTypUInt56:
1293                 {
1294                         *((QWORD *) pBuffer) = AmiGetQword56FromLe(pSrcData_p);
1295                         break;
1296                 }
1297
1298                 // 64 bit values
1299         case kEplObdTypInt64:
1300         case kEplObdTypUInt64:
1301         case kEplObdTypReal64:
1302                 {
1303                         *((QWORD *) pBuffer) = AmiGetQword64FromLe(pSrcData_p);
1304                         break;
1305                 }
1306
1307                 // time of day
1308         case kEplObdTypTimeOfDay:
1309         case kEplObdTypTimeDiff:
1310                 {
1311                         AmiGetTimeOfDay(pBuffer, ((tTimeOfDay *) pSrcData_p));
1312                         break;
1313                 }
1314
1315         }                       // end of switch(pSubEntry->m_Type)
1316
1317         Ret = EplObdWriteEntryPost(EPL_MCO_INSTANCE_PTR_
1318                                    pObdEntry,
1319                                    pSubEntry,
1320                                    &CbParam, pBuffer, pDstData, ObdSize);
1321         if (Ret != kEplSuccessful) {
1322                 goto Exit;
1323         }
1324
1325       Exit:
1326
1327         return Ret;
1328
1329 }
1330
1331 //---------------------------------------------------------------------------
1332 //
1333 // Function:    EplObdGetAccessType()
1334 //
1335 // Description: Function returns accesstype of the entry
1336 //
1337 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
1338 //              uiIndex_p       =   Index of the OD entry
1339 //              uiSubIndex_p    =   Subindex of the OD Entry
1340 //              pAccessTyp_p    =   pointer to buffer to store accesstype
1341 //
1342 // Return:      tEplKernel     =   errorcode
1343 //
1344 //
1345 // State:
1346 //
1347 //---------------------------------------------------------------------------
1348 EPLDLLEXPORT tEplKernel PUBLIC EplObdGetAccessType(EPL_MCO_DECL_INSTANCE_PTR_
1349                                                    unsigned int uiIndex_p,
1350                                                    unsigned int uiSubIndex_p,
1351                                                    tEplObdAccess * pAccessTyp_p)
1352 {
1353         tEplKernel Ret;
1354         tEplObdEntryPtr pObdEntry;
1355         tEplObdSubEntryPtr pObdSubEntry;
1356
1357         // get pointer to index structure
1358         Ret = EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam),
1359                                    uiIndex_p, &pObdEntry);
1360         if (Ret != kEplSuccessful) {
1361                 goto Exit;
1362         }
1363         // get pointer to subindex structure
1364         Ret = EplObdGetSubindexIntern(pObdEntry, uiSubIndex_p, &pObdSubEntry);
1365         if (Ret != kEplSuccessful) {
1366                 goto Exit;
1367         }
1368         // get accessType
1369         *pAccessTyp_p = pObdSubEntry->m_Access;
1370
1371       Exit:
1372         return Ret;
1373 }
1374
1375 //---------------------------------------------------------------------------
1376 //
1377 // Function:    EplObdSearchVarEntry()
1378 //
1379 // Description: gets variable from OD
1380 //
1381 // Parameters:  uiIndex_p       =   index of the var entry to search
1382 //              uiSubindex_p    =   subindex of var entry to search
1383 //              ppVarEntry_p    =   pointer to the pointer to the varentry
1384 //
1385 // Return:      tEplKernel
1386 //
1387 // State:
1388 //
1389 //---------------------------------------------------------------------------
1390
1391 tEplKernel PUBLIC EplObdSearchVarEntry(EPL_MCO_DECL_INSTANCE_PTR_
1392                                        unsigned int uiIndex_p,
1393                                        unsigned int uiSubindex_p,
1394                                        tEplObdVarEntry MEM ** ppVarEntry_p)
1395 {
1396
1397         tEplKernel Ret;
1398         tEplObdSubEntryPtr pSubindexEntry;
1399
1400         // check for all API function if instance is valid
1401         EPL_MCO_CHECK_INSTANCE_STATE();
1402
1403         // get address of subindex entry
1404         Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1405                              uiIndex_p, uiSubindex_p, NULL, &pSubindexEntry);
1406         if (Ret == kEplSuccessful) {
1407                 // get var entry
1408                 Ret = EplObdGetVarEntry(pSubindexEntry, ppVarEntry_p);
1409         }
1410
1411         return Ret;
1412
1413 }
1414
1415 //=========================================================================//
1416 //                                                                         //
1417 //          P R I V A T E   D E F I N I T I O N S                          //
1418 //                                                                         //
1419 //=========================================================================//
1420
1421 EPL_MCO_DECL_INSTANCE_FCT()
1422 //---------------------------------------------------------------------------
1423 //
1424 // Function:    EplObdCallObjectCallback()
1425 //
1426 // Description: calls callback function of an object or of a variable
1427 //
1428 // Parameters:  fpCallback_p
1429 //              pCbParam_p
1430 //
1431 // Return:      tEplKernel
1432 //
1433 // State:
1434 //
1435 //---------------------------------------------------------------------------
1436 static tEplKernel EplObdCallObjectCallback(EPL_MCO_DECL_INSTANCE_PTR_
1437                                            tEplObdCallback fpCallback_p,
1438                                            tEplObdCbParam MEM * pCbParam_p)
1439 {
1440
1441         tEplKernel Ret;
1442         tEplObdCallback MEM fpCallback;
1443
1444         // check for all API function if instance is valid
1445         EPL_MCO_CHECK_INSTANCE_STATE();
1446
1447         ASSERT(pCbParam_p != NULL);
1448
1449         Ret = kEplSuccessful;
1450
1451         // check address of callback function before calling it
1452         if (fpCallback_p != NULL) {
1453                 // KEIL C51 V6.01 has a bug.
1454                 // Therefore the parameter fpCallback_p has to be copied in local variable fpCallback.
1455                 fpCallback = fpCallback_p;
1456
1457                 // call callback function for this object
1458                 Ret = fpCallback(EPL_MCO_INSTANCE_PARAM_IDX_()
1459                                  pCbParam_p);
1460         }
1461
1462         return Ret;
1463 }
1464
1465 //---------------------------------------------------------------------------
1466 //
1467 // Function:    EplObdGetDataSizeIntern()
1468 //
1469 // Description: gets the data size of an object
1470 //              for string objects it returnes the string length
1471 //
1472 // Parameters:  pSubIndexEntry_p
1473 //
1474 // Return:      tEplObdSize
1475 //
1476 // State:
1477 //
1478 //---------------------------------------------------------------------------
1479
1480 static tEplObdSize EplObdGetDataSizeIntern(tEplObdSubEntryPtr pSubIndexEntry_p)
1481 {
1482
1483         tEplObdSize DataSize;
1484         void MEM *pData;
1485
1486         // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
1487         // then the current pointer is always NULL. The function
1488         // returns the length of default string.
1489         DataSize = EplObdGetObjectSize(pSubIndexEntry_p);
1490
1491         if (pSubIndexEntry_p->m_Type == kEplObdTypVString) {
1492                 // The pointer to current value can be received from EplObdGetObjectCurrentPtr()
1493                 pData =
1494                     ((void MEM *)EplObdGetObjectCurrentPtr(pSubIndexEntry_p));
1495                 if (pData != NULL) {
1496                         DataSize =
1497                             EplObdGetStrLen((void *)pData, DataSize,
1498                                             pSubIndexEntry_p->m_Type);
1499                 }
1500
1501         }
1502
1503         return DataSize;
1504
1505 }
1506
1507 //---------------------------------------------------------------------------
1508 //
1509 // Function:    EplObdGetStrLen()
1510 //
1511 // Description: The function calculates the length of string. The '\0'
1512 //              character is included!!
1513 //
1514 // Parameters:  pObjData_p          = pointer to string
1515 //              ObjLen_p            = max. length of objectr entry
1516 //              bObjType_p          = object type (VSTRING, ...)
1517 //
1518 // Returns:     string length + 1
1519 //
1520 // State:
1521 //
1522 //---------------------------------------------------------------------------
1523
1524 static tEplObdSize EplObdGetStrLen(void *pObjData_p,
1525                                    tEplObdSize ObjLen_p, tEplObdType ObjType_p)
1526 {
1527
1528         tEplObdSize StrLen = 0;
1529         BYTE *pbString;
1530
1531         if (pObjData_p == NULL) {
1532                 goto Exit;
1533         }
1534         //----------------------------------------
1535         // Visible String: data format byte
1536         if (ObjType_p == kEplObdTypVString) {
1537                 pbString = pObjData_p;
1538
1539                 for (StrLen = 0; StrLen < ObjLen_p; StrLen++) {
1540                         if (*pbString == '\0') {
1541                                 StrLen++;
1542                                 break;
1543                         }
1544
1545                         pbString++;
1546                 }
1547         }
1548         //----------------------------------------
1549         // other string types ...
1550
1551       Exit:
1552         return (StrLen);
1553
1554 }
1555
1556 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
1557
1558 //---------------------------------------------------------------------------
1559 //
1560 // Function:    EplObdCheckObjectRange()
1561 //
1562 // Description: function to check value range of object data
1563 //
1564 // NOTICE: The pointer of data (pData_p) must point out to an even address,
1565 //         if ObjType is unequal to kEplObdTypInt8 or kEplObdTypUInt8! But it is
1566 //         always realiced because pointer m_pDefault points always to an
1567 //         array of the SPECIFIED type.
1568 //
1569 // Parameters:  pSubindexEntry_p
1570 //              pData_p
1571 //
1572 // Return:      tEplKernel
1573 //
1574 // State:
1575 //
1576 //---------------------------------------------------------------------------
1577
1578 static tEplKernel EplObdCheckObjectRange(tEplObdSubEntryPtr pSubindexEntry_p,
1579                                          void *pData_p)
1580 {
1581
1582         tEplKernel Ret;
1583         void *pRangeData;
1584
1585         ASSERTMSG(pSubindexEntry_p != NULL,
1586                   "EplObdCheckObjectRange(): no address to subindex struct!\n");
1587
1588         Ret = kEplSuccessful;
1589
1590         // check if data range has to be checked
1591         if ((pSubindexEntry_p->m_Access & kEplObdAccRange) == 0) {
1592                 goto Exit;
1593         }
1594         // get address of default data
1595         pRangeData = pSubindexEntry_p->m_pDefault;
1596
1597         // jump to called object type
1598         switch ((tEplObdType) pSubindexEntry_p->m_Type) {
1599                 // -----------------------------------------------------------------
1600                 // ObdType kEplObdTypBool will not be checked because there are only
1601                 // two possible values 0 or 1.
1602
1603                 // -----------------------------------------------------------------
1604                 // ObdTypes which has to be check up because numerical values
1605         case kEplObdTypInt8:
1606
1607                 // switch to lower limit
1608                 pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
1609
1610                 // check if value is to low
1611                 if (*((tEplObdInteger8 *) pData_p) <
1612                     *((tEplObdInteger8 *) pRangeData)) {
1613                         Ret = kEplObdValueTooLow;
1614                         break;
1615                 }
1616                 // switch to higher limit
1617                 pRangeData = ((tEplObdInteger8 *) pRangeData) + 1;
1618
1619                 // check if value is to high
1620                 if (*((tEplObdInteger8 *) pData_p) >
1621                     *((tEplObdInteger8 *) pRangeData)) {
1622                         Ret = kEplObdValueTooHigh;
1623                 }
1624
1625                 break;
1626
1627         case kEplObdTypUInt8:
1628
1629                 // switch to lower limit
1630                 pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
1631
1632                 // check if value is to low
1633                 if (*((tEplObdUnsigned8 *) pData_p) <
1634                     *((tEplObdUnsigned8 *) pRangeData)) {
1635                         Ret = kEplObdValueTooLow;
1636                         break;
1637                 }
1638                 // switch to higher limit
1639                 pRangeData = ((tEplObdUnsigned8 *) pRangeData) + 1;
1640
1641                 // check if value is to high
1642                 if (*((tEplObdUnsigned8 *) pData_p) >
1643                     *((tEplObdUnsigned8 *) pRangeData)) {
1644                         Ret = kEplObdValueTooHigh;
1645                 }
1646
1647                 break;
1648
1649         case kEplObdTypInt16:
1650
1651                 // switch to lower limit
1652                 pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
1653
1654                 // check if value is to low
1655                 if (*((tEplObdInteger16 *) pData_p) <
1656                     *((tEplObdInteger16 *) pRangeData)) {
1657                         Ret = kEplObdValueTooLow;
1658                         break;
1659                 }
1660                 // switch to higher limit
1661                 pRangeData = ((tEplObdInteger16 *) pRangeData) + 1;
1662
1663                 // check if value is to high
1664                 if (*((tEplObdInteger16 *) pData_p) >
1665                     *((tEplObdInteger16 *) pRangeData)) {
1666                         Ret = kEplObdValueTooHigh;
1667                 }
1668
1669                 break;
1670
1671         case kEplObdTypUInt16:
1672
1673                 // switch to lower limit
1674                 pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
1675
1676                 // check if value is to low
1677                 if (*((tEplObdUnsigned16 *) pData_p) <
1678                     *((tEplObdUnsigned16 *) pRangeData)) {
1679                         Ret = kEplObdValueTooLow;
1680                         break;
1681                 }
1682                 // switch to higher limit
1683                 pRangeData = ((tEplObdUnsigned16 *) pRangeData) + 1;
1684
1685                 // check if value is to high
1686                 if (*((tEplObdUnsigned16 *) pData_p) >
1687                     *((tEplObdUnsigned16 *) pRangeData)) {
1688                         Ret = kEplObdValueTooHigh;
1689                 }
1690
1691                 break;
1692
1693         case kEplObdTypInt32:
1694
1695                 // switch to lower limit
1696                 pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
1697
1698                 // check if value is to low
1699                 if (*((tEplObdInteger32 *) pData_p) <
1700                     *((tEplObdInteger32 *) pRangeData)) {
1701                         Ret = kEplObdValueTooLow;
1702                         break;
1703                 }
1704                 // switch to higher limit
1705                 pRangeData = ((tEplObdInteger32 *) pRangeData) + 1;
1706
1707                 // check if value is to high
1708                 if (*((tEplObdInteger32 *) pData_p) >
1709                     *((tEplObdInteger32 *) pRangeData)) {
1710                         Ret = kEplObdValueTooHigh;
1711                 }
1712
1713                 break;
1714
1715         case kEplObdTypUInt32:
1716
1717                 // switch to lower limit
1718                 pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
1719
1720                 // check if value is to low
1721                 if (*((tEplObdUnsigned32 *) pData_p) <
1722                     *((tEplObdUnsigned32 *) pRangeData)) {
1723                         Ret = kEplObdValueTooLow;
1724                         break;
1725                 }
1726                 // switch to higher limit
1727                 pRangeData = ((tEplObdUnsigned32 *) pRangeData) + 1;
1728
1729                 // check if value is to high
1730                 if (*((tEplObdUnsigned32 *) pData_p) >
1731                     *((tEplObdUnsigned32 *) pRangeData)) {
1732                         Ret = kEplObdValueTooHigh;
1733                 }
1734
1735                 break;
1736
1737         case kEplObdTypReal32:
1738
1739                 // switch to lower limit
1740                 pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
1741
1742                 // check if value is to low
1743                 if (*((tEplObdReal32 *) pData_p) <
1744                     *((tEplObdReal32 *) pRangeData)) {
1745                         Ret = kEplObdValueTooLow;
1746                         break;
1747                 }
1748                 // switch to higher limit
1749                 pRangeData = ((tEplObdReal32 *) pRangeData) + 1;
1750
1751                 // check if value is to high
1752                 if (*((tEplObdReal32 *) pData_p) >
1753                     *((tEplObdReal32 *) pRangeData)) {
1754                         Ret = kEplObdValueTooHigh;
1755                 }
1756
1757                 break;
1758
1759                 // -----------------------------------------------------------------
1760         case kEplObdTypInt40:
1761         case kEplObdTypInt48:
1762         case kEplObdTypInt56:
1763         case kEplObdTypInt64:
1764
1765                 // switch to lower limit
1766                 pRangeData = ((signed QWORD *)pRangeData) + 1;
1767
1768                 // check if value is to low
1769                 if (*((signed QWORD *)pData_p) < *((signed QWORD *)pRangeData)) {
1770                         Ret = kEplObdValueTooLow;
1771                         break;
1772                 }
1773                 // switch to higher limit
1774                 pRangeData = ((signed QWORD *)pRangeData) + 1;
1775
1776                 // check if value is to high
1777                 if (*((signed QWORD *)pData_p) > *((signed QWORD *)pRangeData)) {
1778                         Ret = kEplObdValueTooHigh;
1779                 }
1780
1781                 break;
1782
1783                 // -----------------------------------------------------------------
1784         case kEplObdTypUInt40:
1785         case kEplObdTypUInt48:
1786         case kEplObdTypUInt56:
1787         case kEplObdTypUInt64:
1788
1789                 // switch to lower limit
1790                 pRangeData = ((unsigned QWORD *)pRangeData) + 1;
1791
1792                 // check if value is to low
1793                 if (*((unsigned QWORD *)pData_p) <
1794                     *((unsigned QWORD *)pRangeData)) {
1795                         Ret = kEplObdValueTooLow;
1796                         break;
1797                 }
1798                 // switch to higher limit
1799                 pRangeData = ((unsigned QWORD *)pRangeData) + 1;
1800
1801                 // check if value is to high
1802                 if (*((unsigned QWORD *)pData_p) >
1803                     *((unsigned QWORD *)pRangeData)) {
1804                         Ret = kEplObdValueTooHigh;
1805                 }
1806
1807                 break;
1808
1809                 // -----------------------------------------------------------------
1810         case kEplObdTypReal64:
1811
1812                 // switch to lower limit
1813                 pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
1814
1815                 // check if value is to low
1816                 if (*((tEplObdReal64 *) pData_p) <
1817                     *((tEplObdReal64 *) pRangeData)) {
1818                         Ret = kEplObdValueTooLow;
1819                         break;
1820                 }
1821                 // switch to higher limit
1822                 pRangeData = ((tEplObdReal64 *) pRangeData) + 1;
1823
1824                 // check if value is to high
1825                 if (*((tEplObdReal64 *) pData_p) >
1826                     *((tEplObdReal64 *) pRangeData)) {
1827                         Ret = kEplObdValueTooHigh;
1828                 }
1829
1830                 break;
1831
1832                 // -----------------------------------------------------------------
1833         case kEplObdTypTimeOfDay:
1834         case kEplObdTypTimeDiff:
1835                 break;
1836
1837                 // -----------------------------------------------------------------
1838                 // ObdTypes kEplObdTypXString and kEplObdTypDomain can not be checkt because
1839                 // they have no numerical value.
1840         default:
1841
1842                 Ret = kEplObdUnknownObjectType;
1843                 break;
1844         }
1845
1846       Exit:
1847
1848         return Ret;
1849
1850 }
1851 #endif // (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
1852
1853 //---------------------------------------------------------------------------
1854 //
1855 // Function:    EplObdWriteEntryPre()
1856 //
1857 // Description: Function prepares write of data to an OBD entry. Strings
1858 //              are stored with added '\0' character.
1859 //
1860 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
1861 //              uiIndex_p       =   Index of the OD entry
1862 //              uiSubIndex_p    =   Subindex of the OD Entry
1863 //              pSrcData_p      =   Pointer to the data to write
1864 //              Size_p          =   Size of the data in Byte
1865 //
1866 // Return:      tEplKernel      =   Errorcode
1867 //
1868 //
1869 // State:
1870 //
1871 //---------------------------------------------------------------------------
1872
1873 static tEplKernel PUBLIC EplObdWriteEntryPre(EPL_MCO_DECL_INSTANCE_PTR_
1874                                              unsigned int uiIndex_p,
1875                                              unsigned int uiSubIndex_p,
1876                                              void *pSrcData_p,
1877                                              void **ppDstData_p,
1878                                              tEplObdSize Size_p,
1879                                              tEplObdEntryPtr * ppObdEntry_p,
1880                                              tEplObdSubEntryPtr * ppSubEntry_p,
1881                                              tEplObdCbParam MEM * pCbParam_p,
1882                                              tEplObdSize * pObdSize_p)
1883 {
1884
1885         tEplKernel Ret;
1886         tEplObdEntryPtr pObdEntry;
1887         tEplObdSubEntryPtr pSubEntry;
1888         tEplObdAccess Access;
1889         void MEM *pDstData;
1890         tEplObdSize ObdSize;
1891         BOOL fEntryNumerical;
1892
1893 #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1894         tEplObdVStringDomain MEM MemVStringDomain;
1895         void MEM *pCurrData;
1896 #endif
1897
1898         // check for all API function if instance is valid
1899         EPL_MCO_CHECK_INSTANCE_STATE();
1900
1901         ASSERT(pSrcData_p != NULL);     // should never be NULL
1902
1903         //------------------------------------------------------------------------
1904         // get address of index and subindex entry
1905         Ret = EplObdGetEntry(EPL_MCO_INSTANCE_PTR_
1906                              uiIndex_p, uiSubIndex_p, &pObdEntry, &pSubEntry);
1907         if (Ret != kEplSuccessful) {
1908                 goto Exit;
1909         }
1910         // get pointer to object data
1911         pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry);
1912
1913         Access = (tEplObdAccess) pSubEntry->m_Access;
1914
1915         // check access for write
1916         // access violation if adress to current value is NULL
1917         if (((Access & kEplObdAccConst) != 0) || (pDstData == NULL)) {
1918                 Ret = kEplObdAccessViolation;
1919                 goto Exit;
1920         }
1921         //------------------------------------------------------------------------
1922         // get size of object
1923         // -as ObdSize = ObdGetObjectSize (pSubEntry);
1924
1925         //------------------------------------------------------------------------
1926         // To use the same callback function for ObdWriteEntry as well as for
1927         // an SDO download call at first (kEplObdEvPre...) the callback function
1928         // with the argument pointer to object size.
1929         pCbParam_p->m_uiIndex = uiIndex_p;
1930         pCbParam_p->m_uiSubIndex = uiSubIndex_p;
1931
1932         // Because object size and object pointer are
1933         // adapted by user callback function, re-read
1934         // this values.
1935         ObdSize = EplObdGetObjectSize(pSubEntry);
1936         pDstData = (void MEM *)EplObdGetObjectDataPtrIntern(pSubEntry);
1937
1938         // 09-dec-2004 r.d.:
1939         //      Function EplObdWriteEntry() calls new event kEplObdEvWrStringDomain
1940         //      for String or Domain which lets called module directly change
1941         //      the data pointer or size. This prevents a recursive call to
1942         //      the callback function if it calls EplObdGetEntry().
1943 #if (EPL_OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1944         if ((pSubEntry->m_Type == kEplObdTypVString) ||
1945             (pSubEntry->m_Type == kEplObdTypDomain) ||
1946             (pSubEntry->m_Type == kEplObdTypOString)) {
1947                 if (pSubEntry->m_Type == kEplObdTypVString) {
1948                         // reserve one byte for 0-termination
1949                         // -as ObdSize -= 1;
1950                         Size_p += 1;
1951                 }
1952                 // fill out new arg-struct
1953                 MemVStringDomain.m_DownloadSize = Size_p;
1954                 MemVStringDomain.m_ObjSize = ObdSize;
1955                 MemVStringDomain.m_pData = pDstData;
1956
1957                 pCbParam_p->m_ObdEvent = kEplObdEvWrStringDomain;
1958                 pCbParam_p->m_pArg = &MemVStringDomain;
1959                 //  call user callback
1960                 Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1961                                                pObdEntry->m_fpCallback,
1962                                                pCbParam_p);
1963                 if (Ret != kEplSuccessful) {
1964                         goto Exit;
1965                 }
1966                 // write back new settings
1967                 pCurrData = pSubEntry->m_pCurrent;
1968                 if ((pSubEntry->m_Type == kEplObdTypVString)
1969                     || (pSubEntry->m_Type == kEplObdTypOString)) {
1970                         ((tEplObdVString MEM *) pCurrData)->m_Size =
1971                             MemVStringDomain.m_ObjSize;
1972                         ((tEplObdVString MEM *) pCurrData)->m_pString =
1973                             MemVStringDomain.m_pData;
1974                 } else          // if (pSdosTableEntry_p->m_bObjType == kEplObdTypDomain)
1975                 {
1976                         ((tEplObdVarEntry MEM *) pCurrData)->m_Size =
1977                             MemVStringDomain.m_ObjSize;
1978                         ((tEplObdVarEntry MEM *) pCurrData)->m_pData =
1979                             (void MEM *)MemVStringDomain.m_pData;
1980                 }
1981
1982                 // Because object size and object pointer are
1983                 // adapted by user callback function, re-read
1984                 // this values.
1985                 ObdSize = MemVStringDomain.m_ObjSize;
1986                 pDstData = (void MEM *)MemVStringDomain.m_pData;
1987         }
1988 #endif //#if (OBD_USE_STRING_DOMAIN_IN_RAM != FALSE)
1989
1990         // 07-dec-2004 r.d.: size from application is needed because callback function can change the object size
1991         // -as 16.11.04 CbParam.m_pArg     = &ObdSize;
1992         // 09-dec-2004 r.d.: CbParam.m_pArg     = &Size_p;
1993         pCbParam_p->m_pArg = &ObdSize;
1994         pCbParam_p->m_ObdEvent = kEplObdEvInitWrite;
1995         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
1996                                        pObdEntry->m_fpCallback, pCbParam_p);
1997         if (Ret != kEplSuccessful) {
1998                 goto Exit;
1999         }
2000
2001         if (Size_p > ObdSize) {
2002                 Ret = kEplObdValueLengthError;
2003                 goto Exit;
2004         }
2005
2006         if (pSubEntry->m_Type == kEplObdTypVString) {
2007                 if (((char MEM *)pSrcData_p)[Size_p - 1] == '\0') {     // last byte of source string contains null character
2008
2009                         // reserve one byte in destination for 0-termination
2010                         Size_p -= 1;
2011                 } else if (Size_p >= ObdSize) { // source string is not 0-terminated
2012                         // and destination buffer is too short
2013                         Ret = kEplObdValueLengthError;
2014                         goto Exit;
2015                 }
2016         }
2017
2018         Ret = EplObdIsNumericalIntern(pSubEntry, &fEntryNumerical);
2019         if (Ret != kEplSuccessful) {
2020                 goto Exit;
2021         }
2022
2023         if ((fEntryNumerical != FALSE)
2024             && (Size_p != ObdSize)) {
2025                 // type is numerical, therefor size has to fit, but it does not.
2026                 Ret = kEplObdValueLengthError;
2027                 goto Exit;
2028         }
2029         // use given size, because non-numerical objects can be written with shorter values
2030         ObdSize = Size_p;
2031
2032         // set output parameters
2033         *pObdSize_p = ObdSize;
2034         *ppObdEntry_p = pObdEntry;
2035         *ppSubEntry_p = pSubEntry;
2036         *ppDstData_p = pDstData;
2037
2038         // all checks are done
2039         // the caller may now convert the numerial source value to platform byte order in a temporary buffer
2040
2041       Exit:
2042
2043         return Ret;
2044
2045 }
2046
2047 //---------------------------------------------------------------------------
2048 //
2049 // Function:    EplObdWriteEntryPost()
2050 //
2051 // Description: Function finishes write of data to an OBD entry. Strings
2052 //              are stored with added '\0' character.
2053 //
2054 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_
2055 //              uiIndex_p       =   Index of the OD entry
2056 //              uiSubIndex_p    =   Subindex of the OD Entry
2057 //              pSrcData_p      =   Pointer to the data to write
2058 //              Size_p          =   Size of the data in Byte
2059 //
2060 // Return:      tEplKernel      =   Errorcode
2061 //
2062 //
2063 // State:
2064 //
2065 //---------------------------------------------------------------------------
2066
2067 static tEplKernel PUBLIC EplObdWriteEntryPost(EPL_MCO_DECL_INSTANCE_PTR_
2068                                               tEplObdEntryPtr pObdEntry_p,
2069                                               tEplObdSubEntryPtr pSubEntry_p,
2070                                               tEplObdCbParam MEM * pCbParam_p,
2071                                               void *pSrcData_p,
2072                                               void *pDstData_p,
2073                                               tEplObdSize ObdSize_p)
2074 {
2075
2076         tEplKernel Ret;
2077
2078         // caller converted the source value to platform byte order
2079         // now the range of the value may be checked
2080
2081 #if (EPL_OBD_CHECK_OBJECT_RANGE != FALSE)
2082         {
2083                 // check data range
2084                 Ret = EplObdCheckObjectRange(pSubEntry_p, pSrcData_p);
2085                 if (Ret != kEplSuccessful) {
2086                         goto Exit;
2087                 }
2088         }
2089 #endif
2090
2091         // now call user callback function to check value
2092         // write address of source data to structure of callback parameters
2093         // so callback function can check this data
2094         pCbParam_p->m_pArg = pSrcData_p;
2095         pCbParam_p->m_ObdEvent = kEplObdEvPreWrite;
2096         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2097                                        pObdEntry_p->m_fpCallback, pCbParam_p);
2098         if (Ret != kEplSuccessful) {
2099                 goto Exit;
2100         }
2101         // copy object data to OBD
2102         EPL_MEMCPY(pDstData_p, pSrcData_p, ObdSize_p);
2103
2104         // terminate string with 0
2105         if (pSubEntry_p->m_Type == kEplObdTypVString) {
2106                 ((char MEM *)pDstData_p)[ObdSize_p] = '\0';
2107         }
2108         // write address of destination to structure of callback parameters
2109         // so callback function can change data subsequently
2110         pCbParam_p->m_pArg = pDstData_p;
2111         pCbParam_p->m_ObdEvent = kEplObdEvPostWrite;
2112         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2113                                        pObdEntry_p->m_fpCallback, pCbParam_p);
2114
2115       Exit:
2116
2117         return Ret;
2118
2119 }
2120
2121 //---------------------------------------------------------------------------
2122 //
2123 // Function:    EplObdGetObjectSize()
2124 //
2125 // Description: function to get size of object
2126 //              The function determines if an object type an fixed data type (BYTE, WORD, ...)
2127 //              or non fixed object (string, domain). This information is used to decide
2128 //              if download data are stored temporary or not. For objects with fixed data length
2129 //              and types a value range checking can process.
2130 //              For strings the function returns the whole object size not the
2131 //              length of string.
2132 //
2133 // Parameters:  pSubIndexEntry_p
2134 //
2135 // Return:      tEplObdSize
2136 //
2137 // State:
2138 //
2139 //---------------------------------------------------------------------------
2140
2141 static tEplObdSize EplObdGetObjectSize(tEplObdSubEntryPtr pSubIndexEntry_p)
2142 {
2143
2144         tEplObdSize DataSize = 0;
2145         void *pData;
2146
2147         switch (pSubIndexEntry_p->m_Type) {
2148                 // -----------------------------------------------------------------
2149         case kEplObdTypBool:
2150
2151                 DataSize = 1;
2152                 break;
2153
2154                 // -----------------------------------------------------------------
2155                 // ObdTypes which has to be check because numerical values
2156         case kEplObdTypInt8:
2157                 DataSize = sizeof(tEplObdInteger8);
2158                 break;
2159
2160                 // -----------------------------------------------------------------
2161         case kEplObdTypUInt8:
2162                 DataSize = sizeof(tEplObdUnsigned8);
2163                 break;
2164
2165                 // -----------------------------------------------------------------
2166         case kEplObdTypInt16:
2167                 DataSize = sizeof(tEplObdInteger16);
2168                 break;
2169
2170                 // -----------------------------------------------------------------
2171         case kEplObdTypUInt16:
2172                 DataSize = sizeof(tEplObdUnsigned16);
2173                 break;
2174
2175                 // -----------------------------------------------------------------
2176         case kEplObdTypInt32:
2177                 DataSize = sizeof(tEplObdInteger32);
2178                 break;
2179
2180                 // -----------------------------------------------------------------
2181         case kEplObdTypUInt32:
2182                 DataSize = sizeof(tEplObdUnsigned32);
2183                 break;
2184
2185                 // -----------------------------------------------------------------
2186         case kEplObdTypReal32:
2187                 DataSize = sizeof(tEplObdReal32);
2188                 break;
2189
2190                 // -----------------------------------------------------------------
2191                 // ObdTypes which has to be not checked because not NUM values
2192         case kEplObdTypDomain:
2193
2194                 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2195                 if ((void MEM *)pData != (void MEM *)NULL) {
2196                         DataSize = ((tEplObdVarEntry MEM *) pData)->m_Size;
2197                 }
2198                 break;
2199
2200                 // -----------------------------------------------------------------
2201         case kEplObdTypVString:
2202                 //case kEplObdTypUString:
2203
2204                 // If OD entry is defined by macro EPL_OBD_SUBINDEX_ROM_VSTRING
2205                 // then the current pointer is always NULL. The function
2206                 // returns the length of default string.
2207                 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2208                 if ((void MEM *)pData != (void MEM *)NULL) {
2209                         // The max. size of strings defined by STRING-Macro is stored in
2210                         // tEplObdVString of current value.
2211                         // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
2212                         DataSize = ((tEplObdVString MEM *) pData)->m_Size;
2213                 } else {
2214                         // The current position is not decleared. The string
2215                         // is located in ROM, therefor use default pointer.
2216                         pData = (void *)pSubIndexEntry_p->m_pDefault;
2217                         if ((CONST void ROM *)pData != (CONST void ROM *)NULL) {
2218                                 // The max. size of strings defined by STRING-Macro is stored in
2219                                 // tEplObdVString of default value.
2220                                 DataSize =
2221                                     ((CONST tEplObdVString ROM *) pData)->
2222                                     m_Size;
2223                         }
2224                 }
2225
2226                 break;
2227
2228                 // -----------------------------------------------------------------
2229         case kEplObdTypOString:
2230
2231                 pData = (void *)pSubIndexEntry_p->m_pCurrent;
2232                 if ((void MEM *)pData != (void MEM *)NULL) {
2233                         // The max. size of strings defined by STRING-Macro is stored in
2234                         // tEplObdVString of current value.
2235                         // (types tEplObdVString, tEplObdOString and tEplObdUString has the same members)
2236                         DataSize = ((tEplObdOString MEM *) pData)->m_Size;
2237                 } else {
2238                         // The current position is not decleared. The string
2239                         // is located in ROM, therefor use default pointer.
2240                         pData = (void *)pSubIndexEntry_p->m_pDefault;
2241                         if ((CONST void ROM *)pData != (CONST void ROM *)NULL) {
2242                                 // The max. size of strings defined by STRING-Macro is stored in
2243                                 // tEplObdVString of default value.
2244                                 DataSize =
2245                                     ((CONST tEplObdOString ROM *) pData)->
2246                                     m_Size;
2247                         }
2248                 }
2249                 break;
2250
2251                 // -----------------------------------------------------------------
2252         case kEplObdTypInt24:
2253         case kEplObdTypUInt24:
2254
2255                 DataSize = 3;
2256                 break;
2257
2258                 // -----------------------------------------------------------------
2259         case kEplObdTypInt40:
2260         case kEplObdTypUInt40:
2261
2262                 DataSize = 5;
2263                 break;
2264
2265                 // -----------------------------------------------------------------
2266         case kEplObdTypInt48:
2267         case kEplObdTypUInt48:
2268
2269                 DataSize = 6;
2270                 break;
2271
2272                 // -----------------------------------------------------------------
2273         case kEplObdTypInt56:
2274         case kEplObdTypUInt56:
2275
2276                 DataSize = 7;
2277                 break;
2278
2279                 // -----------------------------------------------------------------
2280         case kEplObdTypInt64:
2281         case kEplObdTypUInt64:
2282         case kEplObdTypReal64:
2283
2284                 DataSize = 8;
2285                 break;
2286
2287                 // -----------------------------------------------------------------
2288         case kEplObdTypTimeOfDay:
2289         case kEplObdTypTimeDiff:
2290
2291                 DataSize = 6;
2292                 break;
2293
2294                 // -----------------------------------------------------------------
2295         default:
2296                 break;
2297         }
2298
2299         return DataSize;
2300 }
2301
2302 //---------------------------------------------------------------------------
2303 //
2304 // Function:    EplObdGetObjectDefaultPtr()
2305 //
2306 // Description: function to get the default pointer (type specific)
2307 //
2308 // Parameters:  pSubIndexEntry_p    = pointer to subindex structure
2309 //
2310 // Returns:     (void *)   = pointer to default value
2311 //
2312 // State:
2313 //
2314 //---------------------------------------------------------------------------
2315
2316 static void *EplObdGetObjectDefaultPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
2317 {
2318
2319         void *pDefault;
2320         tEplObdType Type;
2321
2322         ASSERTMSG(pSubIndexEntry_p != NULL,
2323                   "EplObdGetObjectDefaultPtr(): pointer to SubEntry not valid!\n");
2324
2325         // get address to default data from default pointer
2326         pDefault = pSubIndexEntry_p->m_pDefault;
2327         if (pDefault != NULL) {
2328                 // there are some special types, whose default pointer always is NULL or has to get from other structure
2329                 // get type from subindex structure
2330                 Type = pSubIndexEntry_p->m_Type;
2331
2332                 // check if object type is a string value
2333                 if ((Type == kEplObdTypVString) /* ||
2334                                                    (Type == kEplObdTypUString) */ ) {
2335
2336                         // EPL_OBD_SUBINDEX_RAM_VSTRING
2337                         //    tEplObdSize         m_Size;       --> size of default string
2338                         //    char *    m_pDefString; --> pointer to  default string
2339                         //    char *    m_pString;    --> pointer to string in RAM
2340                         //
2341                         pDefault =
2342                             (void *)((tEplObdVString *) pDefault)->m_pString;
2343                 } else if (Type == kEplObdTypOString) {
2344                         pDefault =
2345                             (void *)((tEplObdOString *) pDefault)->m_pString;
2346                 }
2347         }
2348
2349         return pDefault;
2350
2351 }
2352
2353 //---------------------------------------------------------------------------
2354 //
2355 // Function:    EplObdGetVarEntry()
2356 //
2357 // Description: gets a variable entry of an object
2358 //
2359 // Parameters:  pSubindexEntry_p
2360 //              ppVarEntry_p
2361 //
2362 // Return:      tCopKernel
2363 //
2364 // State:
2365 //
2366 //---------------------------------------------------------------------------
2367
2368 static tEplKernel EplObdGetVarEntry(tEplObdSubEntryPtr pSubindexEntry_p,
2369                                     tEplObdVarEntry MEM ** ppVarEntry_p)
2370 {
2371
2372         tEplKernel Ret = kEplObdVarEntryNotExist;
2373
2374         ASSERT(ppVarEntry_p != NULL);   // is not allowed to be NULL
2375         ASSERT(pSubindexEntry_p != NULL);
2376
2377         // check VAR-Flag - only this object points to variables
2378         if ((pSubindexEntry_p->m_Access & kEplObdAccVar) != 0) {
2379                 // check if object is an array
2380                 if ((pSubindexEntry_p->m_Access & kEplObdAccArray) != 0) {
2381                         *ppVarEntry_p =
2382                             &((tEplObdVarEntry MEM *) pSubindexEntry_p->
2383                               m_pCurrent)[pSubindexEntry_p->m_uiSubIndex - 1];
2384                 } else {
2385                         *ppVarEntry_p =
2386                             (tEplObdVarEntry MEM *) pSubindexEntry_p->
2387                             m_pCurrent;
2388                 }
2389
2390                 Ret = kEplSuccessful;
2391         }
2392
2393         return Ret;
2394
2395 }
2396
2397 //---------------------------------------------------------------------------
2398 //
2399 // Function:    EplObdGetEntry()
2400 //
2401 // Description: gets a index entry from OD
2402 //
2403 // Parameters:  uiIndex_p       =   Index number
2404 //              uiSubindex_p    =   Subindex number
2405 //              ppObdEntry_p    =   pointer to the pointer to the entry
2406 //              ppObdSubEntry_p =   pointer to the pointer to the subentry
2407 //
2408 // Return:      tEplKernel
2409
2410 //
2411 // State:
2412 //
2413 //---------------------------------------------------------------------------
2414
2415 static tEplKernel EplObdGetEntry(EPL_MCO_DECL_INSTANCE_PTR_
2416                                  unsigned int uiIndex_p,
2417                                  unsigned int uiSubindex_p,
2418                                  tEplObdEntryPtr * ppObdEntry_p,
2419                                  tEplObdSubEntryPtr * ppObdSubEntry_p)
2420 {
2421
2422         tEplObdEntryPtr pObdEntry;
2423         tEplObdCbParam MEM CbParam;
2424         tEplKernel Ret;
2425
2426         // check for all API function if instance is valid
2427         EPL_MCO_CHECK_INSTANCE_STATE();
2428
2429         //------------------------------------------------------------------------
2430         // get address of entry of index
2431         Ret =
2432             EplObdGetIndexIntern(&EPL_MCO_GLB_VAR(m_ObdInitParam), uiIndex_p,
2433                                  &pObdEntry);
2434         if (Ret != kEplSuccessful) {
2435                 goto Exit;
2436         }
2437         //------------------------------------------------------------------------
2438         // get address of entry of subindex
2439         Ret = EplObdGetSubindexIntern(pObdEntry, uiSubindex_p, ppObdSubEntry_p);
2440         if (Ret != kEplSuccessful) {
2441                 goto Exit;
2442         }
2443         //------------------------------------------------------------------------
2444         // call callback function to inform user/stack that an object will be searched
2445         // if the called module returnes an error then we abort the searching with kEplObdIndexNotExist
2446         CbParam.m_uiIndex = uiIndex_p;
2447         CbParam.m_uiSubIndex = uiSubindex_p;
2448         CbParam.m_pArg = NULL;
2449         CbParam.m_ObdEvent = kEplObdEvCheckExist;
2450         Ret = EplObdCallObjectCallback(EPL_MCO_INSTANCE_PTR_
2451                                        pObdEntry->m_fpCallback, &CbParam);
2452         if (Ret != kEplSuccessful) {
2453                 Ret = kEplObdIndexNotExist;
2454                 goto Exit;
2455         }
2456         //------------------------------------------------------------------------
2457         // it is allowed to set ppObdEntry_p to NULL
2458         // if so, no address will be written to calling function
2459         if (ppObdEntry_p != NULL) {
2460                 *ppObdEntry_p = pObdEntry;
2461         }
2462
2463       Exit:
2464
2465         return Ret;
2466
2467 }
2468
2469 //---------------------------------------------------------------------------
2470 //
2471 // Function:    EplObdGetObjectCurrentPtr()
2472 //
2473 // Description: function to get Current pointer (type specific)
2474 //
2475 // Parameters:  pSubIndexEntry_p
2476 //
2477 // Return:      void MEM*
2478 //
2479 // State:
2480 //
2481 //---------------------------------------------------------------------------
2482
2483 static void MEM *EplObdGetObjectCurrentPtr(tEplObdSubEntryPtr pSubIndexEntry_p)
2484 {
2485
2486         void MEM *pData;
2487         unsigned int uiArrayIndex;
2488         tEplObdSize Size;
2489
2490         pData = pSubIndexEntry_p->m_pCurrent;
2491
2492         // check if constant object
2493         if (pData != NULL) {
2494                 // check if object is an array
2495                 if ((pSubIndexEntry_p->m_Access & kEplObdAccArray) != 0) {
2496                         // calculate correct data pointer
2497                         uiArrayIndex = pSubIndexEntry_p->m_uiSubIndex - 1;
2498                         if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
2499                                 Size = sizeof(tEplObdVarEntry);
2500                         } else {
2501                                 Size = EplObdGetObjectSize(pSubIndexEntry_p);
2502                         }
2503                         pData = ((BYTE MEM *) pData) + (Size * uiArrayIndex);
2504                 }
2505                 // check if VarEntry
2506                 if ((pSubIndexEntry_p->m_Access & kEplObdAccVar) != 0) {
2507                         // The data pointer is stored in VarEntry->pData
2508                         pData = ((tEplObdVarEntry MEM *) pData)->m_pData;
2509                 }
2510                 // the default pointer is stored for strings in tEplObdVString
2511                 else if ((pSubIndexEntry_p->m_Type == kEplObdTypVString)        /* ||
2512                                                                                    (pSubIndexEntry_p->m_Type == kEplObdTypUString)    */
2513                          ) {
2514                         pData =
2515                             (void MEM *)((tEplObdVString MEM *) pData)->
2516                             m_pString;
2517                 } else if (pSubIndexEntry_p->m_Type == kEplObdTypOString) {
2518                         pData =
2519                             (void MEM *)((tEplObdOString MEM *) pData)->
2520                             m_pString;
2521                 }
2522         }
2523
2524         return pData;
2525
2526 }
2527
2528 //---------------------------------------------------------------------------
2529 //
2530 // Function:    EplObdGetIndexIntern()
2531 //
2532 // Description: gets a index entry from OD
2533 //
2534 // Parameters:  pInitParam_p
2535 //              uiIndex_p
2536 //              ppObdEntry_p
2537 //
2538 // Return:      tEplKernel
2539 //
2540 // State:
2541 //
2542 //---------------------------------------------------------------------------
2543
2544 static tEplKernel EplObdGetIndexIntern(tEplObdInitParam MEM * pInitParam_p,
2545                                        unsigned int uiIndex_p,
2546                                        tEplObdEntryPtr * ppObdEntry_p)
2547 {
2548
2549         tEplObdEntryPtr pObdEntry;
2550         tEplKernel Ret;
2551         unsigned int uiIndex;
2552
2553 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2554
2555         unsigned int nLoop;
2556
2557         // if user OD is used then objekts also has to be searched in user OD
2558         // there is less code need if we do this in a loop
2559         nLoop = 2;
2560
2561 #endif
2562
2563         ASSERTMSG(ppObdEntry_p != NULL,
2564                   "EplObdGetIndexIntern(): pointer to index entry is NULL!\n");
2565
2566         Ret = kEplObdIndexNotExist;
2567
2568         // get start address of OD part
2569         // start address depends on object index because
2570         // object dictionary is divided in 3 parts
2571         if ((uiIndex_p >= 0x1000) && (uiIndex_p < 0x2000)) {
2572                 pObdEntry = pInitParam_p->m_pPart;
2573         } else if ((uiIndex_p >= 0x2000) && (uiIndex_p < 0x6000)) {
2574                 pObdEntry = pInitParam_p->m_pManufacturerPart;
2575         }
2576         // index range 0xA000 to 0xFFFF is reserved for DSP-405
2577         // DS-301 defines that range 0x6000 to 0x9FFF (!!!) is stored if "store" was written to 0x1010/3.
2578         // Therefore default configuration is OBD_INCLUDE_A000_TO_DEVICE_PART = FALSE.
2579         // But a CANopen Application which does not implement dynamic OD or user-OD but wants to use static objets 0xA000...
2580         // should set OBD_INCLUDE_A000_TO_DEVICE_PART to TRUE.
2581
2582 #if (EPL_OBD_INCLUDE_A000_TO_DEVICE_PART == FALSE)
2583         else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0x9FFF))
2584 #else
2585         else if ((uiIndex_p >= 0x6000) && (uiIndex_p < 0xFFFF))
2586 #endif
2587         {
2588                 pObdEntry = pInitParam_p->m_pDevicePart;
2589         }
2590
2591 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2592
2593         // if index does not match in static OD then index only has to be searched in user OD
2594         else {
2595                 // begin from first entry of user OD part
2596                 pObdEntry = pInitParam_p->m_pUserPart;
2597
2598                 // no user OD is available
2599                 if (pObdEntry == NULL) {
2600                         goto Exit;
2601                 }
2602                 // loop must only run once
2603                 nLoop = 1;
2604         }
2605
2606         do {
2607
2608 #else
2609
2610         // no user OD is available
2611         // so other object can be found in OD
2612         else {
2613                 Ret = kEplObdIllegalPart;
2614                 goto Exit;
2615         }
2616
2617 #endif
2618
2619         // note:
2620         // The end of Index table is marked with m_uiIndex = 0xFFFF.
2621         // If this function will be called with wIndex_p = 0xFFFF, entry
2622         // should not be found. Therefor it is important to use
2623         // while{} instead of do{}while !!!
2624
2625         // get first index of index table
2626         uiIndex = pObdEntry->m_uiIndex;
2627
2628         // search Index in OD part
2629         while (uiIndex != EPL_OBD_TABLE_INDEX_END) {
2630                 // go to the end of this function if index is found
2631                 if (uiIndex_p == uiIndex) {
2632                         // write address of OD entry to calling function
2633                         *ppObdEntry_p = pObdEntry;
2634                         Ret = kEplSuccessful;
2635                         goto Exit;
2636                 }
2637                 // objects are sorted in OD
2638                 // if the current index in OD is greater than the index which is to search then break loop
2639                 // in this case user OD has to be search too
2640                 if (uiIndex_p < uiIndex) {
2641                         break;
2642                 }
2643                 // next entry in index table
2644                 pObdEntry++;
2645
2646                 // get next index of index table
2647                 uiIndex = pObdEntry->m_uiIndex;
2648         }
2649
2650 #if (defined (EPL_OBD_USER_OD) && (EPL_OBD_USER_OD != FALSE))
2651
2652         // begin from first entry of user OD part
2653         pObdEntry = pInitParam_p->m_pUserPart;
2654
2655         // no user OD is available
2656         if (pObdEntry == NULL) {
2657                 goto Exit;
2658         }
2659         // switch next loop for user OD
2660         nLoop--;
2661
2662 }
2663
2664 while (nLoop > 0) ;
2665
2666 #endif
2667
2668     // in this line Index was not found
2669
2670 Exit:
2671
2672 return Ret;
2673
2674 }
2675
2676 //---------------------------------------------------------------------------
2677 //
2678 // Function:    EplObdGetSubindexIntern()
2679 //
2680 // Description: gets a subindex entry from a index entry
2681 //
2682 // Parameters:  pObdEntry_p
2683 //              bSubIndex_p
2684 //              ppObdSubEntry_p
2685 //
2686 // Return:      tEplKernel
2687 //
2688 // State:
2689 //
2690 //---------------------------------------------------------------------------
2691
2692 static tEplKernel EplObdGetSubindexIntern(tEplObdEntryPtr pObdEntry_p,
2693                                           unsigned int uiSubIndex_p,
2694                                           tEplObdSubEntryPtr * ppObdSubEntry_p)
2695 {
2696
2697         tEplObdSubEntryPtr pSubEntry;
2698         unsigned int nSubIndexCount;
2699         tEplKernel Ret;
2700
2701         ASSERTMSG(pObdEntry_p != NULL,
2702                   "EplObdGetSubindexIntern(): pointer to index is NULL!\n");
2703         ASSERTMSG(ppObdSubEntry_p != NULL,
2704                   "EplObdGetSubindexIntern(): pointer to subindex is NULL!\n");
2705
2706         Ret = kEplObdSubindexNotExist;
2707
2708         // get start address of subindex table and count of subindices
2709         pSubEntry = pObdEntry_p->m_pSubIndex;
2710         nSubIndexCount = pObdEntry_p->m_uiCount;
2711         ASSERTMSG((pSubEntry != NULL) && (nSubIndexCount > 0), "ObdGetSubindexIntern(): invalid subindex table within index table!\n"); // should never be NULL
2712
2713         // search subindex in subindex table
2714         while (nSubIndexCount > 0) {
2715                 // check if array is found
2716                 if ((pSubEntry->m_Access & kEplObdAccArray) != 0) {
2717                         // check if subindex is in range
2718                         if (uiSubIndex_p < pObdEntry_p->m_uiCount) {
2719                                 // update subindex number (subindex entry of an array is always in RAM !!!)
2720                                 pSubEntry->m_uiSubIndex = uiSubIndex_p;
2721                                 *ppObdSubEntry_p = pSubEntry;
2722                                 Ret = kEplSuccessful;
2723                                 goto Exit;
2724                         }
2725                 }
2726                 // go to the end of this function if subindex is found
2727                 else if (uiSubIndex_p == pSubEntry->m_uiSubIndex) {
2728                         *ppObdSubEntry_p = pSubEntry;
2729                         Ret = kEplSuccessful;
2730                         goto Exit;
2731                 }
2732                 // objects are sorted in OD
2733                 // if the current subindex in OD is greater than the subindex which is to search then break loop
2734                 // in this case user OD has to be search too
2735                 if (uiSubIndex_p < pSubEntry->m_uiSubIndex) {
2736                         break;
2737                 }
2738
2739                 pSubEntry++;
2740                 nSubIndexCount--;
2741         }
2742
2743         // in this line SubIndex was not fount
2744
2745       Exit:
2746
2747         return Ret;
2748
2749 }
2750
2751 //---------------------------------------------------------------------------
2752 //
2753 // Function:    EplObdSetStoreLoadObjCallback()
2754 //
2755 // Description: function set address to callbackfunction for command Store and Load
2756 //
2757 // Parameters:  fpCallback_p
2758 //
2759 // Return:      tEplKernel
2760 //
2761 // State:
2762 //
2763 //---------------------------------------------------------------------------
2764 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
2765 EPLDLLEXPORT tEplKernel PUBLIC
2766 EplObdSetStoreLoadObjCallback(EPL_MCO_DECL_INSTANCE_PTR_
2767                               tEplObdStoreLoadObjCallback fpCallback_p)
2768 {
2769
2770         EPL_MCO_CHECK_INSTANCE_STATE();
2771
2772         // set new address of callback function
2773         EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) = fpCallback_p;
2774
2775         return kEplSuccessful;
2776
2777 }
2778 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
2779
2780 //---------------------------------------------------------------------------
2781 //
2782 // Function:    EplObdAccessOdPartIntern()
2783 //
2784 // Description: runs through OD and executes a job
2785 //
2786 // Parameters:  CurrentOdPart_p
2787 //              pObdEnty_p
2788 //              Direction_p     = what is to do (load values from flash or EEPROM, store, ...)
2789 //
2790 // Return:      tEplKernel
2791 //
2792 // State:
2793 //
2794 //---------------------------------------------------------------------------
2795
2796 static tEplKernel EplObdAccessOdPartIntern(EPL_MCO_DECL_INSTANCE_PTR_
2797                                            tEplObdPart CurrentOdPart_p,
2798                                            tEplObdEntryPtr pObdEnty_p,
2799                                            tEplObdDir Direction_p)
2800 {
2801
2802         tEplObdSubEntryPtr pSubIndex;
2803         unsigned int nSubIndexCount;
2804         tEplObdAccess Access;
2805         void MEM *pDstData;
2806         void *pDefault;
2807         tEplObdSize ObjSize;
2808         tEplKernel Ret;
2809         tEplObdCbStoreParam MEM CbStore;
2810         tEplObdVarEntry MEM *pVarEntry;
2811
2812         ASSERT(pObdEnty_p != NULL);
2813
2814         Ret = kEplSuccessful;
2815
2816         // prepare structure for STORE RESTORE callback function
2817         CbStore.m_bCurrentOdPart = (BYTE) CurrentOdPart_p;
2818         CbStore.m_pData = NULL;
2819         CbStore.m_ObjSize = 0;
2820
2821         // command of first action depends on direction to access
2822 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
2823         if (Direction_p == kEplObdDirLoad) {
2824                 CbStore.m_bCommand = (BYTE) kEplObdCommOpenRead;
2825
2826                 // call callback function for previous command
2827                 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
2828                 if (Ret != kEplSuccessful) {
2829                         goto Exit;
2830                 }
2831                 // set command for index and subindex loop
2832                 CbStore.m_bCommand = (BYTE) kEplObdCommReadObj;
2833         } else if (Direction_p == kEplObdDirStore) {
2834                 CbStore.m_bCommand = (BYTE) kEplObdCommOpenWrite;
2835
2836                 // call callback function for previous command
2837                 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
2838                 if (Ret != kEplSuccessful) {
2839                         goto Exit;
2840                 }
2841                 // set command for index and subindex loop
2842                 CbStore.m_bCommand = (BYTE) kEplObdCommWriteObj;
2843         }
2844 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
2845
2846         // we should not restore the OD values here
2847         // the next NMT command "Reset Node" or "Reset Communication" resets the OD data
2848         if (Direction_p != kEplObdDirRestore) {
2849                 // walk through OD part till end is found
2850                 while (pObdEnty_p->m_uiIndex != EPL_OBD_TABLE_INDEX_END) {
2851                         // get address to subindex table and count of subindices
2852                         pSubIndex = pObdEnty_p->m_pSubIndex;
2853                         nSubIndexCount = pObdEnty_p->m_uiCount;
2854                         ASSERT((pSubIndex != NULL) && (nSubIndexCount > 0));    // should never be NULL
2855
2856                         // walk through subindex table till all subinices were restored
2857                         while (nSubIndexCount != 0) {
2858                                 Access = (tEplObdAccess) pSubIndex->m_Access;
2859
2860                                 // get pointer to current and default data
2861                                 pDefault = EplObdGetObjectDefaultPtr(pSubIndex);
2862                                 pDstData = EplObdGetObjectCurrentPtr(pSubIndex);
2863
2864                                 // NOTE (for kEplObdTypVString):
2865                                 //      The function returnes the max. number of bytes for a
2866                                 //      current string.
2867                                 //      r.d.: For stings the default-size will be read in other lines following (kEplObdDirInit).
2868                                 ObjSize = EplObdGetObjectSize(pSubIndex);
2869
2870                                 // switch direction of OD access
2871                                 switch (Direction_p) {
2872                                         // --------------------------------------------------------------------------
2873                                         // VarEntry structures has to be initialized
2874                                 case kEplObdDirInit:
2875
2876                                         // If VAR-Flag is set, m_pCurrent means not address of data
2877                                         // but address of tEplObdVarEntry. Address of data has to be get from
2878                                         // this structure.
2879                                         if ((Access & kEplObdAccVar) != 0) {
2880                                                 EplObdGetVarEntry(pSubIndex,
2881                                                                   &pVarEntry);
2882                                                 EplObdInitVarEntry(pVarEntry,
2883                                                                    pSubIndex->
2884                                                                    m_Type,
2885                                                                    ObjSize);
2886 /*
2887                             if ((Access & kEplObdAccArray) == 0)
2888                             {
2889                                 EplObdInitVarEntry (pSubIndex->m_pCurrent, pSubIndex->m_Type, ObjSize);
2890                             }
2891                             else
2892                             {
2893                                 EplObdInitVarEntry ((tEplObdVarEntry MEM*) (((BYTE MEM*) pSubIndex->m_pCurrent) + (sizeof (tEplObdVarEntry) * pSubIndex->m_uiSubIndex)),
2894                                     pSubIndex->m_Type, ObjSize);
2895                             }
2896 */
2897                                                 // at this time no application variable is defined !!!
2898                                                 // therefore data can not be copied.
2899                                                 break;
2900                                         } else if (pSubIndex->m_Type ==
2901                                                    kEplObdTypVString) {
2902                                                 // If pointer m_pCurrent is not equal to NULL then the
2903                                                 // string was defined with EPL_OBD_SUBINDEX_RAM_VSTRING. The current
2904                                                 // pointer points to struct tEplObdVString located in MEM.
2905                                                 // The element size includes the max. number of
2906                                                 // bytes. The element m_pString includes the pointer
2907                                                 // to string in MEM. The memory location of default string
2908                                                 // must be copied to memory location of current string.
2909
2910                                                 pDstData =
2911                                                     pSubIndex->m_pCurrent;
2912                                                 if (pDstData != NULL) {
2913                                                         // 08-dec-2004: code optimization !!!
2914                                                         //              entries ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_pString
2915                                                         //              and ((tEplObdVStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
2916                                                         //              twice. thats not necessary!
2917
2918                                                         // For copying data we have to set the destination pointer to the real RAM string. This
2919                                                         // pointer to RAM string is located in default string info structure. (translated r.d.)
2920                                                         pDstData =
2921                                                             (void MEM
2922                                                              *)((tEplObdVStringDef ROM *) pSubIndex->m_pDefault)->m_pString;
2923                                                         ObjSize =
2924                                                             ((tEplObdVStringDef
2925                                                               ROM *) pSubIndex->
2926                                                              m_pDefault)->
2927                                                             m_Size;
2928
2929                                                         ((tEplObdVString MEM *)
2930                                                          pSubIndex->
2931                                                          m_pCurrent)->
2932                                      m_pString = pDstData;
2933                                                         ((tEplObdVString MEM *)
2934                                                          pSubIndex->
2935                                                          m_pCurrent)->m_Size =
2936                                      ObjSize;
2937                                                 }
2938
2939                                         } else if (pSubIndex->m_Type ==
2940                                                    kEplObdTypOString) {
2941                                                 pDstData =
2942                                                     pSubIndex->m_pCurrent;
2943                                                 if (pDstData != NULL) {
2944                                                         // 08-dec-2004: code optimization !!!
2945                                                         //              entries ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_pString
2946                                                         //              and ((tEplObdOStringDef ROM*) pSubIndex->m_pDefault)->m_Size were read
2947                                                         //              twice. thats not necessary!
2948
2949                                                         // For copying data we have to set the destination pointer to the real RAM string. This
2950                                                         // pointer to RAM string is located in default string info structure. (translated r.d.)
2951                                                         pDstData =
2952                                                             (void MEM
2953                                                              *)((tEplObdOStringDef ROM *) pSubIndex->m_pDefault)->m_pString;
2954                                                         ObjSize =
2955                                                             ((tEplObdOStringDef
2956                                                               ROM *) pSubIndex->
2957                                                              m_pDefault)->
2958                                                             m_Size;
2959
2960                                                         ((tEplObdOString MEM *)
2961                                                          pSubIndex->
2962                                                          m_pCurrent)->
2963                                      m_pString = pDstData;
2964                                                         ((tEplObdOString MEM *)
2965                                                          pSubIndex->
2966                                                          m_pCurrent)->m_Size =
2967                                      ObjSize;
2968                                                 }
2969
2970                                         }
2971
2972                                         // no break !! because copy of data has to done too.
2973
2974                                         // --------------------------------------------------------------------------
2975                                         // all objects has to be restored with default values
2976                                 case kEplObdDirRestore:
2977
2978                                         // 09-dec-2004 r.d.: optimization! the same code for kEplObdDirRestore and kEplObdDirLoad
2979                                         //                   is replaced to function ObdCopyObjectData() with a new parameter.
2980
2981                                         // restore object data for init phase
2982                                         EplObdCopyObjectData(pDstData, pDefault,
2983                                                              ObjSize,
2984                                                              pSubIndex->m_Type);
2985                                         break;
2986
2987                                         // --------------------------------------------------------------------------
2988                                         // objects with attribute kEplObdAccStore has to be load from EEPROM or from a file
2989                                 case kEplObdDirLoad:
2990
2991                                         // restore object data for init phase
2992                                         EplObdCopyObjectData(pDstData, pDefault,
2993                                                              ObjSize,
2994                                                              pSubIndex->m_Type);
2995
2996                                         // no break !! because callback function has to be called too.
2997
2998                                         // --------------------------------------------------------------------------
2999                                         // objects with attribute kEplObdAccStore has to be stored in EEPROM or in a file
3000                                 case kEplObdDirStore:
3001
3002                                         // when attribute kEplObdAccStore is set, then call callback function
3003 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
3004                                         if ((Access & kEplObdAccStore) != 0) {
3005                                                 // fill out data pointer and size of data
3006                                                 CbStore.m_pData = pDstData;
3007                                                 CbStore.m_ObjSize = ObjSize;
3008
3009                                                 // call callback function for read or write object
3010                                                 Ret =
3011                                                     ObdCallStoreCallback
3012                                                     (EPL_MCO_INSTANCE_PTR_ &
3013                                                      CbStore);
3014                                                 if (Ret != kEplSuccessful) {
3015                                                         goto Exit;
3016                                                 }
3017                                         }
3018 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
3019                                         break;
3020
3021                                         // --------------------------------------------------------------------------
3022                                         // if OD Builder key has to be checked no access to subindex and data should be made
3023                                 case kEplObdDirOBKCheck:
3024
3025                                         // no break !! because we want to break the second loop too.
3026
3027                                         // --------------------------------------------------------------------------
3028                                         // unknown Direction
3029                                 default:
3030
3031                                         // so we can break the second loop earler
3032                                         nSubIndexCount = 1;
3033                                         break;
3034                                 }
3035
3036                                 nSubIndexCount--;
3037
3038                                 // next subindex entry
3039                                 if ((Access & kEplObdAccArray) == 0) {
3040                                         pSubIndex++;
3041                                         if ((nSubIndexCount > 0)
3042                                             &&
3043                                             ((pSubIndex->
3044                                               m_Access & kEplObdAccArray) !=
3045                                              0)) {
3046                                                 // next subindex points to an array
3047                                                 // reset subindex number
3048                                                 pSubIndex->m_uiSubIndex = 1;
3049                                         }
3050                                 } else {
3051                                         if (nSubIndexCount > 0) {
3052                                                 // next subindex points to an array
3053                                                 // increment subindex number
3054                                                 pSubIndex->m_uiSubIndex++;
3055                                         }
3056                                 }
3057                         }
3058
3059                         // next index entry
3060                         pObdEnty_p++;
3061                 }
3062         }
3063         // -----------------------------------------------------------------------------------------
3064         // command of last action depends on direction to access
3065         if (Direction_p == kEplObdDirOBKCheck) {
3066
3067                 goto Exit;
3068         }
3069 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
3070         else {
3071                 if (Direction_p == kEplObdDirLoad) {
3072                         CbStore.m_bCommand = (BYTE) kEplObdCommCloseRead;
3073                 } else if (Direction_p == kEplObdDirStore) {
3074                         CbStore.m_bCommand = (BYTE) kEplObdCommCloseWrite;
3075                 } else if (Direction_p == kEplObdDirRestore) {
3076                         CbStore.m_bCommand = (BYTE) kEplObdCommClear;
3077                 } else {
3078                         goto Exit;
3079                 }
3080
3081                 // call callback function for last command
3082                 Ret = EplObdCallStoreCallback(EPL_MCO_INSTANCE_PTR_ & CbStore);
3083         }
3084 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
3085
3086 //    goto Exit;
3087
3088       Exit:
3089
3090         return Ret;
3091
3092 }
3093
3094 // ----------------------------------------------------------------------------
3095 // Function:    EplObdCopyObjectData()
3096 //
3097 // Description: checks pointers to object data and copy them from source to destination
3098 //
3099 // Parameters:  pDstData_p              = destination pointer
3100 //              pSrcData_p              = source pointer
3101 //              ObjSize_p               = size of object
3102 //              ObjType_p               =
3103 //
3104 // Returns:     tEplKernel              = error code
3105 // ----------------------------------------------------------------------------
3106
3107 static void EplObdCopyObjectData(void MEM * pDstData_p,
3108                                  void *pSrcData_p,
3109                                  tEplObdSize ObjSize_p, tEplObdType ObjType_p)
3110 {
3111
3112         tEplObdSize StrSize = 0;
3113
3114         // it is allowed to set default and current address to NULL (nothing to copy)
3115         if (pDstData_p != NULL) {
3116
3117                 if (ObjType_p == kEplObdTypVString) {
3118                         // The function calculates the really number of characters of string. The
3119                         // object entry size can be bigger as string size of default string.
3120                         // The '\0'-termination is included. A string with no characters has a
3121                         // size of 1.
3122                         StrSize =
3123                             EplObdGetStrLen((void *)pSrcData_p, ObjSize_p,
3124                                             kEplObdTypVString);
3125
3126                         // If the string length is greater than or equal to the entry size in OD then only copy
3127                         // entry size - 1 and always set the '\0'-termination.
3128                         if (StrSize >= ObjSize_p) {
3129                                 StrSize = ObjSize_p - 1;
3130                         }
3131                 }
3132
3133                 if (pSrcData_p != NULL) {
3134                         // copy data
3135                         EPL_MEMCPY(pDstData_p, pSrcData_p, ObjSize_p);
3136
3137                         if (ObjType_p == kEplObdTypVString) {
3138                                 ((char MEM *)pDstData_p)[StrSize] = '\0';
3139                         }
3140                 }
3141         }
3142
3143 }
3144
3145 //---------------------------------------------------------------------------
3146 //
3147 // Function:    EplObdIsNumericalIntern()
3148 //
3149 // Description: function checks if a entry is numerical or not
3150 //
3151 //
3152 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_ = Instancepointer
3153 //              uiIndex_p           = Index
3154 //              uiSubIndex_p        = Subindex
3155 //              pfEntryNumerical_p  = pointer to BOOL for returnvalue
3156 //                                  -> TRUE if entry a numerical value
3157 //                                  -> FALSE if entry not a numerical value
3158 //
3159 // Return:      tEplKernel = Errorcode
3160 //
3161 // State:
3162 //
3163 //---------------------------------------------------------------------------
3164 static tEplKernel EplObdIsNumericalIntern(tEplObdSubEntryPtr pObdSubEntry_p,
3165                                           BOOL * pfEntryNumerical_p)
3166 {
3167         tEplKernel Ret = kEplSuccessful;
3168
3169         // get Type
3170         if ((pObdSubEntry_p->m_Type == kEplObdTypVString)
3171             || (pObdSubEntry_p->m_Type == kEplObdTypOString)
3172             || (pObdSubEntry_p->m_Type == kEplObdTypDomain)) {  // not numerical types
3173                 *pfEntryNumerical_p = FALSE;
3174         } else {                // numerical types
3175                 *pfEntryNumerical_p = TRUE;
3176         }
3177
3178         return Ret;
3179
3180 }
3181
3182 // -------------------------------------------------------------------------
3183 // function to classify object type (fixed/non fixed)
3184 // -------------------------------------------------------------------------
3185
3186 // ----------------------------------------------------------------------------
3187 // Function:    EplObdCallStoreCallback()
3188 //
3189 // Description: checks address to callback function and calles it when unequal
3190 //              to NULL
3191 //
3192 // Parameters:  EPL_MCO_DECL_INSTANCE_PTR_ = (instance pointer)
3193 //              pCbStoreParam_p        = address to callback parameters
3194 //
3195 // Returns:     tEplKernel             = error code
3196 // ----------------------------------------------------------------------------
3197 #if (EPL_OBD_USE_STORE_RESTORE != FALSE)
3198 static tEplKernel EplObdCallStoreCallback(EPL_MCO_DECL_INSTANCE_PTR_
3199                                           tEplObdCbStoreParam MEM *
3200                                           pCbStoreParam_p)
3201 {
3202
3203         tEplKernel Ret = kEplSuccessful;
3204
3205         ASSERT(pCbStoreParam_p != NULL);
3206
3207         // check if function pointer is NULL - if so, no callback should be called
3208         if (EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback) != NULL) {
3209                 Ret =
3210                     EPL_MCO_GLB_VAR(m_fpStoreLoadObjCallback)
3211                     (EPL_MCO_INSTANCE_PARAM_IDX_()
3212                      pCbStoreParam_p);
3213         }
3214
3215         return Ret;
3216
3217 }
3218 #endif // (EPL_OBD_USE_STORE_RESTORE != FALSE)
3219 //---------------------------------------------------------------------------
3220 //
3221 // Function:    EplObdGetObjectDataPtrIntern()
3222 //
3223 // Description: Function gets the data pointer of an object.
3224 //              It returnes the current data pointer. But if object is an
3225 //              constant object it returnes the default pointer.
3226 //
3227 // Parameters:  pSubindexEntry_p = pointer to subindex entry
3228 //
3229 // Return:      void *    = pointer to object data
3230 //
3231 // State:
3232 //
3233 //---------------------------------------------------------------------------
3234
3235 void *EplObdGetObjectDataPtrIntern(tEplObdSubEntryPtr pSubindexEntry_p)
3236 {
3237
3238         void *pData;
3239         tEplObdAccess Access;
3240
3241         ASSERTMSG(pSubindexEntry_p != NULL,
3242                   "EplObdGetObjectDataPtrIntern(): pointer to SubEntry not valid!\n");
3243
3244         // there are are some objects whose data pointer has to get from other structure
3245         // get access type for this object
3246         Access = pSubindexEntry_p->m_Access;
3247
3248         // If object has access type = const,
3249         // for data only exists default values.
3250         if ((Access & kEplObdAccConst) != 0) {
3251                 // The pointer to defualt value can be received from ObdGetObjectDefaultPtr()
3252                 pData = ((void *)EplObdGetObjectDefaultPtr(pSubindexEntry_p));
3253         } else {
3254                 // The pointer to current value can be received from ObdGetObjectCurrentPtr()
3255                 pData = ((void *)EplObdGetObjectCurrentPtr(pSubindexEntry_p));
3256         }
3257
3258         return pData;
3259
3260 }
3261 #endif // end of #if(((EPL_MODULE_INTEGRATION) & (EPL_MODULE_OBDK)) != 0)
3262 // EOF