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

    m.open(MasterDevice::Read);

    87

    slaves = selectedSlaves(m);

    88

    89

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

    90

        throwSingleSlaveRequired(slaves.size());

    91

    }

    92

    slave = &slaves.front();

    93

    data.slave_position = slave->position;

    94

    95

    if (!slave->sii_nwords)

    96

        return;

    97

    98

    data.offset = 0;

    99

    data.nwords = slave->sii_nwords;

   100

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

   101

   102

	try {

   103

		m.readSii(&data);

   104

	} catch (MasterDeviceException &e) {

   105

        delete [] data.words;

   106

		throw e;

   107

	}

   108

   109

    if (getVerbosity() == Verbose) {

   110

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

   111

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

   112

            if (i % BreakAfterBytes) {

   113

                cout << " ";

   114

            } else {

   115

                cout << endl << "  ";

   116

            }

   117

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

   118

        }

   119

        cout << endl;

   120

   121

        if (data.nwords > 0x0040U) {

   122

            // cycle through categories

   123

            categoryHeader = data.words + 0x0040U;

   124

            categoryType = le16_to_cpup(categoryHeader);

   125

            while (categoryType != 0xffff) {

   126

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

   127

                    << setw(4) << categoryType

   128

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

   129

   130

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

   131

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

   132

                    throwCommandException(err);

   133

                }

   134

                categorySize = le16_to_cpup(categoryHeader + 1);

   135

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

   136

   137

                if (categoryHeader + 2 + categorySize

   138

                        > data.words + data.nwords) {

   139

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

   140

                    throwCommandException(err);

   141

                }

   142

   143

                cout << hex;

   144

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

   145

                    if (i % BreakAfterBytes) {

   146

                        cout << " ";

   147

                    } else {

   148

                        cout << endl << "  ";

   149

                    }

   150

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

   151

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

   152

                }

   153

                cout << endl;

   154

   155

                if (categoryHeader + 2 + categorySize + 1

   156

                        > data.words + data.nwords) {

   157

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

   158

                    throwCommandException(err);

   159

                }

   160

                categoryHeader += 2 + categorySize;

   161

                categoryType = le16_to_cpup(categoryHeader);

   162

            }

   163

        }

   164

    } else {

   165

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

   166

            uint16_t *w = data.words + i;

   167

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

   168

        }

   169

    }

   170

   171

    delete [] data.words;

   172

}

   173

   174

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

   175

   176

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

   177

    {0x000a, "STRINGS"},

   178

    {0x0014, "DataTypes"},

   179

    {0x001e, "General"},

   180

    {0x0028, "FMMU"},

   181

    {0x0029, "SyncM"},

   182

    {0x0032, "TXPDO"},

   183

    {0x0033, "RXPDO"},

   184

    {0x003c, "DC"},

   185

    {}

   186

};

   187

   188

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

   189

   190

const char *CommandSiiRead::getCategoryName(uint16_t type)

   191

{

   192

    const CategoryName *cn = categoryNames;

   193

   194

    while (cn->type) {

   195

        if (cn->type == type) {

   196

            return cn->name;

   197

        }

   198

        cn++;

   199

    }

   200

   201

    return "unknown";

   202

}

   203

   204

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