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

 *  vim: expandtab

    29

 *

    30

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

    31

    32

#include <list>

    33

#include <iostream>

    34

#include <iomanip>

    35

#include <sstream>

    36

using namespace std;

    37

    38

#include "CommandConfig.h"

    39

#include "MasterDevice.h"

    40

    41

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

    42

    43

CommandConfig::CommandConfig():

    44

    Command("config", "Show slave configurations.")

    45

{

    46

}

    47

    48

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

    49

    50

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

    51

{

    52

    stringstream str;

    53

    54

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

    55

        << endl

    56

        << getBriefDescription() << endl

    57

        << endl

    58

        << "Without the --verbose option, slave configurations are" << endl

    59

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

    60

        << endl

    61

        << "1001:0  0x0000003b/0x02010000  3  OP" << endl

    62

        << "|       |                      |  |" << endl

    63

        << "|       |                      |  \\- Application-layer" << endl

    64

        << "|       |                      |     state of the attached" << endl

    65

        << "|       |                      |     slave, or '-', if no" << endl

    66

        << "|       |                      |     slave is attached." << endl

    67

        << "|       |                      \\- Absolute decimal ring" << endl

    68

        << "|       |                         position of the attached" << endl

    69

        << "|       |                         slave, or '-' if none" << endl

    70

        << "|       |                         attached." << endl

    71

        << "|       \\- Expected vendor ID and product code (both" << endl

    72

        << "|          hexadecimal)." << endl

    73

        << "\\- Alias address and relative position (both decimal)." << endl

    74

        << endl

    75

        << "With the --verbose option given, the configured PDOs and" << endl

    76

        << "SDOs are output in addition." << endl

    77

        << endl

    78

        << "Configuration selection:" << endl

    79

        << "  Slave configurations can be selected with" << endl

    80

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

    81

        << endl

    82

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

    83

        << "     is given, all slave configurations are displayed." << endl

    84

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

    85

        << "     of zero is assumed (see 4))." << endl

    86

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

    87

        << "     configurations with the given alias address" << endl

    88

        << "     are displayed." << endl

    89

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

    90

        << "     given, the selection can match a single" << endl

    91

        << "     configuration, that is displayed, if it exists." << endl

    92

        << endl

    93

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

    94

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

    95

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

    96

        << "  --verbose  -v          Show detailed configurations." << endl

    97

        << endl

    98

        << numericInfo();

    99

   100

    return str.str();

   101

}

   102

   103

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

   104

   105

/** Lists the bus configuration.

   106

 */

   107

void CommandConfig::execute(const StringVector &args)

   108

{

   109

    MasterIndexList masterIndices;

   110

    bool doIndent;

   111

    ConfigList configs;

   112

   113

    if (args.size()) {

   114

        stringstream err;

   115

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

   116

        throwInvalidUsageException(err);

   117

    }

   118

   119

    masterIndices = getMasterIndices();

   120

    doIndent = masterIndices.size() > 1;

   121

    MasterIndexList::const_iterator mi;

   122

    for (mi = masterIndices.begin();

   123

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

   124

        MasterDevice m(*mi);

   125

        m.open(MasterDevice::Read);

   126

        configs = selectedConfigs(m);

   127

   128

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

   129

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

   130

        }

   131

   132

        if (getVerbosity() == Verbose) {

   133

            showDetailedConfigs(m, configs, doIndent);

   134

        } else {

   135

            listConfigs(m, configs, doIndent);

   136

        }

   137

    }

   138

}

   139

   140

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

   141

   142

/** Lists the complete bus configuration.

   143

 */

   144

void CommandConfig::showDetailedConfigs(

   145

        MasterDevice &m,

   146

        const ConfigList &configList,

   147

        bool doIndent

   148

        )

   149

{

   150

    ConfigList::const_iterator configIter;

   151

    unsigned int i, j, k, l;

   152

    ec_ioctl_slave_t slave;

   153

    ec_ioctl_config_pdo_t pdo;

   154

    ec_ioctl_config_pdo_entry_t entry;

   155

    ec_ioctl_config_sdo_t sdo;

   156

    ec_ioctl_config_idn_t idn;

   157

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

   158

   159

    for (configIter = configList.begin();

   160

            configIter != configList.end();

   161

            configIter++) {

   162

   163

        cout << indent

   164

            << "Alias: "

   165

            << dec << configIter->alias << endl << indent

   166

            << "Position: " << configIter->position << endl << indent

   167

            << "Vendor Id: 0x"

   168

            << hex << setfill('0')

   169

            << setw(8) << configIter->vendor_id << endl << indent

   170

            << "Product code: 0x"

   171

            << setw(8) << configIter->product_code << endl << indent

   172

            << "Attached slave: ";

   173

   174

        if (configIter->slave_position != -1) {

   175

            m.getSlave(&slave, configIter->slave_position);

   176

            cout << dec << configIter->slave_position

   177

                << " (" << alStateString(slave.al_state) << ")" << endl;

   178

        } else {

   179

            cout << "none" << endl;

   180

        }

   181

   182

        cout << indent << "Watchdog divider: ";

   183

        if (configIter->watchdog_divider) {

   184

            cout << dec << configIter->watchdog_divider;

   185

        } else {

   186

            cout << "(Default)";

   187

        }

   188

        cout << endl << indent

   189

            << "Watchdog intervals: ";

   190

        if (configIter->watchdog_intervals) {

   191

            cout << dec << configIter->watchdog_intervals;

   192

        } else {

   193

            cout << "(Default)";

   194

        }

   195

        cout << endl;

   196

   197

        for (j = 0; j < EC_MAX_SYNC_MANAGERS; j++) {

   198

            if (configIter->syncs[j].pdo_count) {

   199

                cout << indent << "SM" << dec << j << ", Dir: "

   200

                    << (configIter->syncs[j].dir == EC_DIR_INPUT

   201

                            ? "Input" : "Output") << ", Watchdog: ";

   202

                switch (configIter->syncs[j].watchdog_mode) {

   203

                    case EC_WD_DEFAULT: cout << "Default"; break;

   204

                    case EC_WD_ENABLE: cout << "Enable"; break;

   205

                    case EC_WD_DISABLE: cout << "Disable"; break;

   206

                    default: cout << "???"; break;

   207

                }

   208

                cout << endl;

   209

   210

                for (k = 0; k < configIter->syncs[j].pdo_count; k++) {

   211

                    m.getConfigPdo(&pdo, configIter->config_index, j, k);

   212

   213

                    cout << indent << "  PDO 0x" << hex << setfill('0')

   214

                        << setw(4) << pdo.index << endl;

   215

   216

                    for (l = 0; l < pdo.entry_count; l++) {

   217

                        m.getConfigPdoEntry(&entry,

   218

                                configIter->config_index, j, k, l);

   219

   220

                        cout << indent << "    PDO entry 0x"

   221

                            << hex << setfill('0')

   222

                            << setw(4) << entry.index << ":"

   223

                            << setw(2) << (unsigned int) entry.subindex

   224

                            << ", " << dec << setfill(' ')

   225

                            << setw(2) << (unsigned int) entry.bit_length

   226

                            << " bit" << endl;

   227

                    }

   228

                }

   229

            }

   230

        }

   231

   232

        cout << indent << "SDO configuration:" << endl;

   233

        if (configIter->sdo_count) {

   234

            for (j = 0; j < configIter->sdo_count; j++) {

   235

                m.getConfigSdo(&sdo, configIter->config_index, j);

   236

   237

                cout << indent << "  0x"

   238

                    << hex << setfill('0')

   239

                    << setw(4) << sdo.index;

   240

                if (sdo.complete_access) {

   241

                    cout << " C";

   242

                }

   243

                else {

   244

                    cout << ":" << setw(2) << (unsigned int) sdo.subindex;

   245

                }

   246

                cout << ", " << dec << sdo.size << " byte" << endl;

   247

   248

                cout << indent << "    " << hex;

   249

                for (i = 0; i < min((uint32_t) sdo.size,

   250

                            (uint32_t) EC_MAX_SDO_DATA_SIZE); i++) {

   251

                    cout << setw(2) << (unsigned int) sdo.data[i];

   252

                    if ((i + 1) % 16 == 0 && i < sdo.size - 1) {

   253

                        cout << endl << indent << "    ";

   254

                    } else {

   255

                        cout << " ";

   256

                    }

   257

                }

   258

   259

                cout << endl;

   260

                if (sdo.size > EC_MAX_SDO_DATA_SIZE) {

   261

                    cout << indent << "    ..." << endl;

   262

                }

   263

            }

   264

        } else {

   265

            cout << indent << "  None." << endl;

   266

        }

   267

   268

        cout << indent << "IDN configuration:" << endl;

   269

        if (configIter->idn_count) {

   270

            for (j = 0; j < configIter->idn_count; j++) {

   271

                m.getConfigIdn(&idn, configIter->config_index, j);

   272

   273

                cout << indent << "  Drive " << (unsigned int) idn.drive_no

   274

                    << ", " << outputIdn(idn.idn)

   275

                    << ", " << dec << idn.size << " byte" << endl;

   276

   277

                cout << indent << "    " << hex << setfill('0');

   278

                for (i = 0; i < min((uint32_t) idn.size,

   279

                            (uint32_t) EC_MAX_IDN_DATA_SIZE); i++) {

   280

                    cout << setw(2) << (unsigned int) idn.data[i];

   281

                    if ((i + 1) % 16 == 0 && i < idn.size - 1) {

   282

                        cout << endl << indent << "    ";

   283

                    } else {

   284

                        cout << " ";

   285

                    }

   286

                }

   287

   288

                cout << endl;

   289

                if (idn.size > EC_MAX_IDN_DATA_SIZE) {

   290

                    cout << indent << "    ..." << endl;

   291

                }

   292

            }

   293

        } else {

   294

            cout << indent << "  None." << endl;

   295

        }

   296

        if (configIter->dc_assign_activate) {

   297

            int i;

   298

   299

            cout << indent << "DC configuration:" << endl

   300

                << indent << "  AssignActivate: 0x" << hex << setfill('0')

   301

                << setw(4) << configIter->dc_assign_activate << endl;

   302

   303

            cout << indent << "         Cycle [ns]   Shift [ns]" << endl;

   304

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

   305

                cout << indent << "  SYNC" << dec << i << "  "

   306

                    << setfill(' ') << right

   307

                    << setw(11) << configIter->dc_sync[i].cycle_time

   308

                    << "  "

   309

                    << setw(11) << configIter->dc_sync[i].shift_time

   310

                    << endl;

   311

            }

   312

        }

   313

        cout << endl;

   314

    }

   315

}

   316

   317

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

   318

   319

/** Lists the bus configuration.

   320

 */

   321

void CommandConfig::listConfigs(

   322

        MasterDevice &m,

   323

        const ConfigList &configList,

   324

        bool doIndent

   325

        )

   326

{

   327

    ConfigList::const_iterator configIter;

   328

    stringstream str;

   329

    Info info;

   330

    typedef list<Info> InfoList;

   331

    InfoList list;

   332

    InfoList::const_iterator iter;

   333

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   334

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   335

    ec_ioctl_slave_t slave;

   336

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

   337

   338

    for (configIter = configList.begin();

   339

            configIter != configList.end();

   340

            configIter++) {

   341

   342

        str << dec << configIter->alias;

   343

        info.alias = str.str();

   344

        str.clear();

   345

        str.str("");

   346

   347

        str << configIter->position;

   348

        info.pos = str.str();

   349

        str.clear();

   350

        str.str("");

   351

   352

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

   353

            << "0x" << setw(8) << configIter->vendor_id

   354

            << "/0x" << setw(8) << configIter->product_code;

   355

        info.ident = str.str();

   356

        str.clear();

   357

        str.str("");

   358

   359

        if (configIter->slave_position != -1) {

   360

            m.getSlave(&slave, configIter->slave_position);

   361

   362

            str << dec << configIter->slave_position;

   363

            info.slavePos = str.str();

   364

            str.clear();

   365

            str.str("");

   366

   367

            info.state = alStateString(slave.al_state);

   368

        } else {

   369

            str << "-";

   370

            info.slavePos = str.str();

   371

            str.clear();

   372

            str.str("");

   373

   374

            str << "-";

   375

            info.state = str.str();

   376

            str.clear();

   377

            str.str("");

   378

        }

   379

   380

        list.push_back(info);

   381

   382

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

   383

            maxAliasWidth = info.alias.length();

   384

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

   385

            maxPosWidth = info.pos.length();

   386

        if (info.slavePos.length() > maxSlavePosWidth)

   387

            maxSlavePosWidth = info.slavePos.length();

   388

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

   389

            maxStateWidth = info.state.length();

   390

    }

   391

   392

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

   393

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

   394

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

   395

            << ":" << left

   396

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

   397

            << "  "

   398

            << iter->ident

   399

            << "  "

   400

            << setw(maxSlavePosWidth) << iter->slavePos << "  "

   401

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

   402

            << endl;

   403

    }

   404

}

   405

   406

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