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

#include <list>

    33

#include <string.h>

    34

using namespace std;

    35

    36

#include "CommandSlaves.h"

    37

#include "MasterDevice.h"

    38

    39

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

    40

    41

CommandSlaves::CommandSlaves():

    42

    Command("slaves", "Display slaves on the bus.")

    43

{

    44

}

    45

    46

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

    47

    48

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

    49

{

    50

    stringstream str;

    51

    52

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

    53

        << endl

    54

        << getBriefDescription() << endl

    55

        << endl

    56

        << "If the --verbose option is not given, the slaves are" << endl

    57

        << "displayed one-per-line. Example:" << endl

    58

        << endl

    59

        << "1  5555:0  PREOP  +  EL3162 2C. Ana. Input 0-10V" << endl

    60

        << "|  |    |  |      |  |" << endl

    61

        << "|  |    |  |      |  \\- Name from the SII if avaliable," << endl

    62

        << "|  |    |  |      |     otherwise vendor ID and product" << endl

    63

        << "|  |    |  |      |     code (both hexadecimal)." << endl

    64

        << "|  |    |  |      \\- Error flag. '+' means no error," << endl

    65

        << "|  |    |  |         'E' means that scan or" << endl

    66

        << "|  |    |  |         configuration failed." << endl

    67

        << "|  |    |  \\- Current application-layer state." << endl

    68

        << "|  |    \\- Decimal relative position to the last" << endl

    69

        << "|  |       slave with an alias address set." << endl

    70

        << "|  \\- Decimal alias address of this slave (if set)," << endl

    71

        << "|     otherwise of the last slave with an alias set," << endl

    72

        << "|     or zero, if no alias was encountered up to this" << endl

    73

        << "|     position." << endl

    74

        << "\\- Absolute ring position in the bus." << endl

    75

        << endl

    76

        << "If the --verbose option is given, a detailed (multi-line)" << endl

    77

        << "description is output for each slave." << endl

    78

        << endl

    79

        << "Slave selection:" << endl

    80

        << "  Slaves for this and other commands can be selected with" << endl

    81

        << "  the --alias and --position parameters as follows:" << endl

    82

        << endl

    83

        << "  1) If neither the --alias nor the --position option" << endl

    84

        << "     is given, all slaves are selected." << endl

    85

        << "  2) If only the --position option is given, it is" << endl

    86

        << "     interpreted as an absolute ring position and" << endl

    87

        << "     a slave with this position is matched." << endl

    88

        << "  3) If only the --alias option is given, all slaves" << endl

    89

        << "     with the given alias address and subsequent" << endl

    90

        << "     slaves before a slave with a different alias" << endl

    91

        << "     address match (use -p0 if only the slaves" << endl

    92

        << "     with the given alias are desired, see 4))." << endl

    93

        << "  4) If both the --alias and the --position option are" << endl

    94

        << "     given, the latter is interpreted as relative" << endl

    95

        << "     position behind any slave with the given alias." << endl

    96

        << endl

    97

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

    98

        << "  --alias    -a <alias>  Slave alias (see above)." << endl

    99

        << "  --position -p <pos>    Slave position (see above)." << endl

   100

        << "  --verbose  -v          Show detailed slave information." << endl

   101

        << endl

   102

        << numericInfo();

   103

   104

    return str.str();

   105

}

   106

   107

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

   108

   109

void CommandSlaves::execute(const StringVector &args)

   110

{

   111

	MasterIndexList masterIndices;

   112

    SlaveList slaves;

   113

    bool doIndent;

   114

   115

    if (args.size()) {

   116

        stringstream err;

   117

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

   118

        throwInvalidUsageException(err);

   119

    }

   120

   121

	masterIndices = getMasterIndices();

   122

    doIndent = masterIndices.size() > 1;

   123

    MasterIndexList::const_iterator mi;

   124

    for (mi = masterIndices.begin();

   125

            mi != masterIndices.end(); mi++) {

   126

        MasterDevice m(*mi);

   127

        m.open(MasterDevice::Read);

   128

        slaves = selectedSlaves(m);

   129

   130

        if (getVerbosity() == Verbose) {

   131

            showSlaves(m, slaves);

   132

        } else {

   133

            listSlaves(m, slaves, doIndent);

   134

        }

   135

    }

   136

}

   137

   138

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

   139

   140

void CommandSlaves::listSlaves(

   141

        MasterDevice &m,

   142

        const SlaveList &slaves,

   143

        bool doIndent

   144

        )

   145

{

   146

    ec_ioctl_master_t master;

   147

    unsigned int i, lastDevice;

   148

    ec_ioctl_slave_t slave;

   149

    uint16_t lastAlias, aliasIndex;

   150

    Info info;

   151

    typedef list<Info> InfoList;

   152

    InfoList infoList;

   153

    InfoList::const_iterator iter;

   154

    stringstream str;

   155

    unsigned int maxPosWidth = 0, maxAliasWidth = 0,

   156

                 maxRelPosWidth = 0, maxStateWidth = 0;

   157

    string indent(doIndent ? "  " : "");

   158

   159

    m.getMaster(&master);

   160

   161

    lastAlias = 0;

   162

    aliasIndex = 0;

   163

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

   164

        m.getSlave(&slave, i);

   165

   166

        if (slave.alias) {

   167

            lastAlias = slave.alias;

   168

            aliasIndex = 0;

   169

        }

   170

   171

        if (slaveInList(slave, slaves)) {

   172

            str << dec << i;

   173

            info.pos = str.str();

   174

            str.clear();

   175

            str.str("");

   176

   177

            str << lastAlias;

   178

            info.alias = str.str();

   179

            str.str("");

   180

   181

            str << aliasIndex;

   182

            info.relPos = str.str();

   183

            str.str("");

   184

   185

            info.state = alStateString(slave.al_state);

   186

            info.flag = (slave.error_flag ? 'E' : '+');

   187

            info.device = slave.device_index;

   188

   189

            if (strlen(slave.name)) {

   190

                info.name = slave.name;

   191

            } else {

   192

                str << "0x" << hex << setfill('0')

   193

                    << setw(8) << slave.vendor_id << ":0x"

   194

                    << setw(8) << slave.product_code;

   195

                info.name = str.str();

   196

                str.str("");

   197

            }

   198

   199

   200

            infoList.push_back(info);

   201

   202

            if (info.pos.length() > maxPosWidth)

   203

                maxPosWidth = info.pos.length();

   204

            if (info.alias.length() > maxAliasWidth)

   205

                maxAliasWidth = info.alias.length();

   206

            if (info.relPos.length() > maxRelPosWidth)

   207

                maxRelPosWidth = info.relPos.length();

   208

            if (info.state.length() > maxStateWidth)

   209

                maxStateWidth = info.state.length();

   210

        }

   211

   212

        aliasIndex++;

   213

    }

   214

   215

    if (infoList.size() && doIndent) {

   216

        cout << "Master" << dec << m.getIndex() << endl;

   217

    }

   218

   219

    lastDevice = EC_DEVICE_MAIN;

   220

    for (iter = infoList.begin(); iter != infoList.end(); iter++) {

   221

        if (iter->device != lastDevice) {

   222

            lastDevice = iter->device;

   223

            cout << "xxx LINK FAILURE xxx" << endl;

   224

        }

   225

        cout << indent << setfill(' ') << right

   226

            << setw(maxPosWidth) << iter->pos << "  "

   227

            << setw(maxAliasWidth) << iter->alias

   228

            << ":" << left

   229

            << setw(maxRelPosWidth) << iter->relPos << "  "

   230

            << setw(maxStateWidth) << iter->state << "  "

   231

            << iter->flag << "  "

   232

            << iter->name << endl;

   233

    }

   234

}

   235

   236

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

   237

   238

void CommandSlaves::showSlaves(

   239

        MasterDevice &m,

   240

        const SlaveList &slaves

   241

        )

   242

{

   243

    SlaveList::const_iterator si;

   244

    int i;

   245

   246

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

   247

        cout << "=== Master " << dec << m.getIndex()

   248

            << ", Slave " << dec << si->position << " ===" << endl;

   249

   250

        if (si->alias)

   251

            cout << "Alias: " << si->alias << endl;

   252

   253

        cout

   254

            << "Device: " << (si->device_index ? "Backup" : "Main") << endl

   255

            << "State: " << alStateString(si->al_state) << endl

   256

            << "Flag: " << (si->error_flag ? 'E' : '+') << endl

   257

            << "Identity:" << endl

   258

            << "  Vendor Id:       0x"

   259

            << hex << setfill('0')

   260

            << setw(8) << si->vendor_id << endl

   261

            << "  Product code:    0x"

   262

            << setw(8) << si->product_code << endl

   263

            << "  Revision number: 0x"

   264

            << setw(8) << si->revision_number << endl

   265

            << "  Serial number:   0x"

   266

            << setw(8) << si->serial_number << endl;

   267

   268

        cout << "DL information:" << endl

   269

            << "  FMMU bit operation: "

   270

            << (si->fmmu_bit ? "yes" : "no") << endl

   271

            << "  Distributed clocks: ";

   272

        if (si->dc_supported) {

   273

            if (si->has_dc_system_time) {

   274

                cout << "yes, ";

   275

                switch (si->dc_range) {

   276

                    case EC_DC_32:

   277

                        cout << "32 bit";

   278

                        break;

   279

                    case EC_DC_64:

   280

                        cout << "64 bit";

   281

                        break;

   282

                    default:

   283

                        cout << "???";

   284

                }

   285

                cout << endl;

   286

            } else {

   287

                cout << "yes, delay measurement only" << endl;

   288

            }

   289

            cout << "  DC system time transmission delay: "

   290

                << dec << si->transmission_delay << " ns" << endl;

   291

        } else {

   292

            cout << "no" << endl;

   293

        }

   294

   295

        cout << "Port  Type  Link  Loop    Signal  NextSlave";

   296

        if (si->dc_supported)

   297

            cout << "  RxTime [ns]  Diff [ns]   NextDc [ns]";

   298

        cout << endl;

   299

   300

        for (i = 0; i < EC_MAX_PORTS; i++) {

   301

            cout << "   " << i << "  " << setfill(' ') << left << setw(4);

   302

            switch (si->ports[i].desc) {

   303

                case EC_PORT_NOT_IMPLEMENTED:

   304

                    cout << "N/A";

   305

                    break;

   306

                case EC_PORT_NOT_CONFIGURED:

   307

                    cout << "N/C";

   308

                    break;

   309

                case EC_PORT_EBUS:

   310

                    cout << "EBUS";

   311

                    break;

   312

                case EC_PORT_MII:

   313

                    cout << "MII";

   314

                    break;

   315

                default:

   316

                    cout << "???";

   317

            }

   318

   319

            cout << "  " << setw(4)

   320

                << (si->ports[i].link.link_up ? "up" : "down")

   321

                << "  " << setw(6)

   322

                << (si->ports[i].link.loop_closed ? "closed" : "open")

   323

                << "  " << setw(6)

   324

                << (si->ports[i].link.signal_detected ? "yes" : "no")

   325

                << "  " << setw(9) << right;

   326

   327

            if (si->ports[i].next_slave != 0xffff) {

   328

                cout << dec << si->ports[i].next_slave;

   329

            } else {

   330

                cout << "-";

   331

            }

   332

   333

            if (si->dc_supported) {

   334

                cout << "  " << setw(11) << right;

   335

                if (!si->ports[i].link.loop_closed) {

   336

                    cout << dec << si->ports[i].receive_time;

   337

                } else {

   338

                    cout << "-";

   339

                }

   340

                cout << "  " << setw(10);

   341

                if (!si->ports[i].link.loop_closed) {

   342

                    cout << si->ports[i].receive_time -

   343

                        si->ports[0].receive_time;

   344

                } else {

   345

                    cout << "-";

   346

                }

   347

                cout << "  " << setw(10);

   348

                if (!si->ports[i].link.loop_closed) {

   349

                    cout << si->ports[i].delay_to_next_dc;

   350

                } else {

   351

                    cout << "-";

   352

                }

   353

            }

   354

   355

            cout << endl;

   356

        }

   357

   358

        if (si->mailbox_protocols) {

   359

            list<string> protoList;

   360

            list<string>::const_iterator protoIter;

   361

   362

            cout << "Mailboxes:" << endl

   363

                << "  Bootstrap RX: 0x" << setfill('0')

   364

                << hex << setw(4) << si->boot_rx_mailbox_offset << "/"

   365

                << dec << si->boot_rx_mailbox_size

   366

                << ", TX: 0x"

   367

                << hex << setw(4) << si->boot_tx_mailbox_offset << "/"

   368

                << dec << si->boot_tx_mailbox_size << endl

   369

                << "  Standard  RX: 0x"

   370

                << hex << setw(4) << si->std_rx_mailbox_offset << "/"

   371

                << dec << si->std_rx_mailbox_size

   372

                << ", TX: 0x"

   373

                << hex << setw(4) << si->std_tx_mailbox_offset << "/"

   374

                << dec << si->std_tx_mailbox_size << endl

   375

                << "  Supported protocols: ";

   376

   377

            if (si->mailbox_protocols & EC_MBOX_AOE) {

   378

                protoList.push_back("AoE");

   379

            }

   380

            if (si->mailbox_protocols & EC_MBOX_EOE) {

   381

                protoList.push_back("EoE");

   382

            }

   383

            if (si->mailbox_protocols & EC_MBOX_COE) {

   384

                protoList.push_back("CoE");

   385

            }

   386

            if (si->mailbox_protocols & EC_MBOX_FOE) {

   387

                protoList.push_back("FoE");

   388

            }

   389

            if (si->mailbox_protocols & EC_MBOX_SOE) {

   390

                protoList.push_back("SoE");

   391

            }

   392

            if (si->mailbox_protocols & EC_MBOX_VOE) {

   393

                protoList.push_back("VoE");

   394

            }

   395

   396

            for (protoIter = protoList.begin(); protoIter != protoList.end();

   397

                    protoIter++) {

   398

                if (protoIter != protoList.begin())

   399

                    cout << ", ";

   400

                cout << *protoIter;

   401

            }

   402

            cout << endl;

   403

        }

   404

   405

        if (si->has_general_category) {

   406

            cout << "General:" << endl

   407

                << "  Group: " << si->group << endl

   408

                << "  Image name: " << si->image << endl

   409

                << "  Order number: " << si->order << endl

   410

                << "  Device name: " << si->name << endl;

   411

   412

            if (si->mailbox_protocols & EC_MBOX_COE) {

   413

                cout << "  CoE details:" << endl

   414

                    << "    Enable SDO: "

   415

                    << (si->coe_details.enable_sdo ? "yes" : "no") << endl

   416

                    << "    Enable SDO Info: "

   417

                    << (si->coe_details.enable_sdo_info ? "yes" : "no")

   418

                    << endl

   419

                    << "    Enable PDO Assign: "

   420

                    << (si->coe_details.enable_pdo_assign

   421

                            ? "yes" : "no") << endl

   422

                    << "    Enable PDO Configuration: "

   423

                    << (si->coe_details.enable_pdo_configuration

   424

                            ? "yes" : "no") << endl

   425

                    << "    Enable Upload at startup: "

   426

                    << (si->coe_details.enable_upload_at_startup

   427

                            ? "yes" : "no") << endl

   428

                    << "    Enable SDO complete access: "

   429

                    << (si->coe_details.enable_sdo_complete_access

   430

                            ? "yes" : "no") << endl;

   431

            }

   432

   433

            cout << "  Flags:" << endl

   434

                << "    Enable SafeOp: "

   435

                << (si->general_flags.enable_safeop ? "yes" : "no") << endl

   436

                << "    Enable notLRW: "

   437

                << (si->general_flags.enable_not_lrw ? "yes" : "no") << endl

   438

                << "  Current consumption: "

   439

                << dec << si->current_on_ebus << " mA" << endl;

   440

        }

   441

    }

   442

}

   443

   444

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

   445

   446

bool CommandSlaves::slaveInList(

   447

        const ec_ioctl_slave_t &slave,

   448

        const SlaveList &slaves

   449

        )

   450

{

   451

    SlaveList::const_iterator si;

   452

   453

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

   454

        if (si->position == slave.position) {

   455

            return true;

   456

        }

   457

    }

   458

   459

    return false;

   460

}

   461

   462

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