diff -r f45fd4cd3832 -r 34654679f262 doc/doxygen/html/sdo_8c-source.html --- a/doc/doxygen/html/sdo_8c-source.html Fri Jul 06 10:53:15 2007 +0200 +++ b/doc/doxygen/html/sdo_8c-source.html Mon Jul 16 08:56:03 2007 +0200 @@ -18,7 +18,7 @@
  • Globals
  • +src

    sdo.c

    Go to the documentation of this file.
    00001 /*
     00002 This file is part of CanFestival, a library implementing CanOpen Stack. 
     00003 
    @@ -48,248 +48,248 @@
     00037 #include "canfestival.h"
     00038 
     00039 /* Uncomment if your compiler does not support inline functions */
    -00040 #define NO_INLINE 
    +00040 #define NO_INLINE 
     00041 
     00042 #ifdef NO_INLINE
    -00043   #define INLINE 
    +00043   #define INLINE 
     00044 #else
     00045   #define INLINE inline
     00046 #endif
     00047 
     00048 /*Internals prototypes*/
     00049 
    -00065 INLINE UNS8 _writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    -00066                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback, UNS8 endianize);
    +00065 INLINE UNS8 _writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    +00066                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback, UNS8 endianize);
     00067 
    -00080 INLINE UNS8 _readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, 
    -00081         UNS8 dataType, SDOCallback_t Callback);
    +00080 INLINE UNS8 _readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, 
    +00081         UNS8 dataType, SDOCallback_t Callback);
     00082         
     00083 
     00084 /***************************************************************************/
     00085 /* SDO (un)packing macros */
     00086 
    -00089 #define getSDOcs(byte) (byte >> 5)
    +00089 #define getSDOcs(byte) (byte >> 5)
     00090 
    -00093 #define getSDOn2(byte) ((byte >> 2) & 3)
    +00093 #define getSDOn2(byte) ((byte >> 2) & 3)
     00094 
    -00097 #define getSDOn3(byte) ((byte >> 1) & 7)
    +00097 #define getSDOn3(byte) ((byte >> 1) & 7)
     00098 
    -00101 #define getSDOe(byte) ((byte >> 1) & 1)
    +00101 #define getSDOe(byte) ((byte >> 1) & 1)
     00102 
    -00105 #define getSDOs(byte) (byte & 1)
    +00105 #define getSDOs(byte) (byte & 1)
     00106 
    -00109 #define getSDOc(byte) (byte & 1)
    +00109 #define getSDOc(byte) (byte & 1)
     00110 
    -00113 #define getSDOt(byte) ((byte >> 4) & 1)
    +00113 #define getSDOt(byte) ((byte >> 4) & 1)
     00114 
    -00117 #define getSDOindex(byte1, byte2) ((byte2 << 8) | (byte1))
    +00117 #define getSDOindex(byte1, byte2) ((byte2 << 8) | (byte1))
     00118 
    -00121 #define getSDOsubIndex(byte3) (byte3)
    +00121 #define getSDOsubIndex(byte3) (byte3)
     00122 
    -00129 void SDOTimeoutAlarm(CO_Data* d, UNS32 id)
    +00129 void SDOTimeoutAlarm(CO_Data* d, UNS32 id)
     00130 {
    -00131     MSG_ERR(0x1A01, "SDO timeout. SDO response not received.", 0);
    -00132     MSG_WAR(0x2A02, "server node : ", d->transfers[id].nodeId);
    -00133     MSG_WAR(0x2A02, "      index : ", d->transfers[id].index);
    -00134     MSG_WAR(0x2A02, "   subIndex : ", d->transfers[id].subIndex); 
    +00131     MSG_ERR(0x1A01, "SDO timeout. SDO response not received.", 0);
    +00132     MSG_WAR(0x2A02, "server node : ", d->transfers[id].nodeId);
    +00133     MSG_WAR(0x2A02, "      index : ", d->transfers[id].index);
    +00134     MSG_WAR(0x2A02, "   subIndex : ", d->transfers[id].subIndex); 
     00135     /* Reset timer handler */
    -00136     d->transfers[id].timer = TIMER_NONE;
    +00136     d->transfers[id].timer = TIMER_NONE;
     00137     /*Set aborted state*/
    -00138     d->transfers[id].state = SDO_ABORTED_INTERNAL;
    +00138     d->transfers[id].state = SDO_ABORTED_INTERNAL;
     00139     /* Sending a SDO abort */
    -00140     sendSDOabort(d, d->transfers[id].whoami, 
    -00141                  d->transfers[id].index, d->transfers[id].subIndex, SDOABT_TIMED_OUT);
    -00142     d->transfers[id].abortCode = SDOABT_TIMED_OUT;
    +00140     sendSDOabort(d, d->transfers[id].whoami, 
    +00141                  d->transfers[id].index, d->transfers[id].subIndex, SDOABT_TIMED_OUT);
    +00142     d->transfers[id].abortCode = SDOABT_TIMED_OUT;
     00143     /* Call the user function to inform of the problem.*/
    -00144     if(d->transfers[id].Callback)
    +00144     if(d->transfers[id].Callback)
     00145         /*If ther is a callback, it is responsible to close SDO transfer (client)*/
    -00146         (*d->transfers[id].Callback)(d,d->transfers[id].nodeId);
    -00147     else if(d->transfers[id].whoami == SDO_SERVER)
    +00146         (*d->transfers[id].Callback)(d,d->transfers[id].nodeId);
    +00147     else if(d->transfers[id].whoami == SDO_SERVER)
     00148         /*Else, if server, reset the line*/
    -00149         resetSDOline(d, (UNS8)id);
    +00149         resetSDOline(d, (UNS8)id);
     00150 }
     00151 
    -00152 #define StopSDO_TIMER(id) \
    +00152 #define StopSDO_TIMER(id) \
     00153 MSG_WAR(0x3A05, "StopSDO_TIMER for line : ", line);\
     00154 d->transfers[id].timer = DelAlarm(d->transfers[id].timer);
     00155 
    -00156 #define StartSDO_TIMER(id) \
    +00156 #define StartSDO_TIMER(id) \
     00157 MSG_WAR(0x3A06, "StartSDO_TIMER for line : ", line);\
     00158 d->transfers[id].timer = SetAlarm(d,id,&SDOTimeoutAlarm,MS_TO_TIMEVAL(SDO_TIMEOUT_MS),0);
     00159 
    -00160 #define RestartSDO_TIMER(id) \
    +00160 #define RestartSDO_TIMER(id) \
     00161 MSG_WAR(0x3A07, "restartSDO_TIMER for line : ", line);\
     00162 if(d->transfers[id].timer != TIMER_NONE) { StopSDO_TIMER(id) StartSDO_TIMER(id) }
     00163 
    -00169 void resetSDO (CO_Data* d)
    +00169 void resetSDO (CO_Data* d)
     00170 {
    -00171   UNS8 j;
    +00171   UNS8 j;
     00172 
     00173   /* transfer structure initialization */
    -00174     for (j = 0 ; j < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; j++) 
    -00175       resetSDOline(d, j);
    +00174     for (j = 0 ; j < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; j++) 
    +00175       resetSDOline(d, j);
     00176 }
     00177 
    -00186 UNS32 SDOlineToObjdict (CO_Data* d, UNS8 line)
    +00186 UNS32 SDOlineToObjdict (CO_Data* d, UNS8 line)
     00187 {
    -00188   UNS8      size;
    -00189   UNS32 errorCode;
    -00190   MSG_WAR(0x3A08, "Enter in SDOlineToObjdict ", line);
    -00191   size = (UNS8)d->transfers[line].count;
    -00192   errorCode = setODentry(d, d->transfers[line].index, d->transfers[line].subIndex, 
    -00193                          (void *) d->transfers[line].data, &size, 1);
    -00194   if (errorCode != OD_SUCCESSFUL)
    +00188   UNS8      size;
    +00189   UNS32 errorCode;
    +00190   MSG_WAR(0x3A08, "Enter in SDOlineToObjdict ", line);
    +00191   size = (UNS8)d->transfers[line].count;
    +00192   errorCode = setODentry(d, d->transfers[line].index, d->transfers[line].subIndex, 
    +00193                          (void *) d->transfers[line].data, &size, 1);
    +00194   if (errorCode != OD_SUCCESSFUL)
     00195     return errorCode;
    -00196   MSG_WAR(0x3A08, "exit of SDOlineToObjdict ", line);
    +00196   MSG_WAR(0x3A08, "exit of SDOlineToObjdict ", line);
     00197   return 0;
     00198 
     00199 }
     00200 
    -00209 UNS32 objdictToSDOline (CO_Data* d, UNS8 line)
    +00209 UNS32 objdictToSDOline (CO_Data* d, UNS8 line)
     00210 {
    -00211   UNS8  size = 0;
    -00212   UNS8  dataType;
    -00213   UNS32 errorCode;
    +00211   UNS8  size = 0;
    +00212   UNS8  dataType;
    +00213   UNS32 errorCode;
     00214 
    -00215   MSG_WAR(0x3A05, "objdict->line index : ", d->transfers[line].index);
    -00216   MSG_WAR(0x3A06, "  subIndex : ", d->transfers[line].subIndex);
    +00215   MSG_WAR(0x3A05, "objdict->line index : ", d->transfers[line].index);
    +00216   MSG_WAR(0x3A06, "  subIndex : ", d->transfers[line].subIndex);
     00217 
    -00218   errorCode = getODentry(d,     d->transfers[line].index,
    -00219                                 d->transfers[line].subIndex,
    -00220                                 (void *)d->transfers[line].data,
    +00218   errorCode = getODentry(d,     d->transfers[line].index,
    +00219                                 d->transfers[line].subIndex,
    +00220                                 (void *)d->transfers[line].data,
     00221                                 &size, &dataType, 0);
     00222   
    -00223   if (errorCode != OD_SUCCESSFUL)
    +00223   if (errorCode != OD_SUCCESSFUL)
     00224     return errorCode;
     00225 
    -00226   d->transfers[line].count = size;
    -00227   d->transfers[line].offset = 0;
    +00226   d->transfers[line].count = size;
    +00227   d->transfers[line].offset = 0;
     00228 #if 0
     00229    /*Me laisser a, please ! (FD)*/
     00230   {
    -00231     UNS8 i;
    +00231     UNS8 i;
     00232     for (i = 0 ; i < 10 ; i++) {
    -00233       MSG_WAR(i, "data= ", d->transfers[line].data[i]);
    +00233       MSG_WAR(i, "data= ", d->transfers[line].data[i]);
     00234     }     
     00235   }
     00236 #endif
     00237   return 0;
     00238 }
     00239 
    -00250 UNS8 lineToSDO (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8* data) {
    -00251   UNS8 i;
    -00252   UNS8 offset;
    +00250 UNS8 lineToSDO (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8* data) {
    +00251   UNS8 i;
    +00252   UNS8 offset;
     00253 
    -00254   if ((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFERT) {
    -00255     MSG_ERR(0x1A10,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
    +00254   if ((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFERT) {
    +00255     MSG_ERR(0x1A10,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
     00256     return 0xFF;
     00257   }
    -00258     if ((d->transfers[line].offset + nbBytes) > d->transfers[line].count) {
    -00259     MSG_ERR(0x1A11,"SDO Size of data too large. Exceed count", nbBytes);
    +00258     if ((d->transfers[line].offset + nbBytes) > d->transfers[line].count) {
    +00259     MSG_ERR(0x1A11,"SDO Size of data too large. Exceed count", nbBytes);
     00260     return 0xFF;
     00261   }
    -00262   offset = (UNS8)d->transfers[line].offset;
    +00262   offset = (UNS8)d->transfers[line].offset;
     00263   for (i = 0 ; i < nbBytes ; i++) 
    -00264     * (data + i) = d->transfers[line].data[offset + i];
    -00265   d->transfers[line].offset = d->transfers[line].offset + nbBytes;
    +00264     * (data + i) = d->transfers[line].data[offset + i];
    +00265   d->transfers[line].offset = d->transfers[line].offset + nbBytes;
     00266   return 0;
     00267 }
     00268 
    -00279 UNS8 SDOtoLine (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8* data)
    +00279 UNS8 SDOtoLine (CO_Data* d, UNS8 line, UNS8 nbBytes, UNS8* data)
     00280 {
    -00281   UNS8 i;
    -00282   UNS8 offset;
    +00281   UNS8 i;
    +00282   UNS8 offset;
     00283   
    -00284   if ((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFERT) {
    -00285     MSG_ERR(0x1A15,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
    +00284   if ((d->transfers[line].offset + nbBytes) > SDO_MAX_LENGTH_TRANSFERT) {
    +00285     MSG_ERR(0x1A15,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
     00286     return 0xFF;
     00287   }
    -00288   offset = (UNS8)d->transfers[line].offset;
    +00288   offset = (UNS8)d->transfers[line].offset;
     00289   for (i = 0 ; i < nbBytes ; i++) 
    -00290     d->transfers[line].data[offset + i] = * (data + i);
    -00291   d->transfers[line].offset = d->transfers[line].offset + nbBytes;
    +00290     d->transfers[line].data[offset + i] = * (data + i);
    +00291   d->transfers[line].offset = d->transfers[line].offset + nbBytes;
     00292   return 0;
     00293 }
     00294 
    -00307 UNS8 failedSDO (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS16 index, 
    -00308                 UNS8 subIndex, UNS32 abortCode)
    +00307 UNS8 failedSDO (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS16 index, 
    +00308                 UNS8 subIndex, UNS32 abortCode)
     00309 {
    -00310   UNS8 err;
    -00311   UNS8 line;
    -00312   err = getSDOlineOnUse( d, nodeId, whoami, &line );
    +00310   UNS8 err;
    +00311   UNS8 line;
    +00312   err = getSDOlineOnUse( d, nodeId, whoami, &line );
     00313   if (!err) /* If a line on use have been found.*/
    -00314     MSG_WAR(0x3A20, "FailedSDO : line found : ", line);
    -00315   if ((! err) && (whoami == SDO_SERVER)) {
    -00316     resetSDOline( d, line );
    -00317     MSG_WAR(0x3A21, "FailedSDO : line released : ", line);
    +00314     MSG_WAR(0x3A20, "FailedSDO : line found : ", line);
    +00315   if ((! err) && (whoami == SDO_SERVER)) {
    +00316     resetSDOline( d, line );
    +00317     MSG_WAR(0x3A21, "FailedSDO : line released : ", line);
     00318   }
    -00319   if ((! err) && (whoami == SDO_CLIENT)) {
    -00320     StopSDO_TIMER(line);
    -00321     d->transfers[line].state = SDO_ABORTED_INTERNAL;
    +00319   if ((! err) && (whoami == SDO_CLIENT)) {
    +00320     StopSDO_TIMER(line);
    +00321     d->transfers[line].state = SDO_ABORTED_INTERNAL;
     00322   }
    -00323   MSG_WAR(0x3A22, "Sending SDO abort ", 0);
    -00324   err = sendSDOabort(d, whoami, index, subIndex, abortCode);
    +00323   MSG_WAR(0x3A22, "Sending SDO abort ", 0);
    +00324   err = sendSDOabort(d, whoami, index, subIndex, abortCode);
     00325   if (err) {
    -00326     MSG_WAR(0x3A23, "Unable to send the SDO abort", 0);
    +00326     MSG_WAR(0x3A23, "Unable to send the SDO abort", 0);
     00327     return 0xFF;
     00328   }
     00329   return 0;
     00330 }
     00331 
    -00338 void resetSDOline ( CO_Data* d, UNS8 line )
    +00338 void resetSDOline ( CO_Data* d, UNS8 line )
     00339 {
    -00340   UNS8 i; 
    -00341   MSG_WAR(0x3A25, "reset SDO line nb : ", line); 
    -00342   initSDOline(d, line, 0, 0, 0, SDO_RESET);
    -00343   for (i = 0 ; i < SDO_MAX_LENGTH_TRANSFERT ; i++)
    -00344     d->transfers[line].data[i] = 0;
    +00340   UNS8 i; 
    +00341   MSG_WAR(0x3A25, "reset SDO line nb : ", line); 
    +00342   initSDOline(d, line, 0, 0, 0, SDO_RESET);
    +00343   for (i = 0 ; i < SDO_MAX_LENGTH_TRANSFERT ; i++)
    +00344     d->transfers[line].data[i] = 0;
     00345 }
     00346 
    -00359 UNS8 initSDOline (CO_Data* d, UNS8 line, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 state)
    +00359 UNS8 initSDOline (CO_Data* d, UNS8 line, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 state)
     00360 {
    -00361   MSG_WAR(0x3A25, "init SDO line nb : ", line); 
    -00362   if (state == SDO_DOWNLOAD_IN_PROGRESS || state == SDO_UPLOAD_IN_PROGRESS){
    -00363         StartSDO_TIMER(line)
    +00361   MSG_WAR(0x3A25, "init SDO line nb : ", line); 
    +00362   if (state == SDO_DOWNLOAD_IN_PROGRESS || state == SDO_UPLOAD_IN_PROGRESS){
    +00363         StartSDO_TIMER(line)
     00364   }else{
    -00365         StopSDO_TIMER(line)
    +00365         StopSDO_TIMER(line)
     00366   }
    -00367   d->transfers[line].nodeId = nodeId; 
    -00368   d->transfers[line].index = index;
    -00369   d->transfers[line].subIndex = subIndex;
    -00370   d->transfers[line].state = state;
    -00371   d->transfers[line].toggle = 0;
    -00372   d->transfers[line].count = 0;
    -00373   d->transfers[line].offset = 0;
    -00374   d->transfers[line].dataType = 0;
    -00375   d->transfers[line].Callback = NULL;  
    +00367   d->transfers[line].nodeId = nodeId; 
    +00368   d->transfers[line].index = index;
    +00369   d->transfers[line].subIndex = subIndex;
    +00370   d->transfers[line].state = state;
    +00371   d->transfers[line].toggle = 0;
    +00372   d->transfers[line].count = 0;
    +00373   d->transfers[line].offset = 0;
    +00374   d->transfers[line].dataType = 0;
    +00375   d->transfers[line].Callback = NULL;  
     00376   return 0;
     00377 }
     00378 
    -00388 UNS8 getSDOfreeLine ( CO_Data* d, UNS8 whoami, UNS8 *line )
    +00388 UNS8 getSDOfreeLine ( CO_Data* d, UNS8 whoami, UNS8 *line )
     00389 {
     00390         
    -00391   UNS8 i;
    +00391   UNS8 i;
     00392     
    -00393   for (i = 0 ; i < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; i++){
    -00394     if ( d->transfers[i].state == SDO_RESET ) {
    +00393   for (i = 0 ; i < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; i++){
    +00394     if ( d->transfers[i].state == SDO_RESET ) {
     00395       *line = i;
    -00396       d->transfers[i].whoami = whoami;
    +00396       d->transfers[i].whoami = whoami;
     00397       return 0;
     00398     } /* end if */
     00399   } /* end for */
    -00400   MSG_ERR(0x1A25, "Too many SDO in progress. Aborted.", i);
    +00400   MSG_ERR(0x1A25, "Too many SDO in progress. Aborted.", i);
     00401   return 0xFF;
     00402 }
     00403 
    -00414 UNS8 getSDOlineOnUse (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS8 *line)
    +00414 UNS8 getSDOlineOnUse (CO_Data* d, UNS8 nodeId, UNS8 whoami, UNS8 *line)
     00415 {
     00416         
    -00417   UNS8 i;
    +00417   UNS8 i;
     00418     
    -00419   for (i = 0 ; i < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; i++){
    -00420     if ( (d->transfers[i].state != SDO_RESET) &&
    -00421          (d->transfers[i].nodeId == nodeId) && 
    -00422          (d->transfers[i].whoami == whoami) ) {
    +00419   for (i = 0 ; i < SDO_MAX_SIMULTANEOUS_TRANSFERTS ; i++){
    +00420     if ( (d->transfers[i].state != SDO_RESET) &&
    +00421          (d->transfers[i].nodeId == nodeId) && 
    +00422          (d->transfers[i].whoami == whoami) ) {
     00423       *line = i;
     00424       return 0;
     00425     }
    @@ -297,83 +297,83 @@
     00427   return 0xFF;
     00428 }
     00429 
    -00439 UNS8 closeSDOtransfer (CO_Data* d, UNS8 nodeId, UNS8 whoami)
    +00439 UNS8 closeSDOtransfer (CO_Data* d, UNS8 nodeId, UNS8 whoami)
     00440 {
    -00441   UNS8 err;
    -00442   UNS8 line;
    -00443   err = getSDOlineOnUse(d, nodeId, whoami, &line);
    +00441   UNS8 err;
    +00442   UNS8 line;
    +00443   err = getSDOlineOnUse(d, nodeId, whoami, &line);
     00444   if (err) {
    -00445     MSG_WAR(0x2A30, "No SDO communication to close for node : ", nodeId); 
    +00445     MSG_WAR(0x2A30, "No SDO communication to close for node : ", nodeId); 
     00446     return 0xFF;
     00447   }
    -00448   resetSDOline(d, line);  
    +00448   resetSDOline(d, line);  
     00449   return 0;
     00450 }
     00451 
    -00461 UNS8 getSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 * nbBytes)
    +00461 UNS8 getSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 * nbBytes)
     00462 {
    -00463   if (d->transfers[line].count == 0) /* if received initiate SDO protocol with e=0 and s=0 */
    +00463   if (d->transfers[line].count == 0) /* if received initiate SDO protocol with e=0 and s=0 */
     00464     * nbBytes = 0;
     00465   else
    -00466     * nbBytes = (UNS8)d->transfers[line].count - (UNS8)d->transfers[line].offset;
    +00466     * nbBytes = (UNS8)d->transfers[line].count - (UNS8)d->transfers[line].offset;
     00467   return 0;
     00468 }
     00469 
    -00479 UNS8 setSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 nbBytes)
    +00479 UNS8 setSDOlineRestBytes (CO_Data* d, UNS8 line, UNS8 nbBytes)
     00480 {
    -00481   if (nbBytes > SDO_MAX_LENGTH_TRANSFERT) {
    -00482     MSG_ERR(0x1A35,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
    +00481   if (nbBytes > SDO_MAX_LENGTH_TRANSFERT) {
    +00482     MSG_ERR(0x1A35,"SDO Size of data too large. Exceed SDO_MAX_LENGTH_TRANSFERT", nbBytes);
     00483     return 0xFF;
     00484   }
    -00485   d->transfers[line].count = nbBytes;
    +00485   d->transfers[line].count = nbBytes;
     00486   return 0;
     00487 }
     00488 
    -00498 UNS8 sendSDO (CO_Data* d, UNS8 whoami, s_SDO sdo)
    +00498 UNS8 sendSDO (CO_Data* d, UNS8 whoami, s_SDO sdo)
     00499 {       
    -00500   UNS16 offset;
    -00501   UNS16 lastIndex;
    -00502   UNS8 found = 0;
    +00500   UNS16 offset;
    +00501   UNS16 lastIndex;
    +00502   UNS8 found = 0;
     00503   Message m;
    -00504   UNS8 i;
    -00505   UNS32 * pwCobId = NULL;
    -00506   UNS32 * pwNodeId = NULL;
    +00504   UNS8 i;
    +00505   UNS32 * pwCobId = NULL;
    +00506   UNS32 * pwNodeId = NULL;
     00507 
    -00508   MSG_WAR(0x3A38, "sendSDO",0);
    -00509   if( !((d->nodeState == Operational) ||  (d->nodeState == Pre_operational ))) {
    -00510     MSG_WAR(0x2A39, "unable to send the SDO (not in op or pre-op mode", d->nodeState);
    +00508   MSG_WAR(0x3A38, "sendSDO",0);
    +00509   if( !((d->nodeState == Operational) ||  (d->nodeState == Pre_operational ))) {
    +00510     MSG_WAR(0x2A39, "unable to send the SDO (not in op or pre-op mode", d->nodeState);
     00511     return 0xFF;
     00512   }                             
     00513 
     00514   /*get the server->client cobid*/
    -00515   if ( whoami == SDO_SERVER )   {/*case server. Easy because today only one server SDO is authorized in CanFestival*/
    -00516     offset = d->firstIndex->SDO_SVR;
    +00515   if ( whoami == SDO_SERVER )   {/*case server. Easy because today only one server SDO is authorized in CanFestival*/
    +00516     offset = d->firstIndex->SDO_SVR;
     00517     if (offset == 0) {
    -00518       MSG_ERR(0x1A42, "SendSDO : No SDO server found", 0); 
    +00518       MSG_ERR(0x1A42, "SendSDO : No SDO server found", 0); 
     00519       return 0xFF;
     00520     }
    -00521     pwCobId = d->objdict[offset].pSubindex[2].pObject;
    -00522     MSG_WAR(0x3A41, "I am server. cobId : ", *pwCobId); 
    +00521     pwCobId = (UNS32*) d->objdict[offset].pSubindex[2].pObject;
    +00522     MSG_WAR(0x3A41, "I am server. cobId : ", *pwCobId); 
     00523   }
     00524   else {                        /*case client*/
     00525     /* Get the client->server cobid.*/
    -00526     UNS16 sdoNum = 0;
    -00527     offset = d->firstIndex->SDO_CLT;
    -00528     lastIndex = d->lastIndex->SDO_CLT;
    +00526     UNS16 sdoNum = 0;
    +00527     offset = d->firstIndex->SDO_CLT;
    +00528     lastIndex = d->lastIndex->SDO_CLT;
     00529     if (offset == 0) {
    -00530       MSG_ERR(0x1A42, "SendSDO : No SDO client index found", 0); 
    +00530       MSG_ERR(0x1A42, "SendSDO : No SDO client index found", 0); 
     00531       return 0xFF;
     00532     }
     00533     /* First, have to find at the index where is defined the communication with the server node */
     00534     while (offset <= lastIndex){
    -00535       MSG_WAR(0x3A43,"Reading index : ", 0x1280 + sdoNum);
    -00536       if (d->objdict[offset].bSubCount <= 3) {
    -00537         MSG_ERR(0x1A28, "Subindex 3  not found at index ", 0x1280 + sdoNum);
    +00535       MSG_WAR(0x3A43,"Reading index : ", 0x1280 + sdoNum);
    +00536       if (d->objdict[offset].bSubCount <= 3) {
    +00537         MSG_ERR(0x1A28, "Subindex 3  not found at index ", 0x1280 + sdoNum);
     00538         return 0xFF;
     00539       }
    -00540       pwNodeId = d->objdict[offset].pSubindex[3].pObject;
    -00541       MSG_WAR(0x3A44, "Found nodeId server = ", *pwNodeId);     
    -00542       if(*pwNodeId == sdo.nodeId) {
    +00540       pwNodeId = (UNS32*) d->objdict[offset].pSubindex[3].pObject;
    +00541       MSG_WAR(0x3A44, "Found nodeId server = ", *pwNodeId);     
    +00542       if(*pwNodeId == sdo.nodeId) {
     00543         found = 1;
     00544         break;          
     00545       }      
    @@ -381,80 +381,80 @@
     00547       sdoNum ++;
     00548     }
     00549     if (! found){
    -00550       MSG_WAR (0x2A45, "No SDO client corresponds to the mesage to send to node ", sdo.nodeId);
    +00550       MSG_WAR (0x2A45, "No SDO client corresponds to the mesage to send to node ", sdo.nodeId);
     00551       return 0xFF;
     00552     }
     00553     /* Second, read the cobid client->server */
    -00554     pwCobId = d->objdict[offset].pSubindex[1].pObject;
    +00554     pwCobId = (UNS32*) d->objdict[offset].pSubindex[1].pObject;
     00555   }
     00556   /* message copy for sending */
    -00557   m.cob_id.w = *pwCobId;
    -00558   m.rtr = NOT_A_REQUEST; 
    +00557   m.cob_id.w = *pwCobId;
    +00558   m.rtr = NOT_A_REQUEST; 
     00559   /* the length of SDO must be 8 */
    -00560   m.len = 8;
    +00560   m.len = 8;
     00561   for (i = 0 ; i < 8 ; i++) {
    -00562     m.data[i] =  sdo.body.data[i];
    +00562     m.data[i] =  sdo.body.data[i];
     00563   }
    -00564   return canSend(d->canHandle,&m);
    +00564   return canSend(d->canHandle,&m);
     00565 }
     00566 
    -00578 UNS8 sendSDOabort (CO_Data* d, UNS8 whoami, UNS16 index, UNS8 subIndex, UNS32 abortCode)
    +00578 UNS8 sendSDOabort (CO_Data* d, UNS8 whoami, UNS16 index, UNS8 subIndex, UNS32 abortCode)
     00579 {
     00580   s_SDO sdo;
    -00581   UNS8 ret;
    -00582   MSG_WAR(0x2A50,"Sending SDO abort ", abortCode);
    -00583   sdo.nodeId = *d->bDeviceNodeId;
    -00584   sdo.body.data[0] = 0x80;
    +00581   UNS8 ret;
    +00582   MSG_WAR(0x2A50,"Sending SDO abort ", abortCode);
    +00583   sdo.nodeId = *d->bDeviceNodeId;
    +00584   sdo.body.data[0] = 0x80;
     00585   /* Index */
    -00586   sdo.body.data[1] = index & 0xFF; /* LSB */
    -00587   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +00586   sdo.body.data[1] = index & 0xFF; /* LSB */
    +00587   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
     00588   /* Subindex */
    -00589   sdo.body.data[3] = subIndex;
    +00589   sdo.body.data[3] = subIndex;
     00590   /* Data */
    -00591   sdo.body.data[4] = (UNS8)(abortCode & 0xFF);
    -00592   sdo.body.data[5] = (UNS8)((abortCode >> 8) & 0xFF);
    -00593   sdo.body.data[6] = (UNS8)((abortCode >> 16) & 0xFF);
    -00594   sdo.body.data[7] = (UNS8)((abortCode >> 24) & 0xFF);
    -00595   ret = sendSDO(d, whoami, sdo);
    +00591   sdo.body.data[4] = (UNS8)(abortCode & 0xFF);
    +00592   sdo.body.data[5] = (UNS8)((abortCode >> 8) & 0xFF);
    +00593   sdo.body.data[6] = (UNS8)((abortCode >> 16) & 0xFF);
    +00594   sdo.body.data[7] = (UNS8)((abortCode >> 24) & 0xFF);
    +00595   ret = sendSDO(d, whoami, sdo);
     00596 
     00597   return ret;
     00598 }
     00599 
    -00608 UNS8 proceedSDO (CO_Data* d, Message *m)
    +00608 UNS8 proceedSDO (CO_Data* d, Message *m)
     00609 {
    -00610   UNS8 err;
    -00611   UNS8 line;
    -00612   UNS8 nbBytes; /* received or to be transmited. */
    -00613   UNS8 nodeId = 0;  /* The node from which the SDO is received */
    -00614   UNS32 nodeId_32; /* node id in 32 bits, for temporary use */
    -00615   UNS32 *pNodeId = NULL;
    -00616   UNS8 whoami = SDO_UNKNOWN;  /* SDO_SERVER or SDO_CLIENT.*/
    -00617   UNS32 errorCode; /* while reading or writing in the local object dictionary.*/
    +00610   UNS8 err;
    +00611   UNS8 line;
    +00612   UNS8 nbBytes; /* received or to be transmited. */
    +00613   UNS8 nodeId = 0;  /* The node from which the SDO is received */
    +00614   UNS32 nodeId_32; /* node id in 32 bits, for temporary use */
    +00615   UNS32 *pNodeId = NULL;
    +00616   UNS8 whoami = SDO_UNKNOWN;  /* SDO_SERVER or SDO_CLIENT.*/
    +00617   UNS32 errorCode; /* while reading or writing in the local object dictionary.*/
     00618   s_SDO sdo;    /* SDO to transmit */
    -00619   UNS16 index;
    -00620   UNS8 subIndex;
    -00621   UNS32 abortCode;
    -00622   UNS8 i,j;
    -00623   UNS32 *     pCobId = NULL;
    -00624   UNS16 offset;
    -00625   UNS16 lastIndex;
    +00619   UNS16 index;
    +00620   UNS8 subIndex;
    +00621   UNS32 abortCode;
    +00622   UNS8 i,j;
    +00623   UNS32 *     pCobId = NULL;
    +00624   UNS16 offset;
    +00625   UNS16 lastIndex;
     00626 
    -00627   MSG_WAR(0x3A60, "proceedSDO ", 0);
    -00628   whoami = SDO_UNKNOWN;
    +00627   MSG_WAR(0x3A60, "proceedSDO ", 0);
    +00628   whoami = SDO_UNKNOWN;
     00629   /* Looking for the cobId in the object dictionary. */
     00630   /* Am-I a server ? */
    -00631   offset = d->firstIndex->SDO_SVR;
    -00632   lastIndex = d->lastIndex->SDO_SVR;
    +00631   offset = d->firstIndex->SDO_SVR;
    +00632   lastIndex = d->lastIndex->SDO_SVR;
     00633   j = 0;
     00634   if(offset) while (offset <= lastIndex) {
    -00635      if (d->objdict[offset].bSubCount <= 1) {
    -00636           MSG_ERR(0x1A61, "Subindex 1  not found at index ", 0x1200 + j);
    +00635      if (d->objdict[offset].bSubCount <= 1) {
    +00636           MSG_ERR(0x1A61, "Subindex 1  not found at index ", 0x1200 + j);
     00637           return 0xFF;
     00638         }
    -00639       pCobId = d->objdict[offset].pSubindex[1].pObject;
    -00640       if ( *pCobId == (*m).cob_id.w ) {
    -00641         whoami = SDO_SERVER;
    -00642         MSG_WAR(0x3A62, "proceedSDO. I am server. index : ", 0x1200 + j);
    +00639       pCobId = (UNS32*) d->objdict[offset].pSubindex[1].pObject;
    +00640       if ( *pCobId == (*m).cob_id.w ) {
    +00641         whoami = SDO_SERVER;
    +00642         MSG_WAR(0x3A62, "proceedSDO. I am server. index : ", 0x1200 + j);
     00643         /* In case of server, the node id of the client may be unknown. So we put the index minus offset */
     00644         /* 0x1200 where the cobid received is defined. */
     00645         nodeId = j;
    @@ -463,161 +463,161 @@
     00648       j++;
     00649       offset++;
     00650   } /* end while */
    -00651   if (whoami == SDO_UNKNOWN) {
    +00651   if (whoami == SDO_UNKNOWN) {
     00652     /* Am-I client ? */
    -00653     offset = d->firstIndex->SDO_CLT;
    -00654     lastIndex = d->lastIndex->SDO_CLT;
    +00653     offset = d->firstIndex->SDO_CLT;
    +00654     lastIndex = d->lastIndex->SDO_CLT;
     00655     j = 0;
     00656     if(offset) while (offset <= lastIndex) {
    -00657        if (d->objdict[offset].bSubCount <= 3) {
    -00658          MSG_ERR(0x1A63, "Subindex 3  not found at index ", 0x1280 + j);
    +00657        if (d->objdict[offset].bSubCount <= 3) {
    +00658          MSG_ERR(0x1A63, "Subindex 3  not found at index ", 0x1280 + j);
     00659          return 0xFF;
     00660        }
     00661        /* a) Looking for the cobid received. */
    -00662        pCobId = d->objdict[offset].pSubindex[2].pObject;
    -00663        if (*pCobId == (*m).cob_id.w ) {
    +00662        pCobId = (UNS32*) d->objdict[offset].pSubindex[2].pObject;
    +00663        if (*pCobId == (*m).cob_id.w ) {
     00664          /* b) cobid found, so reading the node id of the server. */
    -00665          pNodeId = d->objdict[offset].pSubindex[3].pObject;
    -00666          whoami = SDO_CLIENT;
    +00665          pNodeId = (UNS32*) d->objdict[offset].pSubindex[3].pObject;
    +00666          whoami = SDO_CLIENT;
     00667          nodeId_32 = *pNodeId;
    -00668          nodeId = (UNS8)nodeId_32;
    -00669          MSG_WAR(0x3A64, "proceedSDO. I am server. index : ", 0x1280 + j);
    -00670          MSG_WAR(0x3A65, "                 Server nodeId : ", nodeId);
    +00668          nodeId = (UNS8)nodeId_32;
    +00669          MSG_WAR(0x3A64, "proceedSDO. I am server. index : ", 0x1280 + j);
    +00670          MSG_WAR(0x3A65, "                 Server nodeId : ", nodeId);
     00671          break;
     00672         }
     00673        j++;
     00674        offset++;
     00675     } /* end while */
     00676   }
    -00677   if (whoami == SDO_UNKNOWN) {
    +00677   if (whoami == SDO_UNKNOWN) {
     00678     return 0xFF;/* This SDO was not for us ! */
     00679   }
     00680 
     00681   /* Test if the size of the SDO is ok */
     00682   if ( (*m).len != 8) {
    -00683     MSG_ERR(0x1A67, "Error size SDO. CobId  : ", (*m).cob_id.w);
    -00684     failedSDO(d, nodeId, whoami, 0, 0, SDOABT_GENERAL_ERROR);
    +00683     MSG_ERR(0x1A67, "Error size SDO. CobId  : ", (*m).cob_id.w);
    +00684     failedSDO(d, nodeId, whoami, 0, 0, SDOABT_GENERAL_ERROR);
     00685     return 0xFF;
     00686   }
     00687   
    -00688   if (whoami == SDO_CLIENT) {
    -00689     MSG_WAR(0x3A68, "I am CLIENT. Received SDO from nodeId : ", nodeId);
    +00688   if (whoami == SDO_CLIENT) {
    +00689     MSG_WAR(0x3A68, "I am CLIENT. Received SDO from nodeId : ", nodeId);
     00690   }
     00691   else {
    -00692     MSG_WAR(0x3A69, "I am SERVER. Received SDO cobId : ", (*m).cob_id.w);
    +00692     MSG_WAR(0x3A69, "I am SERVER. Received SDO cobId : ", (*m).cob_id.w);
     00693   }
     00694     
     00695   /* Testing the command specifier */
     00696   /* Allowed : cs = 0, 1, 2, 3, 4. (=  all except those for block tranfert). */
     00697   /* cs = other : Not allowed -> abort. */
    -00698   switch (getSDOcs(m->data[0])) {
    +00698   switch (getSDOcs(m->data[0])) {
     00699 
     00700   case 0:
     00701     /* I am SERVER */
    -00702     if (whoami == SDO_SERVER) {
    +00702     if (whoami == SDO_SERVER) {
     00703       /* Receiving a download segment data. */
     00704       /* A SDO transfert should have been yet initiated. */
    -00705       err = getSDOlineOnUse( d, nodeId, whoami, &line ); 
    +00705       err = getSDOlineOnUse( d, nodeId, whoami, &line ); 
     00706       if (!err)
    -00707         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
    +00707         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
     00708       if (err) {
    -00709         MSG_ERR(0x1A70, "SDO error : Received download segment for unstarted trans. index 0x1200 + ", 
    +00709         MSG_ERR(0x1A70, "SDO error : Received download segment for unstarted trans. index 0x1200 + ", 
     00710                 nodeId); 
    -00711         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +00711         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     00712         return 0xFF;
     00713       }
     00714       /* Reset the wathdog */
    -00715       RestartSDO_TIMER(line)
    -00716       MSG_WAR(0x3A71, "Received SDO download segment defined at index 0x1200 + ", nodeId); 
    -00717       index = d->transfers[line].index;
    -00718       subIndex = d->transfers[line].subIndex;
    +00715       RestartSDO_TIMER(line)
    +00716       MSG_WAR(0x3A71, "Received SDO download segment defined at index 0x1200 + ", nodeId); 
    +00717       index = d->transfers[line].index;
    +00718       subIndex = d->transfers[line].subIndex;
     00719       /* Toggle test. */
    -00720       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    -00721         MSG_ERR(0x1A72, "SDO error : Toggle error : ", getSDOt(m->data[0])); 
    -00722         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
    +00720       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    +00721         MSG_ERR(0x1A72, "SDO error : Toggle error : ", getSDOt(m->data[0])); 
    +00722         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
     00723         return 0xFF;
     00724       }
     00725       /* Nb of data to be downloaded */
    -00726       nbBytes = 7 - getSDOn3(m->data[0]);
    +00726       nbBytes = 7 - getSDOn3(m->data[0]);
     00727       /* Store the data in the transfert structure. */
    -00728       err = SDOtoLine(d, line, nbBytes, (*m).data + 1);
    +00728       err = SDOtoLine(d, line, nbBytes, (*m).data + 1);
     00729       if (err) {
    -00730         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00730         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00731         return 0xFF;
     00732       }
     00733       /* Sending the SDO response, CS = 1 */
    -00734       sdo.nodeId = *d->bDeviceNodeId; /* The node id of the server, (here it is the sender). */
    -00735       sdo.body.data[0] = (1 << 5) | (d->transfers[line].toggle << 4);
    +00734       sdo.nodeId = *d->bDeviceNodeId; /* The node id of the server, (here it is the sender). */
    +00735       sdo.body.data[0] = (1 << 5) | (d->transfers[line].toggle << 4);
     00736       for (i = 1 ; i < 8 ; i++)
    -00737         sdo.body.data[i] = 0;
    -00738       MSG_WAR(0x3A73, "SDO. Send response to download request defined at index 0x1200 + ", nodeId); 
    -00739       sendSDO(d, whoami, sdo);
    +00737         sdo.body.data[i] = 0;
    +00738       MSG_WAR(0x3A73, "SDO. Send response to download request defined at index 0x1200 + ", nodeId); 
    +00739       sendSDO(d, whoami, sdo);
     00740       /* Inverting the toggle for the next segment. */
     00741       d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
     00742       /* If it was the last segment, */
    -00743       if (getSDOc(m->data[0])) {
    +00743       if (getSDOc(m->data[0])) {
     00744         /* Transfering line data to object dictionary. */
     00745         /* The code does not use the "d" of initiate frame. So it is safe if e=s=0 */
    -00746         errorCode = SDOlineToObjdict(d, line);
    +00746         errorCode = SDOlineToObjdict(d, line);
     00747         if (errorCode) {
    -00748           MSG_ERR(0x1A54, "SDO error : Unable to copy the data in the object dictionary", 0); 
    -00749           failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
    +00748           MSG_ERR(0x1A54, "SDO error : Unable to copy the data in the object dictionary", 0); 
    +00749           failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
     00750           return 0xFF;    
     00751         }
     00752         /* Release of the line */
    -00753         resetSDOline(d, line);
    -00754         MSG_WAR(0x3A74, "SDO. End of download defined at index 0x1200 + ", nodeId); 
    +00753         resetSDOline(d, line);
    +00754         MSG_WAR(0x3A74, "SDO. End of download defined at index 0x1200 + ", nodeId); 
     00755       }
     00756     } /* end if SERVER */
     00757     else { /* if CLIENT */
     00758       /* I am CLIENT */
     00759       /* It is a request for a previous upload segment. We should find a line opened for this.*/
    -00760       err = getSDOlineOnUse( d, nodeId, whoami, &line);
    +00760       err = getSDOlineOnUse( d, nodeId, whoami, &line);
     00761       if (!err)
    -00762         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
    +00762         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
     00763       if (err) {
    -00764         MSG_ERR(0x1A75, "SDO error : Received segment response for unknown trans. from nodeId", nodeId); 
    -00765         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +00764         MSG_ERR(0x1A75, "SDO error : Received segment response for unknown trans. from nodeId", nodeId); 
    +00765         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     00766         return 0xFF;
     00767       }
     00768       /* Reset the wathdog */
    -00769       RestartSDO_TIMER(line)
    -00770       index = d->transfers[line].index;
    -00771       subIndex = d->transfers[line].subIndex;
    +00769       RestartSDO_TIMER(line)
    +00770       index = d->transfers[line].index;
    +00771       subIndex = d->transfers[line].subIndex;
     00772       /* test of the toggle; */
    -00773       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    -00774         MSG_ERR(0x1A76, "SDO error : Received segment response Toggle error. from nodeId", nodeId); 
    -00775         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
    +00773       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    +00774         MSG_ERR(0x1A76, "SDO error : Received segment response Toggle error. from nodeId", nodeId); 
    +00775         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
     00776         return 0xFF;
     00777       }
     00778       /* nb of data to be uploaded */
    -00779       nbBytes = 7 - getSDOn3(m->data[0]);
    +00779       nbBytes = 7 - getSDOn3(m->data[0]);
     00780       /* Storing the data in the line structure. */
    -00781       err = SDOtoLine(d, line, nbBytes, (*m).data + 1);
    +00781       err = SDOtoLine(d, line, nbBytes, (*m).data + 1);
     00782       if (err) {
    -00783         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00783         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00784         return 0xFF;
     00785       }
     00786       /* Inverting the toggle for the next segment. */
    -00787       d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    +00787       d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
     00788       /* If it was the last segment,*/
    -00789       if ( getSDOc(m->data[0])) {
    +00789       if ( getSDOc(m->data[0])) {
     00790         /* Put in state finished */
     00791         /* The code is safe for the case e=s=0 in initiate frame. */
    -00792         StopSDO_TIMER(line)
    -00793         d->transfers[line].state = SDO_FINISHED;
    -00794         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
    +00792         StopSDO_TIMER(line)
    +00793         d->transfers[line].state = SDO_FINISHED;
    +00794         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
     00795         
    -00796         MSG_WAR(0x3A77, "SDO. End of upload from node : ", nodeId);
    +00796         MSG_WAR(0x3A77, "SDO. End of upload from node : ", nodeId);
     00797       }
     00798       else { /* more segments to receive */
     00799              /* Sending the request for the next segment. */
    -00800         sdo.nodeId = nodeId;
    -00801         sdo.body.data[0] = (3 << 5) | (d->transfers[line].toggle << 4);
    +00800         sdo.nodeId = nodeId;
    +00801         sdo.body.data[0] = (3 << 5) | (d->transfers[line].toggle << 4);
     00802         for (i = 1 ; i < 8 ; i++)
    -00803           sdo.body.data[i] = 0;
    -00804         sendSDO(d, whoami, sdo);
    -00805         MSG_WAR(0x3A78, "SDO send upload segment request to nodeId", nodeId);
    +00803           sdo.body.data[i] = 0;
    +00804         sendSDO(d, whoami, sdo);
    +00805         MSG_WAR(0x3A78, "SDO send upload segment request to nodeId", nodeId);
     00806       }            
     00807     } /* End if CLIENT */
     00808     break;
    @@ -625,475 +625,475 @@
     00810   case 1:
     00811     /* I am SERVER */
     00812     /* Receive of an initiate download */
    -00813     if (whoami == SDO_SERVER) {
    -00814       index = getSDOindex(m->data[1],m->data[2]);
    -00815       subIndex = getSDOsubIndex(m->data[3]);
    -00816       MSG_WAR(0x3A79, "Received SDO Initiate Download (to store data) defined at index 0x1200 + ", 
    +00813     if (whoami == SDO_SERVER) {
    +00814       index = getSDOindex(m->data[1],m->data[2]);
    +00815       subIndex = getSDOsubIndex(m->data[3]);
    +00816       MSG_WAR(0x3A79, "Received SDO Initiate Download (to store data) defined at index 0x1200 + ", 
     00817               nodeId); 
    -00818       MSG_WAR(0x3A80, "Writing at index : ", index);
    -00819       MSG_WAR(0x3A80, "Writing at subIndex : ", subIndex);
    +00818       MSG_WAR(0x3A80, "Writing at index : ", index);
    +00819       MSG_WAR(0x3A80, "Writing at subIndex : ", subIndex);
     00820       
     00821       /* Search if a SDO transfert have been yet initiated */
    -00822       err = getSDOlineOnUse( d, nodeId, whoami, &line );
    +00822       err = getSDOlineOnUse( d, nodeId, whoami, &line );
     00823       if (! err) {
    -00824         MSG_ERR(0x1A81, "SDO error : Transmission yet started.", 0); 
    -00825         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
    +00824         MSG_ERR(0x1A81, "SDO error : Transmission yet started.", 0); 
    +00825         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
     00826         return 0xFF;
     00827       }
     00828       /* No line on use. Great ! */
     00829       /* Try to open a new line. */
    -00830       err = getSDOfreeLine( d, whoami, &line );
    +00830       err = getSDOfreeLine( d, whoami, &line );
     00831       if (err) {
    -00832         MSG_ERR(0x1A82, "SDO error : No line free, too many SDO in progress. Aborted.", 0);
    -00833         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
    +00832         MSG_ERR(0x1A82, "SDO error : No line free, too many SDO in progress. Aborted.", 0);
    +00833         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
     00834         return 0xFF;
     00835       }
    -00836       initSDOline(d, line, nodeId, index, subIndex, SDO_DOWNLOAD_IN_PROGRESS);      
    +00836       initSDOline(d, line, nodeId, index, subIndex, SDO_DOWNLOAD_IN_PROGRESS);      
     00837 
    -00838       if (getSDOe(m->data[0])) { /* If SDO expedited */
    +00838       if (getSDOe(m->data[0])) { /* If SDO expedited */
     00839         /* nb of data to be downloaded */
    -00840         nbBytes = 4 - getSDOn2(m->data[0]);
    +00840         nbBytes = 4 - getSDOn2(m->data[0]);
     00841         /* Storing the data in the line structure. */
    -00842         d->transfers[line].count = nbBytes;
    -00843         err = SDOtoLine(d, line, nbBytes, (*m).data + 4);
    +00842         d->transfers[line].count = nbBytes;
    +00843         err = SDOtoLine(d, line, nbBytes, (*m).data + 4);
     00844         
     00845         if (err) {
    -00846           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00846           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00847           return 0xFF;
     00848         }         
     00849 
     00850         /* SDO expedited -> transfert finished. Data can be stored in the dictionary. */
     00851         /*The line will be reseted when it is downloading in the dictionary. */
    -00852         MSG_WAR(0x3A83, "SDO Initiate Download is an expedited transfert. Finished.: ", nodeId);
    +00852         MSG_WAR(0x3A83, "SDO Initiate Download is an expedited transfert. Finished.: ", nodeId);
     00853         /* Transfering line data to object dictionary. */
    -00854         errorCode = SDOlineToObjdict(d, line);
    +00854         errorCode = SDOlineToObjdict(d, line);
     00855         if (errorCode) {
    -00856           MSG_ERR(0x1A84, "SDO error : Unable to copy the data in the object dictionary", 0); 
    -00857           failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
    +00856           MSG_ERR(0x1A84, "SDO error : Unable to copy the data in the object dictionary", 0); 
    +00857           failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
     00858           return 0xFF;
     00859         }
     00860         /* Release of the line. */
    -00861         resetSDOline(d, line);
    +00861         resetSDOline(d, line);
     00862       }
     00863       else {/* So, if it is not an expedited transfert */
    -00864         if (getSDOs(m->data[0])) {
    +00864         if (getSDOs(m->data[0])) {
     00865           /* TODO : if e and s = 0, not reading m->data[4] but put nbBytes = 0 */
    -00866           nbBytes = m->data[4]; /* Transfert limited to 255 bytes. */
    -00867           err = setSDOlineRestBytes(d, nodeId, nbBytes);
    +00866           nbBytes = m->data[4]; /* Transfert limited to 255 bytes. */
    +00867           err = setSDOlineRestBytes(d, nodeId, nbBytes);
     00868           if (err) {
    -00869             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00869             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00870             return 0xFF;
     00871           }     
     00872         }
     00873       }
     00874       /*Sending a SDO, cs=3*/
    -00875       sdo.nodeId = *d->bDeviceNodeId; /* The node id of the server, (here it is the sender).*/
    -00876       sdo.body.data[0] = 3 << 5;
    -00877       sdo.body.data[1] = index & 0xFF;        /* LSB */
    -00878       sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    -00879       sdo.body.data[3] = subIndex;
    +00875       sdo.nodeId = *d->bDeviceNodeId; /* The node id of the server, (here it is the sender).*/
    +00876       sdo.body.data[0] = 3 << 5;
    +00877       sdo.body.data[1] = index & 0xFF;        /* LSB */
    +00878       sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +00879       sdo.body.data[3] = subIndex;
     00880       for (i = 4 ; i < 8 ; i++)
    -00881                 sdo.body.data[i] = 0;
    -00882       sendSDO(d, whoami, sdo);
    +00881                 sdo.body.data[i] = 0;
    +00882       sendSDO(d, whoami, sdo);
     00883     } /* end if I am SERVER */
     00884     else {
     00885       /* I am CLIENT */
     00886       /* It is a response for a previous download segment. We should find a line opened for this. */
    -00887       err = getSDOlineOnUse( d, nodeId, whoami, &line);
    +00887       err = getSDOlineOnUse( d, nodeId, whoami, &line);
     00888       if (!err)
    -00889         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
    +00889         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
     00890       if (err) {
    -00891         MSG_ERR(0x1A85, "SDO error : Received segment response for unknown trans. from nodeId", nodeId); 
    -00892         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +00891         MSG_ERR(0x1A85, "SDO error : Received segment response for unknown trans. from nodeId", nodeId); 
    +00892         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     00893         return 0xFF;
     00894       }
     00895       /* Reset the wathdog */
    -00896       RestartSDO_TIMER(line)
    -00897       index = d->transfers[line].index;
    -00898       subIndex = d->transfers[line].subIndex;
    +00896       RestartSDO_TIMER(line)
    +00897       index = d->transfers[line].index;
    +00898       subIndex = d->transfers[line].subIndex;
     00899       /* test of the toggle; */
    -00900       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    -00901         MSG_ERR(0x1A86, "SDO error : Received segment response Toggle error. from nodeId", nodeId); 
    -00902         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
    +00900       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    +00901         MSG_ERR(0x1A86, "SDO error : Received segment response Toggle error. from nodeId", nodeId); 
    +00902         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
     00903         return 0xFF;
     00904       }
     00905 
     00906       /* End transmission or downloading next segment. We need to know if it will be the last one. */
    -00907       getSDOlineRestBytes(d, line, &nbBytes);
    +00907       getSDOlineRestBytes(d, line, &nbBytes);
     00908       if (nbBytes == 0) {
    -00909         MSG_WAR(0x3A87, "SDO End download. segment response received. OK. from nodeId", nodeId); 
    -00910         StopSDO_TIMER(line)
    -00911         d->transfers[line].state = SDO_FINISHED;
    -00912         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
    +00909         MSG_WAR(0x3A87, "SDO End download. segment response received. OK. from nodeId", nodeId); 
    +00910         StopSDO_TIMER(line)
    +00911         d->transfers[line].state = SDO_FINISHED;
    +00912         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
     00913         return 0x00;
     00914       }
     00915       /* At least one transfer to send. */
     00916       if (nbBytes > 7) {
     00917         /* several segments to download.*/
     00918         /* code to send the next segment. (cs = 0; c = 0) */
    -00919         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    -00920         sdo.nodeId = nodeId; /* The server node Id; */
    -00921         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    -00922         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
    +00919         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    +00920         sdo.nodeId = nodeId; /* The server node Id; */
    +00921         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    +00922         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
     00923         if (err) {
    -00924           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00924           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00925           return 0xFF;
     00926         }
     00927       } 
     00928       else {
     00929         /* Last segment. */
     00930         /* code to send the last segment. (cs = 0; c = 1)*/
    -00931         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    -00932         sdo.nodeId = nodeId; /* The server node Id; */
    -00933         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    -00934         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
    +00931         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    +00932         sdo.nodeId = nodeId; /* The server node Id; */
    +00933         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    +00934         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
     00935         if (err) {
    -00936           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +00936           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     00937           return 0xFF;
     00938         }
     00939         for (i = nbBytes + 1 ; i < 8 ; i++)
    -00940           sdo.body.data[i] = 0;
    +00940           sdo.body.data[i] = 0;
     00941       }
    -00942       MSG_WAR(0x3A88, "SDO sending download segment to nodeId", nodeId); 
    -00943       sendSDO(d, whoami, sdo); 
    +00942       MSG_WAR(0x3A88, "SDO sending download segment to nodeId", nodeId); 
    +00943       sendSDO(d, whoami, sdo); 
     00944     } /* end if I am a CLIENT */                          
     00945     break;
     00946 
     00947   case 2:
     00948     /* I am SERVER */
     00949     /* Receive of an initiate upload.*/
    -00950     if (whoami == SDO_SERVER) {
    -00951       index = getSDOindex(m->data[1],m->data[2]);
    -00952       subIndex = getSDOsubIndex(m->data[3]);
    -00953       MSG_WAR(0x3A89, "Received SDO Initiate upload (to send data) defined at index 0x1200 + ", 
    +00950     if (whoami == SDO_SERVER) {
    +00951       index = getSDOindex(m->data[1],m->data[2]);
    +00952       subIndex = getSDOsubIndex(m->data[3]);
    +00953       MSG_WAR(0x3A89, "Received SDO Initiate upload (to send data) defined at index 0x1200 + ", 
     00954               nodeId); 
    -00955       MSG_WAR(0x3A90, "Reading at index : ", index);
    -00956       MSG_WAR(0x3A91, "Reading at subIndex : ", subIndex);
    +00955       MSG_WAR(0x3A90, "Reading at index : ", index);
    +00956       MSG_WAR(0x3A91, "Reading at subIndex : ", subIndex);
     00957       /* Search if a SDO transfert have been yet initiated*/
    -00958       err = getSDOlineOnUse( d, nodeId, whoami, &line );
    +00958       err = getSDOlineOnUse( d, nodeId, whoami, &line );
     00959       if (! err) {
    -00960             MSG_ERR(0x1A92, "SDO error : Transmission yet started at line : ", line); 
    -00961         MSG_WAR(0x3A93, "nodeId = ", nodeId); 
    -00962             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
    +00960             MSG_ERR(0x1A92, "SDO error : Transmission yet started at line : ", line); 
    +00961         MSG_WAR(0x3A93, "nodeId = ", nodeId); 
    +00962             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
     00963             return 0xFF;
     00964       }
     00965       /* No line on use. Great !*/
     00966       /* Try to open a new line.*/
    -00967       err = getSDOfreeLine( d, whoami, &line );
    +00967       err = getSDOfreeLine( d, whoami, &line );
     00968       if (err) {
    -00969         MSG_ERR(0x1A71, "SDO error : No line free, too many SDO in progress. Aborted.", 0);
    -00970         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
    +00969         MSG_ERR(0x1A71, "SDO error : No line free, too many SDO in progress. Aborted.", 0);
    +00970         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_LOCAL_CTRL_ERROR);
     00971         return 0xFF;
     00972       }
    -00973       initSDOline(d, line, nodeId, index, subIndex, SDO_UPLOAD_IN_PROGRESS);
    +00973       initSDOline(d, line, nodeId, index, subIndex, SDO_UPLOAD_IN_PROGRESS);
     00974       /* Transfer data from dictionary to the line structure. */
    -00975       errorCode = objdictToSDOline(d, line);
    +00975       errorCode = objdictToSDOline(d, line);
     00976      
     00977       if (errorCode) {
    -00978         MSG_ERR(0x1A94, "SDO error : Unable to copy the data from object dictionary. Err code : ", 
    +00978         MSG_ERR(0x1A94, "SDO error : Unable to copy the data from object dictionary. Err code : ", 
     00979                 errorCode); 
    -00980         failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
    +00980         failedSDO(d, nodeId, whoami, index, subIndex, errorCode);
     00981         return 0xFF;
     00982         }
     00983       /* Preparing the response.*/
    -00984       getSDOlineRestBytes(d, line, &nbBytes);   /* Nb bytes to transfer ? */
    -00985       sdo.nodeId = nodeId; /* The server node Id; */
    +00984       getSDOlineRestBytes(d, line, &nbBytes);   /* Nb bytes to transfer ? */
    +00985       sdo.nodeId = nodeId; /* The server node Id; */
     00986       if (nbBytes > 4) {
     00987         /* normal transfert. (segmented). */
     00988         /* code to send the initiate upload response. (cs = 2) */
    -00989         sdo.body.data[0] = (2 << 5) | 1;
    -00990         sdo.body.data[1] = index & 0xFF;        /* LSB */
    -00991         sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    -00992         sdo.body.data[3] = subIndex;
    -00993         sdo.body.data[4] = nbBytes; /* Limitation of canfestival2 : Max tranfert is 256 bytes.*/
    +00989         sdo.body.data[0] = (2 << 5) | 1;
    +00990         sdo.body.data[1] = index & 0xFF;        /* LSB */
    +00991         sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +00992         sdo.body.data[3] = subIndex;
    +00993         sdo.body.data[4] = nbBytes; /* Limitation of canfestival2 : Max tranfert is 256 bytes.*/
     00994         /* It takes too much memory to upgrate to 2^32 because the size of data is also coded */
     00995         /* in the object dictionary, at every index and subindex. */
     00996         for (i = 5 ; i < 8 ; i++)
    -00997           sdo.body.data[i] = 0;
    -00998         MSG_WAR(0x3A95, "SDO. Sending normal upload initiate response defined at index 0x1200 + ", nodeId); 
    -00999         sendSDO(d, whoami, sdo); 
    +00997           sdo.body.data[i] = 0;
    +00998         MSG_WAR(0x3A95, "SDO. Sending normal upload initiate response defined at index 0x1200 + ", nodeId); 
    +00999         sendSDO(d, whoami, sdo); 
     01000       }
     01001       else {
     01002         /* Expedited upload. (cs = 2 ; e = 1) */
    -01003         sdo.body.data[0] = (2 << 5) | ((4 - nbBytes) << 2) | 3;  
    -01004         sdo.body.data[1] = index & 0xFF;        /* LSB */
    -01005         sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    -01006         sdo.body.data[3] = subIndex;
    -01007         err = lineToSDO(d, line, nbBytes, sdo.body.data + 4);    
    +01003         sdo.body.data[0] = (2 << 5) | ((4 - nbBytes) << 2) | 3;  
    +01004         sdo.body.data[1] = index & 0xFF;        /* LSB */
    +01005         sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +01006         sdo.body.data[3] = subIndex;
    +01007         err = lineToSDO(d, line, nbBytes, sdo.body.data + 4);    
     01008         if (err) {
    -01009           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01009           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01010           return 0xFF;
     01011         }
     01012         for (i = 4 + nbBytes ; i < 8 ; i++)
    -01013           sdo.body.data[i] = 0;
    -01014         MSG_WAR(0x3A96, "SDO. Sending expedited upload initiate response defined at index 0x1200 + ", 
    +01013           sdo.body.data[i] = 0;
    +01014         MSG_WAR(0x3A96, "SDO. Sending expedited upload initiate response defined at index 0x1200 + ", 
     01015                 nodeId); 
    -01016         sendSDO(d, whoami, sdo); 
    +01016         sendSDO(d, whoami, sdo); 
     01017         /* Release the line.*/
    -01018         resetSDOline(d, line);
    +01018         resetSDOline(d, line);
     01019       }
     01020     } /* end if I am SERVER*/
     01021     else {
     01022       /* I am CLIENT */
     01023       /* It is the response for the previous initiate upload request.*/
     01024       /* We should find a line opened for this. */
    -01025       err = getSDOlineOnUse( d, nodeId, whoami, &line);
    +01025       err = getSDOlineOnUse( d, nodeId, whoami, &line);
     01026       if (!err)
    -01027         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
    +01027         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
     01028       if (err) {
    -01029         MSG_ERR(0x1A97, "SDO error : Received response for unknown upload request from nodeId", nodeId); 
    -01030         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +01029         MSG_ERR(0x1A97, "SDO error : Received response for unknown upload request from nodeId", nodeId); 
    +01030         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     01031         return 0xFF;
     01032       }
     01033       /* Reset the wathdog */
    -01034       RestartSDO_TIMER(line)
    -01035       index = d->transfers[line].index;
    -01036       subIndex = d->transfers[line].subIndex;
    +01034       RestartSDO_TIMER(line)
    +01035       index = d->transfers[line].index;
    +01036       subIndex = d->transfers[line].subIndex;
     01037       
    -01038       if (getSDOe(m->data[0])) { /* If SDO expedited */
    +01038       if (getSDOe(m->data[0])) { /* If SDO expedited */
     01039         /* nb of data to be uploaded */
    -01040           nbBytes = 4 - getSDOn2(m->data[0]);
    +01040           nbBytes = 4 - getSDOn2(m->data[0]);
     01041         /* Storing the data in the line structure. */
    -01042         err = SDOtoLine(d, line, nbBytes, (*m).data + 4);
    +01042         err = SDOtoLine(d, line, nbBytes, (*m).data + 4);
     01043         if (err) {
    -01044           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01044           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01045           return 0xFF;
     01046         }
     01047         /* SDO expedited -> transfert finished. data are available via  getReadResultNetworkDict(). */
    -01048         MSG_WAR(0x3A98, "SDO expedited upload finished. Response received from node : ", nodeId);
    -01049         StopSDO_TIMER(line)
    -01050         d->transfers[line].count = nbBytes;
    -01051         d->transfers[line].state = SDO_FINISHED;
    -01052         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
    +01048         MSG_WAR(0x3A98, "SDO expedited upload finished. Response received from node : ", nodeId);
    +01049         StopSDO_TIMER(line)
    +01050         d->transfers[line].count = nbBytes;
    +01051         d->transfers[line].state = SDO_FINISHED;
    +01052         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
     01053         return 0;
     01054       }
     01055       else { /* So, if it is not an expedited transfert */
     01056         /* Storing the nb of data to receive. */
    -01057         if (getSDOs(m->data[0])) {
    -01058           nbBytes = m->data[4]; /* Remember the limitation to 255 bytes to transfert */
    -01059           err = setSDOlineRestBytes(d, line, nbBytes);
    +01057         if (getSDOs(m->data[0])) {
    +01058           nbBytes = m->data[4]; /* Remember the limitation to 255 bytes to transfert */
    +01059           err = setSDOlineRestBytes(d, line, nbBytes);
     01060           if (err) {
    -01061             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01061             failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01062             return 0xFF;
     01063           }     
     01064         }
     01065         /* Requesting next segment. (cs = 3) */
    -01066         sdo.nodeId = nodeId;
    -01067         sdo.body.data[0] = 3 << 5;
    +01066         sdo.nodeId = nodeId;
    +01067         sdo.body.data[0] = 3 << 5;
     01068         for (i = 1 ; i < 8 ; i++)
    -01069           sdo.body.data[i] = 0;
    -01070         MSG_WAR(0x3A99, "SDO. Sending upload segment request to node : ", nodeId); 
    -01071         sendSDO(d, whoami, sdo);  
    +01069           sdo.body.data[i] = 0;
    +01070         MSG_WAR(0x3A99, "SDO. Sending upload segment request to node : ", nodeId); 
    +01071         sendSDO(d, whoami, sdo);  
     01072       }
     01073     } /* End if CLIENT */
     01074     break;
     01075 
     01076   case 3:
     01077     /* I am SERVER */
    -01078     if (whoami == SDO_SERVER) {
    +01078     if (whoami == SDO_SERVER) {
     01079       /* Receiving a upload segment. */
     01080       /* A SDO transfert should have been yet initiated. */
    -01081       err = getSDOlineOnUse( d, nodeId, whoami, &line ); 
    +01081       err = getSDOlineOnUse( d, nodeId, whoami, &line ); 
     01082       if (!err)
    -01083         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
    +01083         err = d->transfers[line].state != SDO_UPLOAD_IN_PROGRESS;
     01084       if (err) {
    -01085         MSG_ERR(0x1AA0, "SDO error : Received upload segment for unstarted trans. index 0x1200 + ", 
    +01085         MSG_ERR(0x1AA0, "SDO error : Received upload segment for unstarted trans. index 0x1200 + ", 
     01086                 nodeId); 
    -01087         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +01087         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     01088         return 0xFF;
     01089       }
     01090       /* Reset the wathdog */
    -01091       RestartSDO_TIMER(line)
    -01092       MSG_WAR(0x3AA1, "Received SDO upload segment defined at index 0x1200 + ", nodeId); 
    -01093       index = d->transfers[line].index;
    -01094       subIndex = d->transfers[line].subIndex;
    +01091       RestartSDO_TIMER(line)
    +01092       MSG_WAR(0x3AA1, "Received SDO upload segment defined at index 0x1200 + ", nodeId); 
    +01093       index = d->transfers[line].index;
    +01094       subIndex = d->transfers[line].subIndex;
     01095       /* Toggle test.*/
    -01096       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    -01097         MSG_ERR(0x1AA2, "SDO error : Toggle error : ", getSDOt(m->data[0])); 
    -01098         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
    +01096       if (d->transfers[line].toggle != getSDOt(m->data[0])) {
    +01097         MSG_ERR(0x1AA2, "SDO error : Toggle error : ", getSDOt(m->data[0])); 
    +01098         failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_TOGGLE_NOT_ALTERNED);
     01099         return 0xFF;
     01100       }
     01101       /* Uploading next segment. We need to know if it will be the last one. */
    -01102       getSDOlineRestBytes(d, line, &nbBytes);             
    +01102       getSDOlineRestBytes(d, line, &nbBytes);             
     01103       if (nbBytes > 7) {
     01104         /* The segment to transfer is not the last one.*/
     01105         /* code to send the next segment. (cs = 0; c = 0) */
    -01106         sdo.nodeId = nodeId; /* The server node Id; */
    -01107         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    -01108         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
    +01106         sdo.nodeId = nodeId; /* The server node Id; */
    +01107         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    +01108         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
     01109         if (err) {
    -01110           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01110           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01111           return 0xFF;
     01112         }
     01113         /* Inverting the toggle for the next tranfert. */
    -01114         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    -01115         MSG_WAR(0x3AA3, "SDO. Sending upload segment defined at index 0x1200 + ", nodeId); 
    -01116         sendSDO(d, whoami, sdo); 
    +01114         d->transfers[line].toggle = ! d->transfers[line].toggle & 1;
    +01115         MSG_WAR(0x3AA3, "SDO. Sending upload segment defined at index 0x1200 + ", nodeId); 
    +01116         sendSDO(d, whoami, sdo); 
     01117       } 
     01118       else {
     01119         /* Last segment. */
     01120         /* code to send the last segment. (cs = 0; c = 1) */        
    -01121         sdo.nodeId = nodeId; 
    -01122         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    -01123         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
    +01121         sdo.nodeId = nodeId; 
    +01122         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    +01123         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
     01124         if (err) {
    -01125           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01125           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01126           return 0xFF;
     01127         }
     01128         for (i = nbBytes + 1 ; i < 8 ; i++)
    -01129           sdo.body.data[i] = 0;
    -01130         MSG_WAR(0x3AA4, "SDO. Sending last upload segment defined at index 0x1200 + ", nodeId);      
    -01131         sendSDO(d, whoami, sdo);
    +01129           sdo.body.data[i] = 0;
    +01130         MSG_WAR(0x3AA4, "SDO. Sending last upload segment defined at index 0x1200 + ", nodeId);      
    +01131         sendSDO(d, whoami, sdo);
     01132         /* Release the line */
    -01133         resetSDOline(d, line);
    +01133         resetSDOline(d, line);
     01134       }
     01135     } /* end if SERVER*/
     01136     else {
     01137       /* I am CLIENT */
     01138       /* It is the response for the previous initiate download request. */
     01139       /* We should find a line opened for this. */
    -01140       err = getSDOlineOnUse( d, nodeId, whoami, &line);
    +01140       err = getSDOlineOnUse( d, nodeId, whoami, &line);
     01141       if (!err)
    -01142         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
    +01142         err = d->transfers[line].state != SDO_DOWNLOAD_IN_PROGRESS;
     01143       if (err) {
    -01144         MSG_ERR(0x1AA5, "SDO error : Received response for unknown download request from nodeId", nodeId); 
    -01145         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
    +01144         MSG_ERR(0x1AA5, "SDO error : Received response for unknown download request from nodeId", nodeId); 
    +01145         failedSDO(d, nodeId, whoami, 0, 0, SDOABT_LOCAL_CTRL_ERROR);
     01146         return 0xFF;
     01147       }
     01148       /* Reset the watchdog */
    -01149       RestartSDO_TIMER(line)
    -01150       index = d->transfers[line].index;
    -01151       subIndex = d->transfers[line].subIndex;
    +01149       RestartSDO_TIMER(line)
    +01150       index = d->transfers[line].index;
    +01151       subIndex = d->transfers[line].subIndex;
     01152       /* End transmission or requesting  next segment. */
    -01153       getSDOlineRestBytes(d, line, &nbBytes);
    +01153       getSDOlineRestBytes(d, line, &nbBytes);
     01154       if (nbBytes == 0) {
    -01155         MSG_WAR(0x3AA6, "SDO End download expedited. Response received. from nodeId", nodeId); 
    -01156         StopSDO_TIMER(line)
    -01157         d->transfers[line].state = SDO_FINISHED;
    -01158         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
    +01155         MSG_WAR(0x3AA6, "SDO End download expedited. Response received. from nodeId", nodeId); 
    +01156         StopSDO_TIMER(line)
    +01157         d->transfers[line].state = SDO_FINISHED;
    +01158         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
     01159         return 0x00;
     01160       }   
     01161       if (nbBytes > 7) {
     01162         /* more than one request to send */
     01163         /* code to send the next segment. (cs = 0; c = 0)       */    
    -01164         sdo.nodeId = nodeId; 
    -01165         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    -01166         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
    +01164         sdo.nodeId = nodeId; 
    +01165         sdo.body.data[0] = (d->transfers[line].toggle << 4);
    +01166         err = lineToSDO(d, line, 7, sdo.body.data + 1);  
     01167         if (err) {
    -01168           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01168           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01169           return 0xFF;
     01170         }
     01171       } 
     01172       else {
     01173         /* Last segment.*/
     01174         /* code to send the last segment. (cs = 0; c = 1)       */   
    -01175         sdo.nodeId = nodeId; /* The server node Id; */
    -01176         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    -01177         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
    +01175         sdo.nodeId = nodeId; /* The server node Id; */
    +01176         sdo.body.data[0] = (d->transfers[line].toggle << 4) | ((7 - nbBytes) << 1) | 1;
    +01177         err = lineToSDO(d, line, nbBytes, sdo.body.data + 1);    
     01178         if (err) {
    -01179           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
    +01179           failedSDO(d, nodeId, whoami, index, subIndex, SDOABT_GENERAL_ERROR);
     01180           return 0xFF;
     01181         }
     01182         for (i = nbBytes + 1 ; i < 8 ; i++)
    -01183           sdo.body.data[i] = 0;
    +01183           sdo.body.data[i] = 0;
     01184       }
    -01185       MSG_WAR(0x3AA7, "SDO sending download segment to nodeId", nodeId); 
    -01186       sendSDO(d, whoami, sdo); 
    +01185       MSG_WAR(0x3AA7, "SDO sending download segment to nodeId", nodeId); 
    +01186       sendSDO(d, whoami, sdo); 
     01187 
     01188     } /* end if I am a CLIENT           */        
     01189     break;  
     01190 
     01191    case 4:
     01192      abortCode = (*m).data[3] |
    -01193       ((UNS32)m->data[5] << 8) |
    -01194       ((UNS32)m->data[6] << 16) |
    -01195       ((UNS32)m->data[7] << 24);
    +01193       ((UNS32)m->data[5] << 8) |
    +01194       ((UNS32)m->data[6] << 16) |
    +01195       ((UNS32)m->data[7] << 24);
     01196     /* Received SDO abort. */
     01197     /* Looking for the line concerned. */
    -01198     if (whoami == SDO_SERVER) {
    -01199       err = getSDOlineOnUse( d, nodeId, whoami, &line );
    +01198     if (whoami == SDO_SERVER) {
    +01199       err = getSDOlineOnUse( d, nodeId, whoami, &line );
     01200       if (!err) {
    -01201         resetSDOline( d, line );
    -01202         MSG_WAR(0x3AA8, "SD0. Received SDO abort. Line released. Code : ", abortCode);
    +01201         resetSDOline( d, line );
    +01202         MSG_WAR(0x3AA8, "SD0. Received SDO abort. Line released. Code : ", abortCode);
     01203       }
     01204       else
    -01205         MSG_WAR(0x3AA9, "SD0. Received SDO abort. No line found. Code : ", abortCode);
    +01205         MSG_WAR(0x3AA9, "SD0. Received SDO abort. No line found. Code : ", abortCode);
     01206       /* Tips : The end user has no way to know that the server node has received an abort SDO. */
     01207       /* Its is ok, I think.*/
     01208     }
     01209     else { /* If I am CLIENT */
    -01210       err = getSDOlineOnUse( d, nodeId, whoami, &line );
    +01210       err = getSDOlineOnUse( d, nodeId, whoami, &line );
     01211       if (!err) {
     01212         /* The line *must* be released by the core program. */
    -01213         StopSDO_TIMER(line)
    -01214         d->transfers[line].state = SDO_ABORTED_RCV;
    -01215         d->transfers[line].abortCode = abortCode;
    -01216         MSG_WAR(0x3AB0, "SD0. Received SDO abort. Line state ABORTED. Code : ", abortCode);
    -01217         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
    +01213         StopSDO_TIMER(line)
    +01214         d->transfers[line].state = SDO_ABORTED_RCV;
    +01215         d->transfers[line].abortCode = abortCode;
    +01216         MSG_WAR(0x3AB0, "SD0. Received SDO abort. Line state ABORTED. Code : ", abortCode);
    +01217         if(d->transfers[line].Callback) (*d->transfers[line].Callback)(d,nodeId);
     01218       }
     01219       else
    -01220         MSG_WAR(0x3AB1, "SD0. Received SDO abort. No line found. Code : ", abortCode);
    +01220         MSG_WAR(0x3AB1, "SD0. Received SDO abort. No line found. Code : ", abortCode);
     01221     } 
     01222     break;
     01223   default:
     01224     /* Error : Unknown cs */
    -01225     MSG_ERR(0x1AB2, "SDO. Received unknown command specifier : ", getSDOcs(m->data[0]));
    +01225     MSG_ERR(0x1AB2, "SDO. Received unknown command specifier : ", getSDOcs(m->data[0]));
     01226     return 0xFF;
     01227 
     01228   } /* End switch */
     01229   return 0;     
     01230 }
     01231 
    -01247 INLINE UNS8 _writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    -01248                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback, UNS8 endianize)
    +01247 INLINE UNS8 _writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    +01248                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback, UNS8 endianize)
     01249 {
    -01250   UNS8 err;
    -01251   UNS8 SDOfound = 0;
    -01252   UNS8 line;
    +01250   UNS8 err;
    +01251   UNS8 SDOfound = 0;
    +01252   UNS8 line;
     01253   s_SDO sdo;    /* SDO to transmit */
    -01254   UNS8 i, j;
    -01255   UNS16     lastIndex;
    -01256   UNS16     offset;
    -01257   UNS32      *pNodeIdServer;
    -01258   UNS32      nodeIdServer;
    +01254   UNS8 i, j;
    +01255   UNS16     lastIndex;
    +01256   UNS16     offset;
    +01257   UNS32      *pNodeIdServer;
    +01258   UNS32      nodeIdServer;
     01259 
    -01260   MSG_WAR(0x3AC0, "Send SDO to write in the dictionary of node : ", nodeId);
    -01261   MSG_WAR(0x3AC1, "                                   At index : ", index);
    -01262   MSG_WAR(0x3AC2, "                                   subIndex : ", subIndex);
    -01263   MSG_WAR(0x3AC3, "                                   nb bytes : ", count);
    +01260   MSG_WAR(0x3AC0, "Send SDO to write in the dictionary of node : ", nodeId);
    +01261   MSG_WAR(0x3AC1, "                                   At index : ", index);
    +01262   MSG_WAR(0x3AC2, "                                   subIndex : ", subIndex);
    +01263   MSG_WAR(0x3AC3, "                                   nb bytes : ", count);
     01264 
     01265   /* Verify that there is no SDO communication yet. */
    -01266   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    +01266   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
     01267   if (!err) {
    -01268     MSG_ERR(0x1AC4, "SDO error : Communication yet established. with node : ", nodeId); 
    +01268     MSG_ERR(0x1AC4, "SDO error : Communication yet established. with node : ", nodeId); 
     01269     return 0xFF;
     01270   }
     01271   /* Taking the line ... */
    -01272   err = getSDOfreeLine( d, SDO_CLIENT, &line );
    +01272   err = getSDOfreeLine( d, SDO_CLIENT, &line );
     01273   if (err) {
    -01274     MSG_ERR(0x1AC5, "SDO error : No line free, too many SDO in progress. Aborted for node : ", nodeId); 
    +01274     MSG_ERR(0x1AC5, "SDO error : No line free, too many SDO in progress. Aborted for node : ", nodeId); 
     01275     return (0xFF);
     01276   }
     01277   /* Check which SDO to use to communicate with the node */
    -01278   offset = d->firstIndex->SDO_CLT;
    -01279   lastIndex = d->lastIndex->SDO_CLT;
    +01278   offset = d->firstIndex->SDO_CLT;
    +01279   lastIndex = d->lastIndex->SDO_CLT;
     01280   if (offset == 0) {
    -01281     MSG_ERR(0x1AC6, "writeNetworkDict : No SDO client index found", 0); 
    +01281     MSG_ERR(0x1AC6, "writeNetworkDict : No SDO client index found", 0); 
     01282     return 0xFF;
     01283   }
     01284   i = 0;
     01285    while (offset <= lastIndex) {
    -01286      if (d->objdict[offset].bSubCount <= 3) {
    -01287          MSG_ERR(0x1AC8, "Subindex 3  not found at index ", 0x1280 + i);
    +01286      if (d->objdict[offset].bSubCount <= 3) {
    +01287          MSG_ERR(0x1AC8, "Subindex 3  not found at index ", 0x1280 + i);
     01288          return 0xFF;
     01289      }
     01290      /* looking for the nodeId server */
    -01291      pNodeIdServer = d->objdict[offset].pSubindex[3].pObject;
    +01291      pNodeIdServer = (UNS32*) d->objdict[offset].pSubindex[3].pObject;
     01292      nodeIdServer = *pNodeIdServer;
    -01293      MSG_WAR(0x1AD2, "index : ", 0x1280 + i);
    -01294      MSG_WAR(0x1AD3, "nodeIdServer : ", nodeIdServer);
    +01293      MSG_WAR(0x1AD2, "index : ", 0x1280 + i);
    +01294      MSG_WAR(0x1AD3, "nodeIdServer : ", nodeIdServer);
     01295    
    -01296     if(nodeIdServer == (UNS32)nodeId) {
    +01296     if(nodeIdServer == (UNS32)nodeId) {
     01297       SDOfound = 1;
     01298       break;
     01299     }
    @@ -1101,50 +1101,50 @@
     01301     i++;
     01302   } /* end while */
     01303   if (!SDOfound) {
    -01304     MSG_ERR(0x1AC9, "SDO. Error. No client found to communicate with node : ", nodeId);
    +01304     MSG_ERR(0x1AC9, "SDO. Error. No client found to communicate with node : ", nodeId);
     01305     return 0xFF;
     01306   }
    -01307   MSG_WAR(0x3AD0,"        SDO client defined at index  : ", 0x1280 + i);
    -01308   initSDOline(d, line, nodeId, index, subIndex, SDO_DOWNLOAD_IN_PROGRESS);
    -01309   d->transfers[line].count = count;
    -01310   d->transfers[line].dataType = dataType;
    +01307   MSG_WAR(0x3AD0,"        SDO client defined at index  : ", 0x1280 + i);
    +01308   initSDOline(d, line, nodeId, index, subIndex, SDO_DOWNLOAD_IN_PROGRESS);
    +01309   d->transfers[line].count = count;
    +01310   d->transfers[line].dataType = dataType;
     01311   
     01312   /* Copy data to transfers structure. */
     01313   for (j = 0 ; j < count ; j++) {
    -01314 # ifdef CANOPEN_BIG_ENDIAN
    +01314 # ifdef CANOPEN_BIG_ENDIAN
     01315     if (dataType == 0 && endianize)
    -01316       d->transfers[line].data[count - 1 - j] = ((char *)data)[j];
    +01316       d->transfers[line].data[count - 1 - j] = ((char *)data)[j];
     01317     else /* String of bytes. */
    -01318       d->transfers[line].data[j] = ((char *)data)[j];
    +01318       d->transfers[line].data[j] = ((char *)data)[j];
     01319 #  else 
    -01320     d->transfers[line].data[j] = ((char *)data)[j];
    +01320     d->transfers[line].data[j] = ((char *)data)[j];
     01321 #  endif
     01322   }
     01323   /* Send the SDO to the server. Initiate download, cs=1. */
    -01324   sdo.nodeId = nodeId;
    +01324   sdo.nodeId = nodeId;
     01325   if (count <= 4) { /* Expedited transfert */
    -01326     sdo.body.data[0] = (1 << 5) | ((4 - count) << 2) | 3;
    +01326     sdo.body.data[0] = (1 << 5) | ((4 - count) << 2) | 3;
     01327     for (i = 4 ; i < 8 ; i++)
    -01328       sdo.body.data[i] = d->transfers[line].data[i - 4];
    -01329     d->transfers[line].offset = count;
    +01328       sdo.body.data[i] = d->transfers[line].data[i - 4];
    +01329     d->transfers[line].offset = count;
     01330   }     
     01331   else { 
    -01332     sdo.body.data[0] = (1 << 5) | 1;
    -01333     sdo.body.data[4] = count; /* nb of byte to transmit. Max = 255. (canfestival2 limitation). */
    +01332     sdo.body.data[0] = (1 << 5) | 1;
    +01333     sdo.body.data[4] = count; /* nb of byte to transmit. Max = 255. (canfestival2 limitation). */
     01334     for (i = 5 ; i < 8 ; i++)
    -01335       sdo.body.data[i] = 0;
    +01335       sdo.body.data[i] = 0;
     01336   }
    -01337   sdo.body.data[1] = index & 0xFF;        /* LSB */
    -01338   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    -01339   sdo.body.data[3] = subIndex;
    +01337   sdo.body.data[1] = index & 0xFF;        /* LSB */
    +01338   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +01339   sdo.body.data[3] = subIndex;
     01340 
    -01341   d->transfers[line].Callback = Callback;
    +01341   d->transfers[line].Callback = Callback;
     01342     
    -01343   err = sendSDO(d, SDO_CLIENT, sdo);
    +01343   err = sendSDO(d, SDO_CLIENT, sdo);
     01344   if (err) {
    -01345     MSG_ERR(0x1AD1, "SDO. Error while sending SDO to node : ", nodeId);
    +01345     MSG_ERR(0x1AD1, "SDO. Error while sending SDO to node : ", nodeId);
     01346     /* release the line */
    -01347     resetSDOline(d, line);
    +01347     resetSDOline(d, line);
     01348     return 0xFF;
     01349   }
     01350 
    @@ -1152,67 +1152,67 @@
     01352   return 0;
     01353 }
     01354 
    -01368 UNS8 writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    -01369                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data)
    +01368 UNS8 writeNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, 
    +01369                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data)
     01370 {
    -01371         return _writeNetworkDict (d, nodeId, index, subIndex, count, dataType, data, NULL, 1);
    +01371         return _writeNetworkDict (d, nodeId, index, subIndex, count, dataType, data, NULL, 1);
     01372 }
     01373 
    -01388 UNS8 writeNetworkDictCallBack (CO_Data* d, UNS8 nodeId, UNS16 index, 
    -01389                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback)
    +01388 UNS8 writeNetworkDictCallBack (CO_Data* d, UNS8 nodeId, UNS16 index, 
    +01389                        UNS8 subIndex, UNS8 count, UNS8 dataType, void *data, SDOCallback_t Callback)
     01390 {
    -01391         return _writeNetworkDict (d, nodeId, index, subIndex, count, dataType, data, Callback, 1);      
    +01391         return _writeNetworkDict (d, nodeId, index, subIndex, count, dataType, data, Callback, 1);      
     01392 }
     01393 
    -01406 INLINE UNS8 _readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback)
    +01406 INLINE UNS8 _readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback)
     01407 {
    -01408   UNS8 err;
    -01409   UNS8 SDOfound = 0;
    -01410   UNS8 i;
    -01411   UNS8 line;
    +01408   UNS8 err;
    +01409   UNS8 SDOfound = 0;
    +01410   UNS8 i;
    +01411   UNS8 line;
     01412   s_SDO sdo;    /* SDO to transmit */
    -01413   UNS32      *pNodeIdServer;
    -01414   UNS32      nodeIdServer;
    -01415   UNS16     offset;
    -01416   UNS16     lastIndex;
    -01417   MSG_WAR(0x3AD5, "Send SDO to read in the dictionary of node : ", nodeId);
    -01418   MSG_WAR(0x3AD6, "                                  At index : ", index);
    -01419   MSG_WAR(0x3AD7, "                                  subIndex : ", subIndex);
    +01413   UNS32      *pNodeIdServer;
    +01414   UNS32      nodeIdServer;
    +01415   UNS16     offset;
    +01416   UNS16     lastIndex;
    +01417   MSG_WAR(0x3AD5, "Send SDO to read in the dictionary of node : ", nodeId);
    +01418   MSG_WAR(0x3AD6, "                                  At index : ", index);
    +01419   MSG_WAR(0x3AD7, "                                  subIndex : ", subIndex);
     01420 
     01421 
     01422   /* Verify that there is no SDO communication yet. */
    -01423   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    +01423   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
     01424   if (!err) {
    -01425     MSG_ERR(0x1AD8, "SDO error : Communication yet established. with node : ", nodeId); 
    +01425     MSG_ERR(0x1AD8, "SDO error : Communication yet established. with node : ", nodeId); 
     01426     return 0xFF;
     01427   }
     01428   /* Taking the line ... */
    -01429   err = getSDOfreeLine( d, SDO_CLIENT, &line );
    +01429   err = getSDOfreeLine( d, SDO_CLIENT, &line );
     01430   if (err) {
    -01431     MSG_ERR(0x1AD9, "SDO error : No line free, too many SDO in progress. Aborted for node : ", nodeId); 
    +01431     MSG_ERR(0x1AD9, "SDO error : No line free, too many SDO in progress. Aborted for node : ", nodeId); 
     01432     return (0xFF);
     01433   }
     01434   else
    -01435     MSG_WAR(0x3AE0, "Transmission on line : ", line);
    +01435     MSG_WAR(0x3AE0, "Transmission on line : ", line);
     01436 
     01437   /* Check which SDO to use to communicate with the node */
    -01438   offset = d->firstIndex->SDO_CLT;
    -01439   lastIndex = d->lastIndex->SDO_CLT;
    +01438   offset = d->firstIndex->SDO_CLT;
    +01439   lastIndex = d->lastIndex->SDO_CLT;
     01440   if (offset == 0) {
    -01441     MSG_ERR(0x1AE1, "writeNetworkDict : No SDO client index found", 0); 
    +01441     MSG_ERR(0x1AE1, "writeNetworkDict : No SDO client index found", 0); 
     01442     return 0xFF;
     01443   }
     01444   i = 0;
     01445   while (offset <= lastIndex) {
    -01446      if (d->objdict[offset].bSubCount <= 3) {
    -01447          MSG_ERR(0x1AE2, "Subindex 3  not found at index ", 0x1280 + i);
    +01446      if (d->objdict[offset].bSubCount <= 3) {
    +01447          MSG_ERR(0x1AE2, "Subindex 3  not found at index ", 0x1280 + i);
     01448          return 0xFF;
     01449      }
     01450      /* looking for the nodeId server */
    -01451      pNodeIdServer = d->objdict[offset].pSubindex[3].pObject;
    +01451      pNodeIdServer = (UNS32*) d->objdict[offset].pSubindex[3].pObject;
     01452      nodeIdServer = *pNodeIdServer;
     01453    
    -01454     if(nodeIdServer == (UNS32)nodeId) {
    +01454     if(nodeIdServer == (UNS32)nodeId) {
     01455       SDOfound = 1;
     01456       break;
     01457     }
    @@ -1220,90 +1220,90 @@
     01459     i++;
     01460   } /* end while */
     01461   if (!SDOfound) {
    -01462     MSG_ERR(0x1AE3, "SDO. Error. No client found to communicate with node : ", nodeId);
    +01462     MSG_ERR(0x1AE3, "SDO. Error. No client found to communicate with node : ", nodeId);
     01463     return 0xFF;
     01464   }
    -01465   MSG_WAR(0x3AE4,"        SDO client defined at index  : ", 0x1280 + i);
    -01466   initSDOline(d, line, nodeId, index, subIndex, SDO_UPLOAD_IN_PROGRESS);
    -01467   getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    -01468   sdo.nodeId = nodeId;
    +01465   MSG_WAR(0x3AE4,"        SDO client defined at index  : ", 0x1280 + i);
    +01466   initSDOline(d, line, nodeId, index, subIndex, SDO_UPLOAD_IN_PROGRESS);
    +01467   getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    +01468   sdo.nodeId = nodeId;
     01469   /* Send the SDO to the server. Initiate upload, cs=2. */
    -01470   d->transfers[line].dataType = dataType;                               
    -01471   sdo.body.data[0] = (2 << 5);  
    -01472   sdo.body.data[1] = index & 0xFF;        /* LSB */
    -01473   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    -01474   sdo.body.data[3] = subIndex;
    +01470   d->transfers[line].dataType = dataType;                               
    +01471   sdo.body.data[0] = (2 << 5);  
    +01472   sdo.body.data[1] = index & 0xFF;        /* LSB */
    +01473   sdo.body.data[2] = (index >> 8) & 0xFF; /* MSB */
    +01474   sdo.body.data[3] = subIndex;
     01475   for (i = 4 ; i < 8 ; i++)
    -01476     sdo.body.data[i] = 0;
    -01477   d->transfers[line].Callback = Callback;
    -01478   err = sendSDO(d, SDO_CLIENT, sdo);
    +01476     sdo.body.data[i] = 0;
    +01477   d->transfers[line].Callback = Callback;
    +01478   err = sendSDO(d, SDO_CLIENT, sdo);
     01479   if (err) {
    -01480     MSG_ERR(0x1AE5, "SDO. Error while sending SDO to node : ", nodeId);
    +01480     MSG_ERR(0x1AE5, "SDO. Error while sending SDO to node : ", nodeId);
     01481     /* release the line */
    -01482     resetSDOline(d, line);
    +01482     resetSDOline(d, line);
     01483     return 0xFF;
     01484   }             
     01485   return 0;
     01486 }
     01487 
    -01499 UNS8 readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType)
    +01499 UNS8 readNetworkDict (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType)
     01500 {
    -01501         return _readNetworkDict (d, nodeId, index, subIndex, dataType, NULL);
    +01501         return _readNetworkDict (d, nodeId, index, subIndex, dataType, NULL);
     01502 }
     01503 
    -01516 UNS8 readNetworkDictCallback (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback)
    +01516 UNS8 readNetworkDictCallback (CO_Data* d, UNS8 nodeId, UNS16 index, UNS8 subIndex, UNS8 dataType, SDOCallback_t Callback)
     01517 {
    -01518         return _readNetworkDict (d, nodeId, index, subIndex, dataType, Callback);
    +01518         return _readNetworkDict (d, nodeId, index, subIndex, dataType, Callback);
     01519 }
     01520 
    -01532 UNS8 getReadResultNetworkDict (CO_Data* d, UNS8 nodeId, void* data, UNS8 *size, 
    -01533                                UNS32 * abortCode)
    +01532 UNS8 getReadResultNetworkDict (CO_Data* d, UNS8 nodeId, void* data, UNS8 *size, 
    +01533                                UNS32 * abortCode)
     01534 {
    -01535   UNS8 i;
    -01536   UNS8 err;
    -01537   UNS8 line;
    +01535   UNS8 i;
    +01536   UNS8 err;
    +01537   UNS8 line;
     01538   * size = 0;
     01539 
     01540   /* Looking for the line tranfert. */
    -01541   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    +01541   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
     01542   if (err) {
    -01543     MSG_ERR(0x1AF0, "SDO error : No line found for communication with node : ", nodeId); 
    -01544     return SDO_ABORTED_INTERNAL;
    +01543     MSG_ERR(0x1AF0, "SDO error : No line found for communication with node : ", nodeId); 
    +01544     return SDO_ABORTED_INTERNAL;
     01545   }
    -01546   if (d->transfers[line].state != SDO_FINISHED)
    -01547     return d->transfers[line].state;
    +01546   if (d->transfers[line].state != SDO_FINISHED)
    +01547     return d->transfers[line].state;
     01548 
     01549   /* Transfert is finished. Put the value in the data. */
    -01550   * size = (UNS8)d->transfers[line].count;
    +01550   * size = (UNS8)d->transfers[line].count;
     01551   for  ( i = 0 ; i < *size ; i++) {
    -01552 # ifdef CANOPEN_BIG_ENDIAN
    -01553     if (d->transfers[line].dataType != visible_string)
    -01554       ( (char *) data)[*size - 1 - i] = d->transfers[line].data[i];
    +01552 # ifdef CANOPEN_BIG_ENDIAN
    +01553     if (d->transfers[line].dataType != visible_string)
    +01554       ( (char *) data)[*size - 1 - i] = d->transfers[line].data[i];
     01555     else /* String of bytes. */
    -01556       ( (char *) data)[i] = d->transfers[line].data[i];
    +01556       ( (char *) data)[i] = d->transfers[line].data[i];
     01557 # else 
    -01558     ( (char *) data)[i] = d->transfers[line].data[i];
    +01558     ( (char *) data)[i] = d->transfers[line].data[i];
     01559 # endif
     01560   } 
    -01561   return SDO_FINISHED;
    +01561   return SDO_FINISHED;
     01562 }
     01563 
    -01573 UNS8 getWriteResultNetworkDict (CO_Data* d, UNS8 nodeId, UNS32 * abortCode)
    +01573 UNS8 getWriteResultNetworkDict (CO_Data* d, UNS8 nodeId, UNS32 * abortCode)
     01574 {
    -01575   UNS8 line = 0;
    -01576   UNS8 err;
    +01575   UNS8 line = 0;
    +01576   UNS8 err;
     01577 
     01578   * abortCode = 0;
     01579   /* Looking for the line tranfert. */
    -01580   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
    +01580   err = getSDOlineOnUse(d, nodeId, SDO_CLIENT, &line);
     01581   if (err) {
    -01582     MSG_ERR(0x1AF1, "SDO error : No line found for communication with node : ", nodeId); 
    -01583     return SDO_ABORTED_INTERNAL;
    +01582     MSG_ERR(0x1AF1, "SDO error : No line found for communication with node : ", nodeId); 
    +01583     return SDO_ABORTED_INTERNAL;
     01584   }
    -01585   * abortCode = d->transfers[line].abortCode;
    -01586   return d->transfers[line].state;
    +01585   * abortCode = d->transfers[line].abortCode;
    +01586   return d->transfers[line].state;
     01587 }
    -

    Generated on Fri Jun 8 08:51:39 2007 for CanFestival by  +
    Generated on Mon Jul 2 19:10:16 2007 for CanFestival by  doxygen 1.5.1