src/pdo.c

   1 /*
   2   This file is part of CanFestival, a library implementing CanOpen
   3   Stack.
   4
   5   Copyright (C): Edouard TISSERANT and Francis DUPIN
   6
   7   See COPYING file for copyrights details.
   8
   9   This library is free software; you can redistribute it and/or
  10   modify it under the terms of the GNU Lesser General Public
  11   License as published by the Free Software Foundation; either
  12   version 2.1 of the License, or (at your option) any later version.
  13
  14   This library is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public
  20   License along with this library; if not, write to the Free Software
  21   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22   USA
  23 */
  24 #include "pdo.h"
  25 #include "objacces.h"
  26 #include "canfestival.h"
  27
  28 /*!
  29 ** @file   pdo.c
  30 ** @author Edouard TISSERANT and Francis DUPIN
  31 ** @date   Tue Jun  5 09:32:32 2007
  32 **
  33 ** @brief
  34 **
  35 **
  36 */
  37
  38 /*!
  39 **
  40 **
  41 ** @param d
  42 ** @param TPDO_com TPDO communication parameters OD entry
  43 ** @param TPDO_map TPDO mapping parameters OD entry
  44 **
  45 ** @return
  46 **/
  47
  48 UNS8 buildPDO(CO_Data* d, UNS8 numPdo, Message *pdo)
  49 {
  50         const indextable* TPDO_com = d->objdict + d->firstIndex->PDO_TRS + numPdo;
  51         const indextable* TPDO_map = d->objdict + d->firstIndex->PDO_TRS_MAP + numPdo;
  52
  53         UNS8 prp_j = 0x00;
  54         UNS8 offset = 0x00;
  55         const UNS8* pMappingCount = (UNS8*) TPDO_map->pSubindex[0].pObject;
  56
  57         pdo->cob_id.w = *(UNS32*)TPDO_com->pSubindex[1].pObject;
  58         pdo->rtr = NOT_A_REQUEST;
  59
  60         MSG_WAR(0x3009, "  PDO CobId is : ", *(UNS32*)TPDO_com->pSubindex[1].pObject);
  61         MSG_WAR(0x300D, "  Number of objects mapped : ",*pMappingCount );
  62
  63         do{
  64                 UNS8 dataType; /* Unused */
  65                 UNS8 tmp[]= {0,0,0,0,0,0,0,0}; /* temporary space to hold bits */
  66
  67                 /* pointer fo the var which holds the mapping parameter of an mapping entry  */
  68                 UNS32* pMappingParameter = (UNS32*) TPDO_map->pSubindex[prp_j + 1].pObject;
  69                 UNS16 index = (UNS16)((*pMappingParameter) >> 16);
  70                 UNS8 Size = (UNS8)(*pMappingParameter); /* Size in bits */
  71                 UNS8 ByteSize = 1 + ((Size - 1) >> 3); /*1->8 => 1 ; 9->16 => 2, ... */
  72                 UNS8 subIndex = (UNS8)(( (*pMappingParameter) >> (UNS8)8 ) & (UNS32)0x000000FF);
  73
  74                 MSG_WAR(0x300F, "  got mapping parameter : ", *pMappingParameter);
  75                 MSG_WAR(0x3050, "    at index : ", TPDO_map->index);
  76                 MSG_WAR(0x3051, "    sub-index : ", prp_j + 1);
  77
  78                 if( getODentry(d, index, subIndex, tmp, &ByteSize, &dataType, 0 ) != OD_SUCCESSFUL ){
  79                         MSG_ERR(0x1013, " Couldn't find mapped variable at index-subindex-size : ", (UNS16)(*pMappingParameter));
  80                         return 0xFF;
  81                 }
  82                 /* copy bit per bit in little endian*/
  83                 CopyBits(Size, ((UNS8*)tmp), 0 , 0, (UNS8*)&pdo->data[offset>>3], offset%8, 0);
  84
  85                 offset += Size ;
  86                 prp_j++;
  87         }while( prp_j < *pMappingCount );
  88
  89         pdo->len = 1 + ((offset - 1) >> 3);
  90
  91         MSG_WAR(0x3015, "  End scan mapped variable", 0);
  92
  93         return 0;
  94 }
  95
  96 /*!
  97 **
  98 **
  99 ** @param d
 100 ** @param cobId
 101 **
 102 ** @return
 103 **/
 104 UNS8 sendPDOrequest( CO_Data* d, UNS32 cobId )
 105 {
 106   UNS32 * pwCobId;
 107   UNS16          offset;
 108   UNS16          lastIndex;
 109   UNS8           err;
 110
 111   MSG_WAR(0x3930, "sendPDOrequest ",0);
 112   /* Sending the request only if the cobid have been found on the PDO
 113      receive */
 114   /* part dictionary */
 115   offset = d->firstIndex->PDO_RCV;
 116   lastIndex = d->lastIndex->PDO_RCV;
 117   if (offset)
 118     while (offset <= lastIndex) {
 119       /* get the CobId*/
 120       pwCobId = (UNS32*) d->objdict[offset].pSubindex[1].pObject;
 121
 122       if ( *pwCobId  == cobId ) {
 123         Message pdo = {*pwCobId, REQUEST, 0};
 124         return canSend(d->canHandle,&pdo);
 125       }
 126       offset++;
 127     }
 128   MSG_WAR(0x1931, "sendPDOrequest : COBID not found : ", cobId);
 129   return 0xFF;
 130 }
 131
 132
 133 /*!
 134 **
 135 **
 136 ** @param d
 137 ** @param m
 138 **
 139 ** @return
 140 **/
 141 UNS8 proceedPDO(CO_Data* d, Message *m)
 142 {
 143   UNS8   numPdo;
 144   UNS8   numMap;  /* Number of the mapped varable */
 145   UNS8 i;
 146   UNS8 *     pMappingCount = NULL;    /* count of mapped objects... */
 147   /* pointer to the var which is mapped to a pdo... */
 148   /*  void *     pMappedAppObject = NULL;   */
 149   /* pointer fo the var which holds the mapping parameter of an
 150      mapping entry */
 151   UNS32 *    pMappingParameter = NULL;
 152   UNS8  *    pTransmissionType = NULL; /* pointer to the transmission
 153                                          type */
 154   UNS32 *    pwCobId = NULL;
 155   UNS8       Size;
 156   UNS8       dataType;
 157   UNS8       offset;
 158   UNS8       status;
 159   UNS32      objDict;
 160   UNS16      offsetObjdict;
 161   UNS16      lastIndex;
 162
 163   status = state2;
 164
 165   MSG_WAR(0x3935, "proceedPDO, cobID : ", ((*m).cob_id.w & 0x7ff));
 166   offset = 0x00;
 167   numPdo = 0;
 168   numMap = 0;
 169   if((*m).rtr == NOT_A_REQUEST ) { /* The PDO received is not a
 170                                      request. */
 171
 172     offsetObjdict = d->firstIndex->PDO_RCV;
 173     lastIndex = d->lastIndex->PDO_RCV;
 174
 175     /* study of all the PDO stored in the dictionary */
 176     if(offsetObjdict)
 177       while (offsetObjdict <= lastIndex) {
 178
 179         switch( status ) {
 180
 181         case state2:
 182           /* get CobId of the dictionary correspondant to the received
 183              PDO */
 184           pwCobId = (UNS32*) d->objdict[offsetObjdict].pSubindex[1].pObject;
 185           /* check the CobId coherance */
 186           /*pwCobId is the cobId read in the dictionary at the state 3
 187             */
 188           if ( *pwCobId == (*m).cob_id.w ){
 189             /* The cobId is recognized */
 190             status = state4;
 191             MSG_WAR(0x3936, "cobId found at index ", 0x1400 + numPdo);
 192             break;
 193           }
 194           else {
 195             /* cobId received does not match with those write in the
 196               dictionnary */
 197             numPdo++;
 198             offsetObjdict++;
 199             status = state2;
 200             break;
 201           }
 202
 203             case state4:/* Get Mapped Objects Number */
 204                /* The cobId of the message received has been found in the
 205                  dictionnary. */
 206                offsetObjdict = d->firstIndex->PDO_RCV_MAP;
 207              lastIndex = d->lastIndex->PDO_RCV_MAP;
 208              pMappingCount = (UNS8*) (d->objdict + offsetObjdict + numPdo)->pSubindex[0].pObject;
 209              numMap = 0;
 210              while (numMap < *pMappingCount) {
 211                UNS8 tmp[]= {0,0,0,0,0,0,0,0};
 212                UNS8 ByteSize;
 213                pMappingParameter = (UNS32*) (d->objdict + offsetObjdict + numPdo)->pSubindex[numMap + 1].pObject;
 214                if (pMappingParameter == NULL) {
 215                  MSG_ERR(0x1937, "Couldn't get mapping parameter : ", numMap + 1);
 216                  return 0xFF;
 217                }
 218                /* Get the addresse of the mapped variable. */
 219                /* detail of *pMappingParameter : */
 220                /* The 16 hight bits contains the index, the medium 8 bits
 221                  contains the subindex, */
 222                /* and the lower 8 bits contains the size of the mapped
 223                  variable. */
 224
 225                Size = (UNS8)(*pMappingParameter);
 226
 227                /* copy bit per bit in little endian */
 228                CopyBits(Size, (UNS8*)&m->data[offset>>3], offset%8, 0, ((UNS8*)tmp), 0, 0);
 229
 230                ByteSize = 1 + ((Size - 1) >> 3); /*1->8 => 1 ; 9->16 =>
 231                                                    2, ... */
 232
 233                objDict = setODentry(d, (UNS16)((*pMappingParameter) >> 16),
 234                                     (UNS8)(((*pMappingParameter) >> 8 ) & 0xFF),
 235                                  tmp, &ByteSize, 0 );
 236
 237                if(objDict != OD_SUCCESSFUL) {
 238                  MSG_ERR(0x1938, "error accessing to the mapped var : ", numMap + 1);
 239                  MSG_WAR(0x2939, "         Mapped at index : ", (*pMappingParameter) >> 16);
 240                  MSG_WAR(0x2940, "                subindex : ", ((*pMappingParameter) >> 8 ) & 0xFF);
 241                  return 0xFF;
 242                }
 243
 244                MSG_WAR(0x3942, "Variable updated with value received by PDO cobid : ", m->cob_id.w);
 245                MSG_WAR(0x3943, "         Mapped at index : ", (*pMappingParameter) >> 16);
 246                MSG_WAR(0x3944, "                subindex : ", ((*pMappingParameter) >> 8 ) & 0xFF);
 247                /* MSG_WAR(0x3945, "                data : ",*((UNS32*)pMappedAppObject)); */
 248                offset += Size;
 249                numMap++;
 250                /*TODO :  check that offset is not not greater that message size (in bit) */
 251              } /* end loop while on mapped variables */
 252
 253              offset=0x00;
 254              numMap = 0;
 255              return 0;
 256
 257         }/* end switch status*/
 258       }/* end while*/
 259   }/* end if Donnees */
 260   else if ((*m).rtr == REQUEST ){
 261     MSG_WAR(0x3946, "Receive a PDO request cobId : ", m->cob_id.w);
 262     status = state1;
 263     offsetObjdict = d->firstIndex->PDO_TRS;
 264     lastIndex = d->lastIndex->PDO_TRS;
 265     if(offsetObjdict) while( offsetObjdict  <= lastIndex ){
 266       /* study of all PDO stored in the objects dictionary */
 267
 268       switch( status ){
 269
 270       case state1:/* check the CobId */
 271         /* get CobId of the dictionary which match to the received PDO
 272          */
 273         pwCobId = (UNS32*) (d->objdict + offsetObjdict)->pSubindex[1].pObject;
 274         if ( *pwCobId == (*m).cob_id.w ) {
 275           status = state4;
 276           break;
 277         }
 278         else {
 279           numPdo++;
 280           offsetObjdict++;
 281         }
 282         status = state1;
 283         break;
 284
 285
 286       case state4:/* check transmission type (after request?) */
 287         pTransmissionType = (UNS8*) d->objdict[offsetObjdict].pSubindex[2].pObject;
 288         if ( (*pTransmissionType == TRANS_RTR) ||
 289              (*pTransmissionType == TRANS_RTR_SYNC )) {
 290           status = state5;
 291           break;
 292         }else if(
 293              (*pTransmissionType == TRANS_EVENT_PROFILE) ||
 294              (*pTransmissionType == TRANS_EVENT_SPECIFIC) ) {
 295           /* Zap all timers and inhibit flag */
 296           d->PDO_status[numPdo].event_timer = DelAlarm(d->PDO_status[numPdo].event_timer);
 297           d->PDO_status[numPdo].inhibit_timer = DelAlarm(d->PDO_status[numPdo].inhibit_timer);
 298           d->PDO_status[numPdo].transmit_type_parameter &= ~PDO_INHIBITED;
 299           /* Call  PDOEventTimerAlarm for this TPDO, this will trigger emission et reset timers */
 300           PDOEventTimerAlarm(d, numPdo);
 301           return 0;
 302         }else {
 303           /* The requested PDO is not to send on request. So, does
 304             nothing. */
 305           MSG_WAR(0x2947, "PDO is not to send on request : ", m->cob_id.w);
 306           return 0xFF;
 307         }
 308
 309       case state5:/* build and send requested PDO */
 310       {
 311         Message pdo;
 312         if( buildPDO(d, numPdo, &pdo))
 313         {
 314           MSG_ERR(0x1013, " Couldn't find mapped variable at index-subindex-size : ", (UNS16)(*pMappingParameter));
 315           //return 0xFF; /*No real reason to stop...*/
 316         }
 317         canSend(d->canHandle,&pdo);
 318         return 0;
 319       }
 320       }/* end switch status */
 321     }/* end while */
 322   }/* end if Requete */
 323
 324   return 0;
 325 }
 326
 327 /*!
 328 **
 329 **
 330 ** @param NbBits
 331 ** @param SrcByteIndex
 332 ** @param SrcBitIndex
 333 ** @param SrcBigEndian
 334 ** @param DestByteIndex
 335 ** @param DestBitIndex
 336 ** @param DestBigEndian
 337 **/
 338 void CopyBits(UNS8 NbBits, UNS8* SrcByteIndex, UNS8 SrcBitIndex, UNS8 SrcBigEndian, UNS8* DestByteIndex, UNS8 DestBitIndex, UNS8 DestBigEndian)
 339 {
 340   /* This loop copy as many bits that it can each time, crossing*/
 341   /* successively bytes*/
 342   // boundaries from LSB to MSB.
 343   while(NbBits > 0)
 344     {
 345       /* Bit missalignement between src and dest*/
 346       INTEGER8 Vect = DestBitIndex - SrcBitIndex;
 347
 348       /* We can now get src and align it to dest*/
 349       UNS8 Aligned = Vect>0 ? *SrcByteIndex << Vect : *SrcByteIndex >> -Vect;
 350
 351       /* Compute the nb of bit we will be able to copy*/
 352       UNS8 BoudaryLimit = (Vect>0 ? 8 - DestBitIndex :  8 - SrcBitIndex );
 353       UNS8 BitsToCopy = BoudaryLimit > NbBits ? NbBits : BoudaryLimit;
 354
 355       /* Create a mask that will serve in:*/
 356       UNS8 Mask = ((0xff << (DestBitIndex + BitsToCopy)) | (0xff >> (8 - DestBitIndex)));
 357
 358       /* - Filtering src*/
 359       UNS8 Filtered = Aligned & ~Mask;
 360
 361       /* - and erase bits where we write, preserve where we don't*/
 362       *DestByteIndex &= Mask;
 363
 364       /* Then write.*/
 365       *DestByteIndex |= Filtered ;
 366
 367       /*Compute next time cursors for src*/
 368       if((SrcBitIndex += BitsToCopy)>7)/* cross boundary ?*/
 369         {
 370           SrcBitIndex = 0;/* First bit*/
 371           SrcByteIndex += (SrcBigEndian ? -1 : 1);/* Next byte*/
 372         }
 373
 374
 375       /*Compute next time cursors for dest*/
 376       if((DestBitIndex += BitsToCopy)>7)
 377         {
 378           DestBitIndex = 0;/* First bit*/
 379           DestByteIndex += (DestBigEndian ? -1 : 1);/* Next byte*/
 380         }
 381
 382       /*And decrement counter.*/
 383       NbBits -= BitsToCopy;
 384     }
 385
 386 }
 387 /*!
 388 **
 389 **
 390 ** @param d
 391 **
 392 ** @return
 393 **/
 394
 395 UNS8 sendPDOevent( CO_Data* d)
 396 {
 397   /* Calls _sendPDOevent specifying it is not a sync event */
 398   return _sendPDOevent(d, 0);
 399 }
 400
 401
 402 void PDOEventTimerAlarm(CO_Data* d, UNS32 pdoNum)
 403 {
 404         printf("EV PDOEventTimerAlarm : %d\n", pdoNum);
 405
 406         /* This is needed to avoid deletion of re-attribuated timer */
 407         d->PDO_status[pdoNum].event_timer = TIMER_NONE;
 408         /* force emission of PDO by artificially changing last emitted*/
 409         d->PDO_status[pdoNum].last_message.cob_id.w = 0;
 410         _sendPDOevent( d, 0 ); /* not a Sync Event*/
 411 }
 412
 413 void PDOInhibitTimerAlarm(CO_Data* d, UNS32 pdoNum)
 414 {
 415         printf("EV PDOInhibitTimerAlarm : %d\n", pdoNum);
 416
 417         /* This is needed to avoid deletion of re-attribuated timer */
 418         d->PDO_status[pdoNum].inhibit_timer = TIMER_NONE;
 419         /* Remove inhibit flag */
 420         d->PDO_status[pdoNum].transmit_type_parameter &= ~PDO_INHIBITED;
 421         _sendPDOevent( d, 0 ); /* not a Sync Event*/
 422 }
 423
 424 /*!
 425 **
 426 **
 427 ** @param d
 428 ** @param isSyncEvent
 429 **
 430 ** @return
 431 **/
 432
 433 UNS8 _sendPDOevent( CO_Data* d, UNS8 isSyncEvent )
 434 {
 435   UNS8  pdoNum = 0x00;       /* number of the actual processed pdo-nr. */
 436   UNS8* pTransmissionType = NULL;
 437   UNS8 status = state3;
 438   UNS16 offsetObjdict = d->firstIndex->PDO_TRS;
 439   UNS16 offsetObjdictMap = d->firstIndex->PDO_TRS_MAP;
 440   UNS16 lastIndex = d->lastIndex->PDO_TRS;
 441
 442   /* study all PDO stored in the objects dictionary */
 443   if(offsetObjdict){
 444    Message clean = Message_Initializer;
 445    Message pdo = Message_Initializer;
 446    while( offsetObjdict <= lastIndex) {
 447     switch( status ) {
 448     case state3:    /* get the PDO transmission type */
 449       if (d->objdict[offsetObjdict].bSubCount <= 2) {
 450           MSG_ERR(0x1004, "Subindex 2  not found at index ", 0x1800 + pdoNum);
 451           return 0xFF;
 452         }
 453       pTransmissionType = (UNS8*) d->objdict[offsetObjdict].pSubindex[2].pObject;
 454       MSG_WAR(0x3005, "Reading PDO at index : ", 0x1800 + pdoNum);
 455
 456       /* check if transmission type is after (this) SYNC */
 457       /* The message may not be transmited every SYNC but every n SYNC */
 458       if( isSyncEvent &&
 459           (*pTransmissionType >= TRANS_SYNC_MIN) &&
 460           (*pTransmissionType <= TRANS_SYNC_MAX) &&
 461           (++d->PDO_status[pdoNum].transmit_type_parameter == *pTransmissionType) ) {
 462         d->PDO_status[pdoNum].transmit_type_parameter = 0;
 463         MSG_WAR(0x3007, "  PDO is on SYNCHRO. Trans type : ", *pTransmissionType);
 464         pdo = clean;
 465         if(buildPDO(d, pdoNum, &pdo))
 466         {
 467             MSG_ERR(0x3006, " Couldn't build TPDO number : ", pdoNum);
 468             status = state11;
 469             break;
 470         }
 471         status = state5;
 472       }
 473       /* If transmission on Event and not inhibited, check for changes */
 474       else if((*pTransmissionType == TRANS_EVENT_PROFILE ||
 475                *pTransmissionType == TRANS_EVENT_SPECIFIC )&&
 476               !(d->PDO_status[pdoNum].transmit_type_parameter & PDO_INHIBITED)) {
 477         MSG_WAR(0x3008, "  PDO is on EVENT. Trans type : ", *pTransmissionType);
 478         pdo = pdo = clean;
 479         if(buildPDO(d, pdoNum, &pdo))
 480         {
 481             MSG_ERR(0x3007, " Couldn't build TPDO number : ", pdoNum);
 482             status = state11;
 483             break;
 484         }
 485
 486         /*Compare new and old PDO*/
 487         if(d->PDO_status[pdoNum].last_message.cob_id.w == pdo.cob_id.w &&
 488            d->PDO_status[pdoNum].last_message.len == pdo.len &&
 489            *(UNS64*)(&d->PDO_status[pdoNum].last_message.data[0]) == *(UNS64*)(&pdo.data[0])){
 490                 /* No changes -> go to next pdo*/
 491                 status = state11;
 492         }else{
 493                 MSG_WAR(0x3008, "Changes TPDO number : ", pdoNum);
 494                 printf("EV Changes TPDO number : %d\n", pdoNum);
 495                 /* Changes detected -> transmit message */
 496                 status = state5;
 497
 498                 /* Start both event_timer and inhibit_timer*/
 499                 DelAlarm(d->PDO_status[pdoNum].event_timer);
 500                 d->PDO_status[pdoNum].event_timer = SetAlarm(d, pdoNum, &PDOEventTimerAlarm, MS_TO_TIMEVAL(*(UNS16*)d->objdict[offsetObjdict].pSubindex[5].pObject), 0);
 501
 502                 DelAlarm(d->PDO_status[pdoNum].inhibit_timer);
 503                 d->PDO_status[pdoNum].inhibit_timer = SetAlarm(d, pdoNum, &PDOInhibitTimerAlarm, US_TO_TIMEVAL(*(UNS16*)d->objdict[offsetObjdict].pSubindex[3].pObject * 100), 0);
 504
 505                 /* and inhibit TPDO */
 506                 d->PDO_status[pdoNum].transmit_type_parameter |= PDO_INHIBITED;
 507         }
 508       }else{
 509         MSG_WAR(0x3009, "  PDO is not on EVENT or synchro or not at this SYNC. Trans type : ", *pTransmissionType);
 510         status = state11;
 511       }
 512         break;
 513     case state5: /*Send the pdo*/
 514         /*store_as_last_message*/
 515         d->PDO_status[pdoNum].last_message = pdo;
 516         MSG_WAR(0x3901, "sendPDO cobId :", pdo.cob_id.w);
 517         MSG_WAR(0x3902,  "     Nb octets  : ",  pdo.len);
 518         {int i;
 519         for (i = 0 ; i < pdo.len ; i++) {
 520                 MSG_WAR(0x3903,"           data : ", pdo.data[i]);
 521         }}
 522
 523         canSend(d->canHandle,&pdo);
 524         status = state11;
 525         break;
 526     case state11: /*Go to next TPDO*/
 527         pdoNum++;
 528         offsetObjdict++;
 529         offsetObjdictMap++;
 530         MSG_WAR(0x3017, "next pdo index : ", pdoNum);
 531         status = state3;
 532         break;
 533
 534     default:
 535       MSG_ERR(0x1019,"Unknown state has been reached : %d",status);
 536       return 0xFF;
 537     }/* end switch case */
 538
 539   }/* end while */
 540   }
 541   return 0;
 542 }
 543
 544 void PDOInit(CO_Data* d)
 545 {
 546
 547         /* TODO: implement callbacks on 140xh
 548          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 549          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 550          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 551          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 552          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 553          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 554          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 555          * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXx
 556         */
 557
 558   _sendPDOevent(d, 0 );
 559 }
 560
 561 void PDOStop(CO_Data* d)
 562 {
 563   UNS8  pdoNum = 0x00;       /* number of the actual processed pdo-nr. */
 564   UNS16 offsetObjdict = d->firstIndex->PDO_TRS;
 565   UNS16 lastIndex = d->lastIndex->PDO_TRS;
 566   if(offsetObjdict) while( offsetObjdict <= lastIndex) {
 567         d->PDO_status[pdoNum].event_timer = DelAlarm(d->PDO_status[pdoNum].event_timer);
 568         d->PDO_status[pdoNum].inhibit_timer = DelAlarm(d->PDO_status[pdoNum].inhibit_timer);
 569         d->PDO_status[pdoNum].transmit_type_parameter = 0;
 570         d->PDO_status[pdoNum].last_message.cob_id.w = 0;
 571         pdoNum++;
 572         offsetObjdict++;
 573   }
 574 }