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

    36

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

    37

    38

CommandSiiRead::CommandSiiRead():

    39

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

    40

{

    41

}

    42

    43

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

    44

    45

string CommandSiiRead::helpString() const

    46

{

    47

    stringstream str;

    48

    49

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

    50

    	<< endl

    51

    	<< getBriefDescription() << endl

    52

    	<< endl

    53

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

    54

    	<< endl

    55

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

    56

		<< "output." << endl

    57

    	<< endl

    58

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

    59

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

    60

		<< "names." << endl

    61

    	<< endl

    62

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

    63

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

    64

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

    65

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

    66

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

    67

		<< "                         category names." << endl

    68

    	<< endl

    69

		<< numericInfo();

    70

    71

	return str.str();

    72

}

    73

    74

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

    75

    76

void CommandSiiRead::execute(MasterDevice &m, const StringVector &args)

    77

{

    78

    SlaveList slaves;

    79

    ec_ioctl_slave_t *slave;

    80

    ec_ioctl_slave_sii_t data;

    81

    unsigned int i;

    82

    const uint16_t *categoryHeader;

    83

    uint16_t categoryType, categorySize;

    84

    stringstream err;

    85

    86

    if (args.size()) {

    87

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

    88

        throwInvalidUsageException(err);

    89

    }

    90

    91

    m.open(MasterDevice::Read);

    92

    slaves = selectedSlaves(m);

    93

    94

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

    95

        throwSingleSlaveRequired(slaves.size());

    96

    }

    97

    slave = &slaves.front();

    98

    data.slave_position = slave->position;

    99

   100

    if (!slave->sii_nwords)

   101

        return;

   102

   103

    data.offset = 0;

   104

    data.nwords = slave->sii_nwords;

   105

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

   106

   107

	try {

   108

		m.readSii(&data);

   109

	} catch (MasterDeviceException &e) {

   110

        delete [] data.words;

   111

		throw e;

   112

	}

   113

   114

    if (getVerbosity() == Verbose) {

   115

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

   116

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

   117

            if (i % BreakAfterBytes) {

   118

                cout << " ";

   119

            } else {

   120

                cout << endl << "  ";

   121

            }

   122

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

   123

        }

   124

        cout << endl;

   125

   126

        if (data.nwords > 0x0040U) {

   127

            // cycle through categories

   128

            categoryHeader = data.words + 0x0040U;

   129

            categoryType = le16_to_cpup(categoryHeader);

   130

            while (categoryType != 0xffff) {

   131

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

   132

                    << setw(4) << categoryType

   133

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

   134

   135

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

   136

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

   137

                    throwCommandException(err);

   138

                }

   139

                categorySize = le16_to_cpup(categoryHeader + 1);

   140

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

   141

   142

                if (categoryHeader + 2 + categorySize

   143

                        > data.words + data.nwords) {

   144

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

   145

                    throwCommandException(err);

   146

                }

   147

   148

                cout << hex;

   149

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

   150

                    if (i % BreakAfterBytes) {

   151

                        cout << " ";

   152

                    } else {

   153

                        cout << endl << "  ";

   154

                    }

   155

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

   156

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

   157

                }

   158

                cout << endl;

   159

   160

                if (categoryHeader + 2 + categorySize + 1

   161

                        > data.words + data.nwords) {

   162

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

   163

                    throwCommandException(err);

   164

                }

   165

                categoryHeader += 2 + categorySize;

   166

                categoryType = le16_to_cpup(categoryHeader);

   167

            }

   168

        }

   169

    } else {

   170

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

   171

            uint16_t *w = data.words + i;

   172

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

   173

        }

   174

    }

   175

   176

    delete [] data.words;

   177

}

   178

   179

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

   180

   181

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

   182

    {0x000a, "STRINGS"},

   183

    {0x0014, "DataTypes"},

   184

    {0x001e, "General"},

   185

    {0x0028, "FMMU"},

   186

    {0x0029, "SyncM"},

   187

    {0x0032, "TXPDO"},

   188

    {0x0033, "RXPDO"},

   189

    {0x003c, "DC"},

   190

    {}

   191

};

   192

   193

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

   194

   195

const char *CommandSiiRead::getCategoryName(uint16_t type)

   196

{

   197

    const CategoryName *cn = categoryNames;

   198

   199

    while (cn->type) {

   200

        if (cn->type == type) {

   201

            return cn->name;

   202

        }

   203

        cn++;

   204

    }

   205

   206

    return "unknown";

   207

}

   208

   209

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