1 /*****************************************************************************

     2  *

     3  * $Id$

     4  *

     5  ****************************************************************************/

     6 

     7 #include <iostream>

     8 #include <iomanip>

     9 using namespace std;

    10 

    11 #include "globals.h"

    12 

    13 /****************************************************************************/

    14 

    15 const char *help_sii_read =

    16     "[OPTIONS]\n"

    17     "\n"

    18     "Outputs the SII (EEPROM) contents of a slave.\n"

    19     "\n"

    20     "Without the --verbose option, binary SII contents are output. They can\n"

    21     "be piped to a tool like hexdump, for example:\n"

    22     "\n"

    23     "  ethercat sii_read -s2 | hexdump -C\n"

    24     "\n"

    25     "With the --verbose option given, a textual representation of the data\n"

    26     "is output, that is separated by SII category names.\n"

    27     "\n"

    28     "Command-specific options:\n"

    29     "  --slave   -s <index>  Positive numerical ring position (mandatory).\n"

    30     "  --verbose -v          Output textual data with category names.\n"

    31     "\n"

    32     "Numerical values can be specified either with decimal (no prefix),\n"

    33     "octal (prefix '0') or hexadecimal (prefix '0x') base.\n";

    34 

    35 /****************************************************************************/

    36 

    37 struct CategoryName {

    38     uint16_t type;

    39     const char *name;

    40 };

    41 

    42 static const CategoryName categoryNames[] = {

    43     {0x000a, "STRINGS"},

    44     {0x0014, "DataTypes"},

    45     {0x001e, "General"},

    46     {0x0028, "FMMU"},

    47     {0x0029, "SyncM"},

    48     {0x0032, "TXPDO"},

    49     {0x0033, "RXPDO"},

    50     {0x003c, "DC"},

    51     {}

    52 };

    53 

    54 /****************************************************************************/

    55 

    56 const char *getCategoryName(uint16_t type)

    57 {

    58     const CategoryName *cn = categoryNames;

    59 

    60     while (cn->type) {

    61         if (cn->type == type) {

    62             return cn->name;

    63         }

    64         cn++;

    65     }

    66 

    67     return "unknown";

    68 }

    69 

    70 /****************************************************************************/

    71 

    72 void command_sii_read(void)

    73 {

    74     ec_ioctl_slave_sii_t data;

    75     ec_ioctl_slave_t slave;

    76     unsigned int i;

    77     const uint16_t *categoryHeader;

    78     uint16_t categoryType, categorySize;

    79     stringstream err;

    80 

    81     if (slavePosition < 0) {

    82         err << "'" << commandName << "' requires a slave! "

    83             << "Please specify --slave.";

    84         throw InvalidUsageException(err);

    85     }

    86     data.slave_position = slavePosition;

    87 

    88     masterDev.open(MasterDevice::Read);

    89 

    90     masterDev.getSlave(&slave, slavePosition);

    91 

    92     if (!slave.sii_nwords)

    93         return;

    94 

    95     data.offset = 0;

    96     data.nwords = slave.sii_nwords;

    97     data.words = new uint16_t[data.nwords];

    98 

    99 	try {

   100 		masterDev.readSii(&data);

   101 	} catch (MasterDeviceException &e) {

   102         delete [] data.words;

   103 		throw e;

   104 	}

   105 

   106     if (verbosity == Verbose) {

   107         cout << "SII Area:" << hex << setfill('0');

   108         for (i = 0; i < min(data.nwords, 0x0040U) * 2; i++) {

   109             if (i % BreakAfterBytes) {

   110                 cout << " ";

   111             } else {

   112                 cout << endl << "  ";

   113             }

   114             cout << setw(2) << (unsigned int) *((uint8_t *) data.words + i);

   115         }

   116         cout << endl;

   117 

   118         if (data.nwords > 0x0040U) {

   119             // cycle through categories

   120             categoryHeader = data.words + 0x0040U;

   121             categoryType = le16tocpu(*categoryHeader);

   122             while (categoryType != 0xffff) {

   123                 cout << "SII Category 0x" << hex

   124                     << setw(4) << categoryType

   125                     << " (" << getCategoryName(categoryType) << ")" << flush;

   126 

   127                 if (categoryHeader + 1 > data.words + data.nwords) {

   128                     err << "SII data seem to be corrupted!";

   129                     throw CommandException(err);

   130                 }

   131                 categorySize = le16tocpu(*(categoryHeader + 1));

   132                 cout << ", " << dec << categorySize << " words" << flush;

   133 

   134                 if (categoryHeader + 2 + categorySize

   135                         > data.words + data.nwords) {

   136                     err << "SII data seem to be corrupted!";

   137                     throw CommandException(err);

   138                 }

   139 

   140                 cout << hex;

   141                 for (i = 0; i < categorySize * 2U; i++) {

   142                     if (i % BreakAfterBytes) {

   143                         cout << " ";

   144                     } else {

   145                         cout << endl << "  ";

   146                     }

   147                     cout << setw(2) << (unsigned int)

   148                         *((uint8_t *) (categoryHeader + 2) + i);

   149                 }

   150                 cout << endl;

   151 

   152                 if (categoryHeader + 2 + categorySize + 1

   153                         > data.words + data.nwords) {

   154                     err << "SII data seem to be corrupted!"; 

   155                     throw CommandException(err);

   156                 }

   157                 categoryHeader += 2 + categorySize;

   158                 categoryType = le16tocpu(*categoryHeader);

   159             }

   160         }

   161     } else {

   162         for (i = 0; i < data.nwords; i++) {

   163             uint16_t *w = data.words + i;

   164             cout << *(uint8_t *) w << *((uint8_t *) w + 1);

   165         }

   166     }

   167 

   168     delete [] data.words;

   169 }

   170 

   171 /*****************************************************************************/