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 <map>

    32

#include <algorithm>

    33

using namespace std;

    34

    35

#include "CommandGraph.h"

    36

#include "MasterDevice.h"

    37

    38

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

    39

    40

CommandGraph::CommandGraph():

    41

    Command("graph", "Output the bus topology as a graph.")

    42

{

    43

}

    44

    45

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

    46

    47

string CommandGraph::helpString(const string &binaryBaseName) const

    48

{

    49

    stringstream str;

    50

    51

    str

    52

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

    53

        << binaryBaseName << " " << getName() << " [OPTIONS] <INFO>" << endl

    54

        << endl

    55

        << getBriefDescription() << endl

    56

        << endl

    57

        << "The bus is output in DOT language (see" << endl

    58

        << "http://www.graphviz.org/doc/info/lang.html), which can" << endl

    59

        << "be processed with the tools from the Graphviz" << endl

    60

        << "package. Example:" << endl

    61

        << endl

    62

        << "  ethercat graph | dot -Tsvg > bus.svg" << endl

    63

        << endl

    64

        << "See 'man dot' for more information." << endl

    65

        << endl

    66

        << "Additional information at edges and nodes is selected via" << endl

    67

        << "the first argument:" << endl

    68

        << "  DC  - DC timing" << endl

    69

        << "  CRC - CRC error register information" << endl

    70

        << endl;

    71

    72

    return str.str();

    73

}

    74

    75

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

    76

    77

enum Info {

    78

    None,

    79

    DC,

    80

    CRC

    81

};

    82

    83

#define REG_SIZE (20)

    84

    85

struct CrcInfo {

    86

    unsigned int crc[EC_MAX_PORTS];

    87

    unsigned int phy[EC_MAX_PORTS];

    88

    unsigned int fwd[EC_MAX_PORTS];

    89

    unsigned int lnk[EC_MAX_PORTS];

    90

};

    91

    92

void CommandGraph::execute(const StringVector &args)

    93

{

    94

    Info info = None;

    95

    ec_ioctl_master_t master;

    96

    typedef vector<ec_ioctl_slave_t> SlaveVector;

    97

    SlaveVector slaves;

    98

    typedef vector<CrcInfo> CrcInfoVector;

    99

    CrcInfoVector crcInfos;

   100

    ec_ioctl_slave_t slave;

   101

    SlaveVector::const_iterator si;

   102

    map<int, string> portMedia;

   103

    map<int, string>::const_iterator mi;

   104

    map<int, int> mediaWeights;

   105

    map<int, int>::const_iterator wi;

   106

   107

    portMedia[EC_PORT_MII] = "MII";

   108

    mediaWeights[EC_PORT_MII] = 1;

   109

   110

    portMedia[EC_PORT_EBUS] = "EBUS";

   111

    mediaWeights[EC_PORT_EBUS] = 5;

   112

   113

    if (args.size() > 1) {

   114

        stringstream err;

   115

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

   116

        throwInvalidUsageException(err);

   117

    }

   118

   119

    if (args.size() == 1) {

   120

        string arg = args[0];

   121

        transform(arg.begin(), arg.end(),

   122

                arg.begin(), (int (*) (int)) std::toupper);

   123

        if (arg == "DC") {

   124

            info = DC;

   125

        }

   126

        else if (arg == "CRC") {

   127

            info = CRC;

   128

        }

   129

        else {

   130

            stringstream err;

   131

            err << "Unknown argument \"" << args[0] << "\"!";

   132

            throwInvalidUsageException(err);

   133

        }

   134

    }

   135

   136

    MasterDevice m(getSingleMasterIndex());

   137

    m.open(MasterDevice::Read);

   138

    m.getMaster(&master);

   139

   140

    for (unsigned int i = 0; i < master.slave_count; i++) {

   141

        m.getSlave(&slave, i);

   142

        slaves.push_back(slave);

   143

   144

    }

   145

   146

    if (info == CRC) {

   147

        uint8_t data[REG_SIZE];

   148

        ec_ioctl_slave_reg_t io;

   149

        io.emergency = 0;

   150

        io.address = 0x0300;

   151

        io.size = REG_SIZE;

   152

        io.data = data;

   153

   154

        for (unsigned int i = 0; i < master.slave_count; i++) {

   155

            io.slave_position = i;

   156

            try {

   157

                m.readReg(&io);

   158

            } catch (MasterDeviceException &e) {

   159

                throw e;

   160

            }

   161

   162

            CrcInfo crcInfo;

   163

            for (int port = 0; port < EC_MAX_PORTS; port++) {

   164

                crcInfo.crc[port] = io.data[ 0 + port * 2];

   165

                crcInfo.phy[port] = io.data[ 1 + port * 2];

   166

                crcInfo.fwd[port] = io.data[ 8 + port];

   167

                crcInfo.lnk[port] = io.data[16 + port];

   168

            }

   169

            crcInfos.push_back(crcInfo);

   170

        }

   171

    }

   172

   173

    cout << "/* EtherCAT bus graph. Generated by 'ethercat graph'. */" << endl

   174

        << endl

   175

        << "strict graph bus {" << endl

   176

        << "    rankdir=\"LR\"" << endl

   177

        << "    ranksep=0.8" << endl

   178

        << "    nodesep=0.8" << endl

   179

        << "    node [fontname=\"Helvetica\"]" << endl

   180

        << "    edge [fontname=\"Helvetica\",fontsize=\"10\"]" << endl

   181

        << endl

   182

        << "    master [label=\"EtherCAT\\nMaster\"]" << endl;

   183

   184

    if (slaves.size()) {

   185

        cout << "    master -- slave0";

   186

        mi = portMedia.find(slaves.front().ports[0].desc);

   187

        if (mi != portMedia.end())

   188

            cout << "[label=\"" << mi->second << "\"]";

   189

   190

        cout << endl;

   191

    }

   192

    cout << endl;

   193

   194

    uint16_t alias = 0x0000;

   195

    uint16_t pos = 0;

   196

   197

    for (si = slaves.begin(); si != slaves.end(); si++) {

   198

        if (si->alias) {

   199

            alias = si->alias;

   200

            pos = 0;

   201

        }

   202

   203

        cout << "    slave" << si->position << " [shape=\"box\""

   204

            << ",label=\"" << si->position

   205

            << " / " << alias << ":" << pos;

   206

        if (string(si->order).size())

   207

            cout << "\\n" << si->order;

   208

        if (info == DC && si->dc_supported) {

   209

            cout << "\\nDC: ";

   210

            if (si->has_dc_system_time) {

   211

                switch (si->dc_range) {

   212

                    case EC_DC_32:

   213

                        cout << "32 bit";

   214

                        break;

   215

                    case EC_DC_64:

   216

                        cout << "64 bit";

   217

                        break;

   218

                    default:

   219

                        break;

   220

                }

   221

            } else {

   222

                cout << "Delay meas.";

   223

            }

   224

            cout << "\\nDelay: " << si->transmission_delay << " ns";

   225

        }

   226

        cout << "\"]" << endl;

   227

   228

   229

        for (int port = 1; port < EC_MAX_PORTS; port++) {

   230

            uint16_t next_pos = si->ports[port].next_slave;

   231

   232

            if (next_pos == 0xffff) {

   233

                continue;

   234

            }

   235

   236

            if (next_pos >= slaves.size()) {

   237

                cerr << "Invalid next slave pointer." << endl;

   238

                continue;

   239

            }

   240

   241

            ec_ioctl_slave_t *next = &slaves[next_pos];

   242

   243

            cout << "    slave" << si->position << " -- "

   244

                << "slave" << next_pos << " [taillabel=\"" << port;

   245

   246

            if (info == DC && si->dc_supported) {

   247

                cout << " [" << si->ports[port].delay_to_next_dc << "]";

   248

            }

   249

            if (info == CRC) {

   250

                CrcInfo *crcInfo = &crcInfos[si->position];

   251

                cout << " [" << crcInfo->crc[port] << "/"

   252

                    << crcInfo->fwd[port] << "]";

   253

            }

   254

   255

            cout << "\",headlabel=\"0";

   256

   257

            if (info == DC && next->dc_supported) {

   258

                cout << " [" << next->ports[0].delay_to_next_dc << "]";

   259

            }

   260

            if (info == CRC) {

   261

                CrcInfo *crcInfo = &crcInfos[next_pos];

   262

                cout << " [" << crcInfo->crc[0] << "/"

   263

                    << crcInfo->fwd[0] << "]";

   264

            }

   265

            cout << "\"";

   266

   267

            mi = portMedia.find(si->ports[port].desc);

   268

            if (mi == portMedia.end() && next) {

   269

                /* Try medium of next-hop slave. */

   270

                mi = portMedia.find(next->ports[0].desc);

   271

            }

   272

   273

            if (mi != portMedia.end())

   274

                cout << ",label=\"" << mi->second << "\"";

   275

   276

            wi = mediaWeights.find(si->ports[port].desc);

   277

            if (wi != mediaWeights.end())

   278

                cout << ",weight=\"" << wi->second << "\"";

   279

   280

            cout << "]" << endl;

   281

        }

   282

   283

        cout << endl;

   284

        pos++;

   285

    }

   286

   287

    cout << "}" << endl;

   288

}

   289

   290

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