examples/AppliMaster_Linux/objdict.c
changeset 93 16c8ceea8f18
parent 92 0d84d95790d9
child 94 bdf4c86be6b2
equal deleted inserted replaced
92:0d84d95790d9 93:16c8ceea8f18
     1 /*
       
     2 This file is part of CanFestival, a library implementing CanOpen Stack. 
       
     3 
       
     4 Copyright (C): Edouard TISSERANT and Francis DUPIN
       
     5 
       
     6 See COPYING file for copyrights details.
       
     7 
       
     8 This library is free software; you can redistribute it and/or
       
     9 modify it under the terms of the GNU Lesser General Public
       
    10 License as published by the Free Software Foundation; either
       
    11 version 2.1 of the License, or (at your option) any later version.
       
    12 
       
    13 This library is distributed in the hope that it will be useful,
       
    14 but WITHOUT ANY WARRANTY; without even the implied warranty of
       
    15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       
    16 Lesser General Public License for more details.
       
    17 
       
    18 You should have received a copy of the GNU Lesser General Public
       
    19 License along with this library; if not, write to the Free Software
       
    20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
       
    21 */
       
    22 
       
    23 #include <stddef.h>
       
    24 
       
    25 #include <applicfg.h>
       
    26 #include "def.h"
       
    27 #include "can.h"
       
    28 #include "objdictdef.h"
       
    29 #include "pdo.h"
       
    30 #include "sdo.h"
       
    31 #include "sync.h"
       
    32 #include "lifegrd.h"
       
    33 #include "nmtSlave.h"
       
    34 
       
    35 /**************************************************************************/
       
    36 /* Declaration of the mapped variables                                    */
       
    37 /**************************************************************************/
       
    38 
       
    39 
       
    40 
       
    41 /*// Copy and uncomment this code to your main file
       
    42 extern UNS32 canopenErrNB_node5;		// Mapped at index 0x6000, subindex 0x00
       
    43 extern UNS32 canopenErrVAL_node5;		// Mapped at index 0x6001, subindex 0x00
       
    44 extern UNS8 second;		// Mapped at index 0x6002, subindex 0x01
       
    45 extern UNS8 minutes;		// Mapped at index 0x6002, subindex 0x02
       
    46 extern UNS8 hour;		// Mapped at index 0x6002, subindex 0x03
       
    47 extern UNS8 day;		// Mapped at index 0x6002, subindex 0x04
       
    48 extern UNS32 canopenErrNB;		// Mapped at index 0x6003, subindex 0x01
       
    49 extern UNS32 canopenErrVAL;		// Mapped at index 0x6003, subindex 0x02
       
    50 
       
    51 // END copy to main file
       
    52 */
       
    53 
       
    54 UNS32 canopenErrNB_node5;		// Mapped at index 0x6000, subindex 0x00
       
    55 UNS32 canopenErrVAL_node5;		// Mapped at index 0x6001, subindex 0x00
       
    56 UNS8 second;		// Mapped at index 0x6002, subindex 0x01
       
    57 UNS8 minutes;		// Mapped at index 0x6002, subindex 0x02
       
    58 UNS8 hour;		// Mapped at index 0x6002, subindex 0x03
       
    59 UNS8 day;		// Mapped at index 0x6002, subindex 0x04
       
    60 UNS32 canopenErrNB;		// Mapped at index 0x6003, subindex 0x01
       
    61 UNS32 canopenErrVAL;		// Mapped at index 0x6003, subindex 0x02
       
    62 
       
    63 /**************************************************************************/
       
    64 /* Declaration of the value range types                                   */
       
    65 /**************************************************************************/
       
    66 
       
    67 
       
    68 
       
    69 UNS32 valueRangeTest (UNS8 typeValue, UNS32 unsValue, REAL32 realValue)
       
    70 {
       
    71   return 0;
       
    72 }
       
    73 
       
    74 
       
    75 /**************************************************************************/
       
    76 /* The node id                                                            */
       
    77 /**************************************************************************/
       
    78 /* Computed by strNode */
       
    79 /* node_id default value. 
       
    80    This default value is deprecated.
       
    81    You should always overwrite this by using the function setNodeId(UNS8 nodeId) in your C code.
       
    82 */
       
    83 #define NODE_ID 0x01
       
    84 UNS8 bDeviceNodeId = NODE_ID;
       
    85 
       
    86 
       
    87 //*****************************************************************************/
       
    88 /* Computed by strStartDico */
       
    89 
       
    90 /* Array of message processing information */
       
    91 /* Should not be modified */
       
    92 volatile const proceed_info proceed_infos[] = {
       
    93   {NMT,		"NMT",	        NULL},
       
    94   {SYNC,        "SYNC",         proceedSYNC},
       
    95   {TIME_STAMP,	"TStmp",	NULL},
       
    96   {PDO1tx,	"PDO1t",        proceedPDO},
       
    97   {PDO1rx,	"PDO1r",	proceedPDO},
       
    98   {PDO2tx,	"PDO2t",	proceedPDO},
       
    99   {PDO2rx,	"PDO2r",	proceedPDO},
       
   100   {PDO3tx,	"PDO3t",	proceedPDO},
       
   101   {PDO3rx,	"PDO3r",	proceedPDO},
       
   102   {PDO4tx,	"PDO4t",	proceedPDO},
       
   103   {PDO4rx,	"PDO4r",	proceedPDO},
       
   104   {SDOtx,	"SDOt",	        proceedSDO},
       
   105   {SDOrx,	"SDOr",         proceedSDO},
       
   106   {0xD,		"Unkw",	        NULL},
       
   107   {NODE_GUARD,	"NGrd",         proceedNMTerror},
       
   108   {0xF,		"Unkw",	        NULL}
       
   109 };
       
   110 
       
   111   // Macros definition
       
   112 
       
   113 /* Beware : 
       
   114 index                 *must* be writen 4 numbers in hexa
       
   115 sub_index             *must* be writen 2 numbers in hexa
       
   116 size_variable_in_UNS8 *must* be writen 2 numbers in hexa
       
   117 */
       
   118 #define PDO_MAP(index, sub_index, size_variable_in_bits)\
       
   119 0x ## index ## sub_index ## size_variable_in_bits
       
   120 
       
   121 //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
       
   122 //
       
   123 //                       OBJECT DICTIONARY
       
   124 //                   
       
   125 //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
       
   126 // Make your change, depending of your application
       
   127  
       
   128 
       
   129 /* index 0x1000 :   Device type. 
       
   130                     You have to change the value below, so
       
   131                     it fits your canopen-slave-module */
       
   132  
       
   133                     /* Not used, so, should not be modified */
       
   134                     
       
   135                     UNS32 obj1000 = 0;
       
   136                     subindex Index1000[] =
       
   137                     {
       
   138                       { RO, uint32, sizeof(UNS32), (void*)&obj1000 }
       
   139                     };
       
   140 
       
   141 /* index 0x1001 :   Error register. 
       
   142                     Change the entries to fit your application 
       
   143                     Not used, so, should not be modified */
       
   144                     /*const*/ UNS8 obj1001 = 0x0;
       
   145                     /*const*/ subindex Index1001[] =
       
   146                     {
       
   147                       { RO, uint8, sizeof(UNS8), (void*)&obj1001 }
       
   148                     };
       
   149 
       
   150 /* index 0x1005 :   COB_ID SYNC */
       
   151                     /* Should not be modified */
       
   152                     UNS32 obj1005 = 0x00000080; // bit 30 = 1 : device can generate a SYNC message
       
   153                                                 // Beware, it is over written when the node 
       
   154                                                 // enters in reset mode
       
   155                                                 // See initResetMode() in init.c
       
   156                     /*const*/ subindex Index1005[] =
       
   157                     {
       
   158                       { RW, uint32, sizeof(UNS32), (void*)&obj1005 }
       
   159                     };
       
   160 
       
   161 /* index 0x1006 :   SYNC period */
       
   162                     // For producing the SYNC signal every n micro-seconds.
       
   163                     // Put O to not producing SYNC
       
   164                     /*const*/ UNS32 obj1006 = 0x0; 
       
   165                                          // Default 0 to not produce SYNC //
       
   166                                          // Beware, it is over written when the 
       
   167                                          // node enters in reset mode.
       
   168                                          // See initResetMode() in init.c
       
   169                     /*const*/ subindex Index1006[] =
       
   170                     {
       
   171                       { RW, uint32, sizeof(UNS32), (void*)&obj1006 }
       
   172                     };
       
   173  
       
   174 /* index 0x1007 :   Synchronous Window Length
       
   175                     Seems to be needed by DS401 to generate the SYNC signal ! */
       
   176                     /*const*/ UNS32 obj1007 = 0x0; /* Default 0 */
       
   177                     /*const*/ subindex Index1007[] =
       
   178                     {
       
   179                       { RW, uint32, sizeof(UNS32), (void*)&obj1007 }
       
   180                     };
       
   181 
       
   182 /* index 0x1008 :   Manufacturer device name */
       
   183                     UNS8 obj1008[] = "Appli_Master_Linux"; /* Default 0 */
       
   184                     subindex Index1008[] =
       
   185                     {
       
   186                       { RO, uint32, sizeof(obj1008), (void*)&obj1008 }
       
   187                     };
       
   188 
       
   189 /* index 0x1009 :   Manufacturer hardware version */
       
   190                     UNS8 obj1009[] = __DATE__; /* Default 0 */
       
   191                     subindex Index1009[] =
       
   192                     {
       
   193                       { RO, uint32, sizeof(obj1009), (void*)&obj1009 }
       
   194                     };
       
   195 
       
   196 /* index 0x100A :   Manufacturer software version */
       
   197                     UNS8 obj100A[] = __TIME__; /* Default 0 */
       
   198                     subindex Index100A[] =
       
   199                     {
       
   200                       { RO, uint32, sizeof(obj100A), (void*)&obj100A}
       
   201                     };
       
   202 
       
   203 /* index 0x1016 :   HeartBeat consumers 
       
   204                     The nodes which can send a heartbeat */ 
       
   205                     static  UNS32 obj1016[] = {// Consumer time for each node 
       
   206                     0x00000000}; // Format 0x00NNTTTT (N=Node T=time in ms)
       
   207 
       
   208                     static  UNS8 obj1016_cnt = 1; // 1 nodes could send me
       
   209                                                   // their heartbeat.
       
   210                     subindex Index1016[] = 
       
   211                     {
       
   212                       { RO, uint8, sizeof(UNS8), (void*)&obj1016_cnt },
       
   213                       { RW, uint32, sizeof(UNS32), (void*)&obj1016[0] }
       
   214                     }; 
       
   215 
       
   216 /* index 0x1017 :   Heartbeat producer                    
       
   217                     Every HBProducerTime, the node sends its heartbeat */
       
   218                     static UNS16 obj1017 = 0; //HBProducerTime in ms. If 0 : not activated 
       
   219                                                      // Beware, it is over written when the 
       
   220                                                      // node enters in reset mode.
       
   221                                                      // See initResetMode() in init.c
       
   222                     subindex Index1017[] =
       
   223                     {
       
   224 	              { RW, uint16, sizeof(UNS16), &obj1017 }
       
   225                     };
       
   226 
       
   227 /* index 0x1018 :   Identity object */
       
   228                     /** index 1018: identify object. Adjust the entries for your node/company
       
   229                     */
       
   230                     /* Values can be modified */
       
   231 
       
   232                     s_identity obj1018 =
       
   233                     {
       
   234                       4,       // number of supported entries
       
   235                       0,  // Vendor-ID (given by the can-cia)
       
   236                       0,  // Product Code
       
   237                       0,  // Revision number
       
   238                       0  // serial number
       
   239                     };
       
   240 
       
   241                     subindex Index1018[] =
       
   242                     {
       
   243                       { RO, uint8,  sizeof(UNS8),  (void*)&obj1018.count },
       
   244                       { RO, uint32, sizeof(UNS32), (void*)&obj1018.vendor_id},
       
   245                       { RO, uint32, sizeof(UNS32), (void*)&obj1018.product_code},
       
   246                       { RO, uint32, sizeof(UNS32), (void*)&obj1018.revision_number},
       
   247                       { RO, uint32, sizeof(UNS32), (void*)&obj1018.serial_number}
       
   248                     };
       
   249 
       
   250 /* index 0x1200 :   The SDO Server parameters */
       
   251                     /* BEWARE You cannot define more than one SDO server */
       
   252                     /* The values should not be modified here, 
       
   253                     but can be changed at runtime */
       
   254                     // Beware that the default values that you could put here
       
   255                     // will be over written at the initialisation of the node. 
       
   256                     // See setNodeId() in init.c
       
   257                     static s_sdo_parameter obj1200  = 
       
   258                       { 3,                   // Number of entries. Always 3 for the SDO	       
       
   259                         0x600 + NODE_ID,     // The cob_id transmited in CAN msg to the server     
       
   260                         0x580 + NODE_ID,     // The cob_id received in CAN msg from the server  
       
   261                         NODE_ID              // The node id of the client. Should not be modified 
       
   262                       };
       
   263                     static subindex Index1200[] =
       
   264                     {
       
   265                       { RO, uint8,  sizeof( UNS8 ), (void*)&obj1200.count },
       
   266                       { RO, uint32, sizeof( UNS32), (void*)&obj1200.cob_id_client },
       
   267                       { RO, uint32, sizeof( UNS32), (void*)&obj1200.cob_id_server },
       
   268                       { RW, uint8,  sizeof( UNS8),  (void*)&obj1200.node_id }
       
   269                     };
       
   270 
       
   271 /* index 0x1280 :   SDO client parameter */
       
   272                     static s_sdo_parameter obj1280 = 
       
   273                       { 3,     // Nb of entries 
       
   274                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   275                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   276                         0x0    // server NodeId
       
   277                       };
       
   278                     static subindex Index1280[] = 
       
   279                       { 
       
   280                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1280.count },
       
   281                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1280.cob_id_client },
       
   282                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1280.cob_id_server },
       
   283                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1280.node_id }
       
   284                       }; 
       
   285 
       
   286 /* index 0x1281 :   SDO client parameter */
       
   287                     static s_sdo_parameter obj1281 = 
       
   288                       { 3,     // Nb of entries 
       
   289                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   290                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   291                         0x0    // server NodeId
       
   292                       };
       
   293                     static subindex Index1281[] = 
       
   294                       { 
       
   295                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1281.count },
       
   296                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1281.cob_id_client },
       
   297                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1281.cob_id_server },
       
   298                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1281.node_id }
       
   299                       }; 
       
   300 
       
   301 /* index 0x1282 :   SDO client parameter */
       
   302                     static s_sdo_parameter obj1282 = 
       
   303                       { 3,     // Nb of entries 
       
   304                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   305                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   306                         0x0    // server NodeId
       
   307                       };
       
   308                     static subindex Index1282[] = 
       
   309                       { 
       
   310                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1282.count },
       
   311                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1282.cob_id_client },
       
   312                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1282.cob_id_server },
       
   313                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1282.node_id }
       
   314                       }; 
       
   315 
       
   316 /* index 0x1283 :   SDO client parameter */
       
   317                     static s_sdo_parameter obj1283 = 
       
   318                       { 3,     // Nb of entries 
       
   319                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   320                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   321                         0x0    // server NodeId
       
   322                       };
       
   323                     static subindex Index1283[] = 
       
   324                       { 
       
   325                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1283.count },
       
   326                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1283.cob_id_client },
       
   327                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1283.cob_id_server },
       
   328                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1283.node_id }
       
   329                       }; 
       
   330 
       
   331 /* index 0x1284 :   SDO client parameter */
       
   332                     static s_sdo_parameter obj1284 = 
       
   333                       { 3,     // Nb of entries 
       
   334                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   335                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   336                         0x0    // server NodeId
       
   337                       };
       
   338                     static subindex Index1284[] = 
       
   339                       { 
       
   340                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1284.count },
       
   341                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1284.cob_id_client },
       
   342                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1284.cob_id_server },
       
   343                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1284.node_id }
       
   344                       }; 
       
   345 
       
   346 /* index 0x1285 :   SDO client parameter */
       
   347                     static s_sdo_parameter obj1285 = 
       
   348                       { 3,     // Nb of entries 
       
   349                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   350                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   351                         0x0    // server NodeId
       
   352                       };
       
   353                     static subindex Index1285[] = 
       
   354                       { 
       
   355                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1285.count },
       
   356                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1285.cob_id_client },
       
   357                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1285.cob_id_server },
       
   358                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1285.node_id }
       
   359                       }; 
       
   360 
       
   361 /* index 0x1286 :   SDO client parameter */
       
   362                     static s_sdo_parameter obj1286 = 
       
   363                       { 3,     // Nb of entries 
       
   364                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   365                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   366                         0x0    // server NodeId
       
   367                       };
       
   368                     static subindex Index1286[] = 
       
   369                       { 
       
   370                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1286.count },
       
   371                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1286.cob_id_client },
       
   372                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1286.cob_id_server },
       
   373                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1286.node_id }
       
   374                       }; 
       
   375 
       
   376 /* index 0x1287 :   SDO client parameter */
       
   377                     static s_sdo_parameter obj1287 = 
       
   378                       { 3,     // Nb of entries 
       
   379                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   380                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   381                         0x0    // server NodeId
       
   382                       };
       
   383                     static subindex Index1287[] = 
       
   384                       { 
       
   385                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1287.count },
       
   386                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1287.cob_id_client },
       
   387                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1287.cob_id_server },
       
   388                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1287.node_id }
       
   389                       }; 
       
   390 
       
   391 /* index 0x1288 :   SDO client parameter */
       
   392                     static s_sdo_parameter obj1288 = 
       
   393                       { 3,     // Nb of entries 
       
   394                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   395                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   396                         0x0    // server NodeId
       
   397                       };
       
   398                     static subindex Index1288[] = 
       
   399                       { 
       
   400                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1288.count },
       
   401                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1288.cob_id_client },
       
   402                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1288.cob_id_server },
       
   403                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1288.node_id }
       
   404                       }; 
       
   405 
       
   406 /* index 0x1289 :   SDO client parameter */
       
   407                     static s_sdo_parameter obj1289 = 
       
   408                       { 3,     // Nb of entries 
       
   409                         0x600, // cobid transmited to the server. The good value should be 0x600 + server nodeId
       
   410                         0x580, // cobid received from the server. The good value should be 0x580 + server nodeId
       
   411                         0x0    // server NodeId
       
   412                       };
       
   413                     static subindex Index1289[] = 
       
   414                       { 
       
   415                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1289.count },
       
   416                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1289.cob_id_client },
       
   417                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1289.cob_id_server },
       
   418                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1289.node_id }
       
   419                       }; 
       
   420 
       
   421 /* index 0x1400 :   PDO receive communication parameter */
       
   422                     static s_pdo_communication_parameter obj1400 = 
       
   423                       { 2, // Largest subindex supported 
       
   424                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   425                         253 // Transmission type. See objdictdef.h 
       
   426                       };
       
   427                     static subindex Index1400[] = 
       
   428                       { 
       
   429                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1400.count },
       
   430                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1400.cob_id },
       
   431                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1400.type },
       
   432                       }; 
       
   433 
       
   434 /* index 0x1401 :   PDO receive communication parameter */
       
   435                     static s_pdo_communication_parameter obj1401 = 
       
   436                       { 2, // Largest subindex supported 
       
   437                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   438                         253 // Transmission type. See objdictdef.h 
       
   439                       };
       
   440                     static subindex Index1401[] = 
       
   441                       { 
       
   442                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1401.count },
       
   443                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1401.cob_id },
       
   444                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1401.type },
       
   445                       }; 
       
   446 
       
   447 /* index 0x1402 :   PDO receive communication parameter */
       
   448                     static s_pdo_communication_parameter obj1402 = 
       
   449                       { 2, // Largest subindex supported 
       
   450                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   451                         253 // Transmission type. See objdictdef.h 
       
   452                       };
       
   453                     static subindex Index1402[] = 
       
   454                       { 
       
   455                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1402.count },
       
   456                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1402.cob_id },
       
   457                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1402.type },
       
   458                       }; 
       
   459 
       
   460 /* index 0x1600 :   PDO receive mapping parameter of PDO communication index 0x1400 */
       
   461                     static UNS8 obj1600_cnt = 0; // Number of mapped variables
       
   462                     static UNS32 obj1600_mappedVar[] = { 
       
   463                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   464                         // PDO_MAP(6035,12,16)
       
   465                         PDO_MAP(0000, 00, 00),
       
   466                         PDO_MAP(0000, 00, 00),
       
   467                         PDO_MAP(0000, 00, 00),
       
   468                         PDO_MAP(0000, 00, 00),
       
   469                         PDO_MAP(0000, 00, 00),
       
   470                         PDO_MAP(0000, 00, 00),
       
   471                         PDO_MAP(0000, 00, 00),
       
   472                         PDO_MAP(0000, 00, 00)
       
   473                       };
       
   474                     subindex Index1600[] = 
       
   475                       { 
       
   476                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1600_cnt },
       
   477                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[0]},
       
   478                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[1]},
       
   479                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[2]},
       
   480                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[3]},
       
   481                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[4]},
       
   482                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[5]},
       
   483                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[6]},
       
   484                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1600_mappedVar[7]}
       
   485                       }; 
       
   486 
       
   487 /* index 0x1601 :   PDO receive mapping parameter of PDO communication index 0x1401 */
       
   488                     static UNS8 obj1601_cnt = 0; // Number of mapped variables
       
   489                     static UNS32 obj1601_mappedVar[] = { 
       
   490                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   491                         // PDO_MAP(6035,12,16)
       
   492                         PDO_MAP(0000, 00, 00),
       
   493                         PDO_MAP(0000, 00, 00),
       
   494                         PDO_MAP(0000, 00, 00),
       
   495                         PDO_MAP(0000, 00, 00),
       
   496                         PDO_MAP(0000, 00, 00),
       
   497                         PDO_MAP(0000, 00, 00),
       
   498                         PDO_MAP(0000, 00, 00),
       
   499                         PDO_MAP(0000, 00, 00)
       
   500                       };
       
   501                     subindex Index1601[] = 
       
   502                       { 
       
   503                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1601_cnt },
       
   504                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[0]},
       
   505                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[1]},
       
   506                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[2]},
       
   507                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[3]},
       
   508                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[4]},
       
   509                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[5]},
       
   510                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[6]},
       
   511                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1601_mappedVar[7]}
       
   512                       }; 
       
   513 
       
   514 /* index 0x1602 :   PDO receive mapping parameter of PDO communication index 0x1402 */
       
   515                     static UNS8 obj1602_cnt = 0; // Number of mapped variables
       
   516                     static UNS32 obj1602_mappedVar[] = { 
       
   517                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   518                         // PDO_MAP(6035,12,16)
       
   519                         PDO_MAP(0000, 00, 00),
       
   520                         PDO_MAP(0000, 00, 00),
       
   521                         PDO_MAP(0000, 00, 00),
       
   522                         PDO_MAP(0000, 00, 00),
       
   523                         PDO_MAP(0000, 00, 00),
       
   524                         PDO_MAP(0000, 00, 00),
       
   525                         PDO_MAP(0000, 00, 00),
       
   526                         PDO_MAP(0000, 00, 00)
       
   527                       };
       
   528                     subindex Index1602[] = 
       
   529                       { 
       
   530                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1602_cnt },
       
   531                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[0]},
       
   532                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[1]},
       
   533                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[2]},
       
   534                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[3]},
       
   535                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[4]},
       
   536                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[5]},
       
   537                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[6]},
       
   538                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1602_mappedVar[7]}
       
   539                       }; 
       
   540 
       
   541 /* index 0x1800 :   PDO transmit communication parameter */
       
   542                     static s_pdo_communication_parameter obj1800 = 
       
   543                       { 2, // Largest subindex supported 
       
   544                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   545                         253 // Transmission type. See objdictdef.h 
       
   546                       };
       
   547                     static subindex Index1800[] = 
       
   548                       { 
       
   549                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1800.count },
       
   550                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1800.cob_id },
       
   551                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1800.type },
       
   552                       }; 
       
   553 
       
   554 /* index 0x1801 :   PDO transmit communication parameter */
       
   555                     static s_pdo_communication_parameter obj1801 = 
       
   556                       { 2, // Largest subindex supported 
       
   557                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   558                         253 // Transmission type. See objdictdef.h 
       
   559                       };
       
   560                     static subindex Index1801[] = 
       
   561                       { 
       
   562                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1801.count },
       
   563                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1801.cob_id },
       
   564                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1801.type },
       
   565                       }; 
       
   566 
       
   567 /* index 0x1802 :   PDO transmit communication parameter */
       
   568                     static s_pdo_communication_parameter obj1802 = 
       
   569                       { 2, // Largest subindex supported 
       
   570                         0x0, // Default COBID (overwritten at init for index 0x1400 to 0x1403)
       
   571                         253 // Transmission type. See objdictdef.h 
       
   572                       };
       
   573                     static subindex Index1802[] = 
       
   574                       { 
       
   575                         { RO, uint8, sizeof( UNS8  ), (void*)&obj1802.count },
       
   576                         { RW, uint8, sizeof( UNS32 ), (void*)&obj1802.cob_id },
       
   577                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1802.type },
       
   578                       }; 
       
   579 
       
   580 /* index 0x1A00 :   PDO transmit mapping parameter of PDO communication index 0x1800 */
       
   581                     static UNS8 obj1A00_cnt = 0; // Number of mapped variables
       
   582                     static UNS32 obj1A00_mappedVar[] = { 
       
   583                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   584                         // PDO_MAP(6035,12,16)
       
   585                         PDO_MAP(0000, 00, 00),
       
   586                         PDO_MAP(0000, 00, 00),
       
   587                         PDO_MAP(0000, 00, 00),
       
   588                         PDO_MAP(0000, 00, 00),
       
   589                         PDO_MAP(0000, 00, 00),
       
   590                         PDO_MAP(0000, 00, 00),
       
   591                         PDO_MAP(0000, 00, 00),
       
   592                         PDO_MAP(0000, 00, 00)
       
   593                       };
       
   594                     subindex Index1A00[] = 
       
   595                       { 
       
   596                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1A00_cnt },
       
   597                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[0]},
       
   598                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[1]},
       
   599                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[2]},
       
   600                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[3]},
       
   601                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[4]},
       
   602                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[5]},
       
   603                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[6]},
       
   604                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A00_mappedVar[7]}
       
   605                       }; 
       
   606 
       
   607 /* index 0x1A01 :   PDO transmit mapping parameter of PDO communication index 0x1801 */
       
   608                     static UNS8 obj1A01_cnt = 0; // Number of mapped variables
       
   609                     static UNS32 obj1A01_mappedVar[] = { 
       
   610                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   611                         // PDO_MAP(6035,12,16)
       
   612                         PDO_MAP(0000, 00, 00),
       
   613                         PDO_MAP(0000, 00, 00),
       
   614                         PDO_MAP(0000, 00, 00),
       
   615                         PDO_MAP(0000, 00, 00),
       
   616                         PDO_MAP(0000, 00, 00),
       
   617                         PDO_MAP(0000, 00, 00),
       
   618                         PDO_MAP(0000, 00, 00),
       
   619                         PDO_MAP(0000, 00, 00)
       
   620                       };
       
   621                     subindex Index1A01[] = 
       
   622                       { 
       
   623                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1A01_cnt },
       
   624                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[0]},
       
   625                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[1]},
       
   626                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[2]},
       
   627                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[3]},
       
   628                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[4]},
       
   629                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[5]},
       
   630                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[6]},
       
   631                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A01_mappedVar[7]}
       
   632                       }; 
       
   633 
       
   634 /* index 0x1A02 :   PDO transmit mapping parameter of PDO communication index 0x1802 */
       
   635                     static UNS8 obj1A02_cnt = 0; // Number of mapped variables
       
   636                     static UNS32 obj1A02_mappedVar[] = { 
       
   637                         // Example to map a variable of 16 bits defined at index 0x6035, subindex 0x12 :
       
   638                         // PDO_MAP(6035,12,16)
       
   639                         PDO_MAP(0000, 00, 00),
       
   640                         PDO_MAP(0000, 00, 00),
       
   641                         PDO_MAP(0000, 00, 00),
       
   642                         PDO_MAP(0000, 00, 00),
       
   643                         PDO_MAP(0000, 00, 00),
       
   644                         PDO_MAP(0000, 00, 00),
       
   645                         PDO_MAP(0000, 00, 00),
       
   646                         PDO_MAP(0000, 00, 00)
       
   647                       };
       
   648                     subindex Index1A02[] = 
       
   649                       { 
       
   650                         { RW, uint8, sizeof( UNS8  ), (void*)&obj1A02_cnt },
       
   651                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[0]},
       
   652                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[1]},
       
   653                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[2]},
       
   654                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[3]},
       
   655                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[4]},
       
   656                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[5]},
       
   657                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[6]},
       
   658                         { RW, uint32, sizeof( UNS32 ), (void*)&obj1A02_mappedVar[7]}
       
   659                       }; 
       
   660 
       
   661 
       
   662 /* index 0x6000 :   Mapped variable */
       
   663                     subindex Index6000[] = 
       
   664                      {
       
   665                        { RW, uint32, sizeof (UNS32), (void*)&canopenErrNB_node5 }
       
   666                      };
       
   667 
       
   668 /* index 0x6001 :   Mapped variable */
       
   669                     subindex Index6001[] = 
       
   670                      {
       
   671                        { RW, uint32, sizeof (UNS32), (void*)&canopenErrVAL_node5 }
       
   672                      };
       
   673 
       
   674 /* index 0x6002 :   Mapped variable */
       
   675                     static UNS8 highestSubIndex_6002 = 4; // number of subindex - 1
       
   676                     subindex Index6002[] = 
       
   677                      {
       
   678                        { RO, uint8, sizeof (UNS8), (void*)&highestSubIndex_6002 },
       
   679                        { RW, uint8, sizeof (UNS8), (void*)&second },
       
   680                        { RW, uint8, sizeof (UNS8), (void*)&minutes },
       
   681                        { RW, uint8, sizeof (UNS8), (void*)&hour },
       
   682                        { RW, uint8, sizeof (UNS8), (void*)&day }
       
   683                      };
       
   684 
       
   685 /* index 0x6003 :   Mapped variable */
       
   686                     static UNS8 highestSubIndex_6003 = 2; // number of subindex - 1
       
   687                     subindex Index6003[] = 
       
   688                      {
       
   689                        { RO, uint8, sizeof (UNS8), (void*)&highestSubIndex_6003 },
       
   690                        { RW, uint32, sizeof (UNS32), (void*)&canopenErrNB },
       
   691                        { RW, uint32, sizeof (UNS32), (void*)&canopenErrVAL }
       
   692                      };
       
   693 
       
   694 const indextable objdict[] = 
       
   695 {
       
   696   DeclareIndexTableEntry(Index1000, 0x1000),
       
   697   DeclareIndexTableEntry(Index1001, 0x1001),
       
   698   DeclareIndexTableEntry(Index1005, 0x1005),
       
   699   DeclareIndexTableEntry(Index1006, 0x1006),
       
   700   DeclareIndexTableEntry(Index1007, 0x1007),
       
   701   DeclareIndexTableEntry(Index1008, 0x1008),
       
   702   DeclareIndexTableEntry(Index1009, 0x1009),
       
   703   DeclareIndexTableEntry(Index100A, 0x100A),
       
   704   DeclareIndexTableEntry(Index1016, 0x1016),
       
   705   DeclareIndexTableEntry(Index1017, 0x1017),
       
   706   DeclareIndexTableEntry(Index1018, 0x1018),
       
   707   DeclareIndexTableEntry(Index1200, 0x1200),
       
   708   DeclareIndexTableEntry(Index1280, 0x1280),
       
   709   DeclareIndexTableEntry(Index1281, 0x1281),
       
   710   DeclareIndexTableEntry(Index1282, 0x1282),
       
   711   DeclareIndexTableEntry(Index1283, 0x1283),
       
   712   DeclareIndexTableEntry(Index1284, 0x1284),
       
   713   DeclareIndexTableEntry(Index1285, 0x1285),
       
   714   DeclareIndexTableEntry(Index1286, 0x1286),
       
   715   DeclareIndexTableEntry(Index1287, 0x1287),
       
   716   DeclareIndexTableEntry(Index1288, 0x1288),
       
   717   DeclareIndexTableEntry(Index1289, 0x1289),
       
   718   DeclareIndexTableEntry(Index1400, 0x1400),
       
   719   DeclareIndexTableEntry(Index1401, 0x1401),
       
   720   DeclareIndexTableEntry(Index1402, 0x1402),
       
   721   DeclareIndexTableEntry(Index1600, 0x1600),
       
   722   DeclareIndexTableEntry(Index1601, 0x1601),
       
   723   DeclareIndexTableEntry(Index1602, 0x1602),
       
   724   DeclareIndexTableEntry(Index1800, 0x1800),
       
   725   DeclareIndexTableEntry(Index1801, 0x1801),
       
   726   DeclareIndexTableEntry(Index1802, 0x1802),
       
   727   DeclareIndexTableEntry(Index1A00, 0x1A00),
       
   728   DeclareIndexTableEntry(Index1A01, 0x1A01),
       
   729   DeclareIndexTableEntry(Index1A02, 0x1A02),
       
   730   DeclareIndexTableEntry(Index6000, 0x6000),
       
   731   DeclareIndexTableEntry(Index6001, 0x6001),
       
   732   DeclareIndexTableEntry(Index6002, 0x6002),
       
   733   DeclareIndexTableEntry(Index6003, 0x6003),
       
   734 };
       
   735 
       
   736 // To count at which received SYNC a PDO must be sent.
       
   737 // Even if no pdoTransmit are defined, at least one entry is computed
       
   738 // for compilations issues.
       
   739 UNS8 count_sync[1] = {0, };
       
   740   
       
   741 UNS16 firstIndex (enum e_first_object object, UNS16 *lastIndex)
       
   742 {
       
   743   switch (object) {
       
   744     case FIRST_SDO_SERVER :
       
   745       *lastIndex = 11;
       
   746       return 11;
       
   747     case FIRST_SDO_CLIENT :
       
   748       *lastIndex = 21;
       
   749       return 12;
       
   750     case FIRST_PDO_RCV :
       
   751       *lastIndex = 24;
       
   752       return 22;
       
   753     case FIRST_PDO_RCV_MAP :
       
   754       *lastIndex = 27;
       
   755       return 25;
       
   756     case FIRST_PDO_TRS :
       
   757       *lastIndex = 30;
       
   758       return 28;
       
   759     case FIRST_PDO_TRS_MAP :
       
   760       *lastIndex = 33;
       
   761       return 31;
       
   762   }
       
   763   *lastIndex = 0;
       
   764   return 0;
       
   765 }
       
   766 
       
   767 UNS16 getObjdictSize (void) 
       
   768 {
       
   769   return sizeof(objdict)/sizeof(objdict[0]);
       
   770 }