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

    31

#include <iostream>

    32

#include <iomanip>

    33

#include <sstream>

    34

using namespace std;

    35

    36

#include "CommandConfig.h"

    37

#include "MasterDevice.h"

    38

    39

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

    40

    41

CommandConfig::CommandConfig():

    42

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

    43

{

    44

}

    45

    46

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

    47

    48

string CommandConfig::helpString() const

    49

{

    50

    stringstream str;

    51

    52

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

    53

        << endl

    54

        << getBriefDescription() << endl

    55

        << endl

    56

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

    57

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

    58

        << endl

    59

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

    60

        << "|       |                      |  |" << endl

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

        << "|       |                         attached." << endl

    69

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

    70

        << "|          hexadecimal)." << endl

    71

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

    72

        << endl

    73

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

    74

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

    75

        << endl

    76

        << "Configuration selection:" << endl

    77

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

    78

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

    79

        << endl

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

        << "     are displayed." << endl

    87

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

    88

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

    89

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

    90

        << endl

    91

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

    92

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

    93

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

    94

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

    95

        << endl

    96

        << numericInfo();

    97

    98

    return str.str();

    99

}

   100

   101

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

   102

   103

/** Lists the bus configuration.

   104

 */

   105

void CommandConfig::execute(const StringVector &args)

   106

{

   107

    ConfigList configs;

   108

    bool doIndent;

   109

   110

    if (args.size()) {

   111

        stringstream err;

   112

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

   113

        throwInvalidUsageException(err);

   114

    }

   115

   116

    doIndent = getMasterIndices().size() > 1;

   117

    MasterIndexList::const_iterator mi;

   118

    for (mi = getMasterIndices().begin();

   119

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

   120

        MasterDevice m(*mi);

   121

        m.open(MasterDevice::Read);

   122

        configs = selectedConfigs(m);

   123

   124

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

   125

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

   126

        }

   127

   128

        if (getVerbosity() == Verbose) {

   129

            showDetailedConfigs(m, configs, doIndent);

   130

        } else {

   131

            listConfigs(m, configs, doIndent);

   132

        }

   133

    }

   134

}

   135

   136

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

   137

   138

/** Lists the complete bus configuration.

   139

 */

   140

void CommandConfig::showDetailedConfigs(

   141

        MasterDevice &m,

   142

        const ConfigList &configList,

   143

        bool doIndent

   144

        )

   145

{

   146

    ConfigList::const_iterator configIter;

   147

    unsigned int i, j, k, l;

   148

    ec_ioctl_slave_t slave;

   149

    ec_ioctl_config_pdo_t pdo;

   150

    ec_ioctl_config_pdo_entry_t entry;

   151

    ec_ioctl_config_sdo_t sdo;

   152

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

   153

   154

    for (configIter = configList.begin();

   155

            configIter != configList.end();

   156

            configIter++) {

   157

   158

        cout << indent

   159

            << "Alias: "

   160

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

   161

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

   162

            << "Vendor Id: 0x"

   163

            << hex << setfill('0')

   164

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

   165

            << "Product code: 0x"

   166

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

   167

            << "Attached slave: ";

   168

   169

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

   170

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

   171

            cout << dec << configIter->slave_position

   172

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

   173

        } else {

   174

            cout << "none" << endl;

   175

        }

   176

   177

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

   178

        if (configIter->watchdog_divider) {

   179

            cout << dec << configIter->watchdog_divider;

   180

        } else {

   181

            cout << "(Default)";

   182

        }

   183

        cout << endl << indent

   184

            << "Watchdog intervals: ";

   185

        if (configIter->watchdog_intervals) {

   186

            cout << dec << configIter->watchdog_intervals;

   187

        } else {

   188

            cout << "(Default)";

   189

        }

   190

        cout << endl;

   191

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

                }

   203

                cout << endl;

   204

   205

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

   206

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

   207

   208

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

   209

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

   210

   211

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

   212

                        m.getConfigPdoEntry(&entry,

   213

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

   214

   215

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

   216

                            << hex << setfill('0')

   217

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

   218

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

   219

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

   220

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

   221

                            << " bit" << endl;

   222

                    }

   223

                }

   224

            }

   225

        }

   226

   227

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

   228

        if (configIter->sdo_count) {

   229

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

   230

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

   231

   232

                cout << indent << "  0x"

   233

                    << hex << setfill('0')

   234

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

   235

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

   236

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

   237

   238

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

   239

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

   240

                            (uint32_t) EC_MAX_SDO_DATA_SIZE); i++) {

   241

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

   242

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

   243

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

   244

                    } else {

   245

                        cout << " ";

   246

                    }

   247

                }

   248

   249

                cout << endl;

   250

                if (sdo.size > EC_MAX_SDO_DATA_SIZE) {

   251

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

   252

                }

   253

            }

   254

        } else {

   255

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

   256

        }

   257

   258

        if (configIter->dc_assign_activate) {

   259

            int i;

   260

   261

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

   262

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

   263

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

   264

   265

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

   266

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

   267

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

   268

                    << setfill(' ') << right

   269

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

   270

                    << "  "

   271

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

   272

                    << endl;

   273

            }

   274

        }

   275

        cout << endl;

   276

    }

   277

}

   278

   279

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

   280

   281

/** Lists the bus configuration.

   282

 */

   283

void CommandConfig::listConfigs(

   284

        MasterDevice &m,

   285

        const ConfigList &configList,

   286

        bool doIndent

   287

        )

   288

{

   289

    ConfigList::const_iterator configIter;

   290

    stringstream str;

   291

    Info info;

   292

    typedef list<Info> InfoList;

   293

    InfoList list;

   294

    InfoList::const_iterator iter;

   295

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   296

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   297

    ec_ioctl_slave_t slave;

   298

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

   299

   300

    for (configIter = configList.begin();

   301

            configIter != configList.end();

   302

            configIter++) {

   303

   304

        str << dec << configIter->alias;

   305

        info.alias = str.str();

   306

        str.clear();

   307

        str.str("");

   308

   309

        str << configIter->position;

   310

        info.pos = str.str();

   311

        str.clear();

   312

        str.str("");

   313

   314

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

   315

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

   316

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

   317

        info.ident = str.str();

   318

        str.clear();

   319

        str.str("");

   320

   321

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

   322

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

   323

   324

            str << dec << configIter->slave_position;

   325

            info.slavePos = str.str();

   326

            str.clear();

   327

            str.str("");

   328

   329

            str << alStateString(slave.al_state);

   330

            info.state = str.str();

   331

            str.clear();

   332

            str.str("");

   333

        } else {

   334

            str << "-";

   335

            info.slavePos = str.str();

   336

            str.clear();

   337

            str.str("");

   338

   339

            str << "-";

   340

            info.state = str.str();

   341

            str.clear();

   342

            str.str("");

   343

        }

   344

   345

        list.push_back(info);

   346

   347

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

   348

            maxAliasWidth = info.alias.length();

   349

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

   350

            maxPosWidth = info.pos.length();

   351

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

   352

            maxSlavePosWidth = info.slavePos.length();

   353

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

   354

            maxStateWidth = info.state.length();

   355

    }

   356

   357

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

   358

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

   359

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

   360

            << ":" << left

   361

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

   362

            << "  "

   363

            << iter->ident

   364

            << "  "

   365

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

   366

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

   367

            << endl;

   368

    }

   369

}

   370

   371

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