1

/*****************************************************************************

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master 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 General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

 ****************************************************************************/

    29

    30

#include <iostream>

    31

#include <iomanip>

    32

using namespace std;

    33

    34

#include "CommandSiiRead.h"

    35

#include "MasterDevice.h"

    36

    37

/*****************************************************************************/

    38

    39

CommandSiiRead::CommandSiiRead():

    40

    Command("sii_read", "Output a slave's SII contents.")

    41

{

    42

}

    43

    44

/*****************************************************************************/

    45

    46

string CommandSiiRead::helpString() const

    47

{

    48

    stringstream str;

    49

    50

    str << getName() << " [OPTIONS]" << endl

    51

        << endl

    52

        << getBriefDescription() << endl

    53

        << endl

    54

        << "This command requires a single slave to be selected." << endl

    55

        << endl

    56

        << "Without the --verbose option, binary SII contents are" << endl

    57

        << "output." << endl

    58

        << endl

    59

        << "With the --verbose option given, a textual representation" << endl

    60

        << "of the data is output, that is separated by SII category" << endl

    61

        << "names." << endl

    62

        << endl

    63

        << "Command-specific options:" << endl

    64

        << "  --alias    -a <alias>" << endl

    65

        << "  --position -p <pos>    Slave selection. See the help of" << endl

    66

        << "                         the 'slaves' command." << endl

    67

        << "  --verbose  -v          Output textual data with" << endl

    68

        << "                         category names." << endl

    69

        << endl

    70

        << numericInfo();

    71

    72

    return str.str();

    73

}

    74

    75

/****************************************************************************/

    76

    77

void CommandSiiRead::execute(const StringVector &args)

    78

{

    79

    SlaveList slaves;

    80

    ec_ioctl_slave_t *slave;

    81

    ec_ioctl_slave_sii_t data;

    82

    unsigned int i;

    83

    const uint16_t *categoryHeader;

    84

    uint16_t categoryType, categorySize;

    85

    stringstream err;

    86

    87

    if (args.size()) {

    88

        err << "'" << getName() << "' takes no arguments!";

    89

        throwInvalidUsageException(err);

    90

    }

    91

    92

    MasterDevice m(getSingleMasterIndex());

    93

    m.open(MasterDevice::Read);

    94

    slaves = selectedSlaves(m);

    95

    96

    if (slaves.size() != 1) {

    97

        throwSingleSlaveRequired(slaves.size());

    98

    }

    99

    slave = &slaves.front();

   100

    data.slave_position = slave->position;

   101

   102

    if (!slave->sii_nwords)

   103

        return;

   104

   105

    data.offset = 0;

   106

    data.nwords = slave->sii_nwords;

   107

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

   108

   109

    try {

   110

        m.readSii(&data);

   111

    } catch (MasterDeviceException &e) {

   112

        delete [] data.words;

   113

        throw e;

   114

    }

   115

   116

    if (getVerbosity() == Verbose) {

   117

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

   118

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

   119

            if (i % BreakAfterBytes) {

   120

                cout << " ";

   121

            } else {

   122

                cout << endl << "  ";

   123

            }

   124

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

   125

        }

   126

        cout << endl;

   127

   128

        if (data.nwords > 0x0040U) {

   129

            // cycle through categories

   130

            categoryHeader = data.words + 0x0040U;

   131

            categoryType = le16_to_cpup(categoryHeader);

   132

            while (categoryType != 0xffff) {

   133

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

   134

                    << setw(4) << categoryType

   135

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

   136

   137

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

   138

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

   139

                    throwCommandException(err);

   140

                }

   141

                categorySize = le16_to_cpup(categoryHeader + 1);

   142

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

   143

   144

                if (categoryHeader + 2 + categorySize

   145

                        > data.words + data.nwords) {

   146

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

   147

                    throwCommandException(err);

   148

                }

   149

   150

                cout << hex;

   151

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

   152

                    if (i % BreakAfterBytes) {

   153

                        cout << " ";

   154

                    } else {

   155

                        cout << endl << "  ";

   156

                    }

   157

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

   158

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

   159

                }

   160

                cout << endl;

   161

   162

                if (categoryHeader + 2 + categorySize + 1

   163

                        > data.words + data.nwords) {

   164

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

   165

                    throwCommandException(err);

   166

                }

   167

                categoryHeader += 2 + categorySize;

   168

                categoryType = le16_to_cpup(categoryHeader);

   169

            }

   170

        }

   171

    } else {

   172

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

   173

            uint16_t *w = data.words + i;

   174

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

   175

        }

   176

    }

   177

   178

    delete [] data.words;

   179

}

   180

   181

/****************************************************************************/

   182

   183

const CommandSiiRead::CategoryName CommandSiiRead::categoryNames[] = {

   184

    {0x000a, "STRINGS"},

   185

    {0x0014, "DataTypes"},

   186

    {0x001e, "General"},

   187

    {0x0028, "FMMU"},

   188

    {0x0029, "SyncM"},

   189

    {0x0032, "TXPDO"},

   190

    {0x0033, "RXPDO"},

   191

    {0x003c, "DC"},

   192

    {}

   193

};

   194

   195

/****************************************************************************/

   196

   197

const char *CommandSiiRead::getCategoryName(uint16_t type)

   198

{

   199

    const CategoryName *cn = categoryNames;

   200

   201

    while (cn->type) {

   202

        if (cn->type == type) {

   203

            return cn->name;

   204

        }

   205

        cn++;

   206

    }

   207

   208

    return "unknown";

   209

}

   210

   211

/*****************************************************************************/