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

    51

{

    52

    stringstream str;

    53

    54

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

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

   157

   158

    for (configIter = configList.begin();

   159

            configIter != configList.end();

   160

            configIter++) {

   161

   162

        cout << indent

   163

            << "Alias: "

   164

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

   165

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

   166

            << "Vendor Id: 0x"

   167

            << hex << setfill('0')

   168

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

   169

            << "Product code: 0x"

   170

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

   171

            << "Attached slave: ";

   172

   173

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

   174

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

   175

            cout << dec << configIter->slave_position

   176

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

   177

        } else {

   178

            cout << "none" << endl;

   179

        }

   180

   181

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

   182

        if (configIter->watchdog_divider) {

   183

            cout << dec << configIter->watchdog_divider;

   184

        } else {

   185

            cout << "(Default)";

   186

        }

   187

        cout << endl << indent

   188

            << "Watchdog intervals: ";

   189

        if (configIter->watchdog_intervals) {

   190

            cout << dec << configIter->watchdog_intervals;

   191

        } else {

   192

            cout << "(Default)";

   193

        }

   194

        cout << endl;

   195

   196

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

   197

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

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

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

   206

                }

   207

                cout << endl;

   208

   209

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

   210

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

   211

   212

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

   213

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

   214

   215

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

   216

                        m.getConfigPdoEntry(&entry,

   217

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

   218

   219

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

   220

                            << hex << setfill('0')

   221

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

   222

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

   223

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

   224

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

   225

                            << " bit" << endl;

   226

                    }

   227

                }

   228

            }

   229

        }

   230

   231

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

   232

        if (configIter->sdo_count) {

   233

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

   234

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

   235

   236

                cout << indent << "  0x"

   237

                    << hex << setfill('0')

   238

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

   239

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

   240

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

   241

   242

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

   243

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

   244

                            (uint32_t) EC_MAX_SDO_DATA_SIZE); i++) {

   245

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

   246

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

   247

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

   248

                    } else {

   249

                        cout << " ";

   250

                    }

   251

                }

   252

   253

                cout << endl;

   254

                if (sdo.size > EC_MAX_SDO_DATA_SIZE) {

   255

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

   256

                }

   257

            }

   258

        } else {

   259

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

   260

        }

   261

   262

        if (configIter->dc_assign_activate) {

   263

            int i;

   264

   265

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

   266

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

   267

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

   268

   269

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

   270

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

   271

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

   272

                    << setfill(' ') << right

   273

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

   274

                    << "  "

   275

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

   276

                    << endl;

   277

            }

   278

        }

   279

        cout << endl;

   280

    }

   281

}

   282

   283

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

   284

   285

/** Lists the bus configuration.

   286

 */

   287

void CommandConfig::listConfigs(

   288

        MasterDevice &m,

   289

        const ConfigList &configList,

   290

        bool doIndent

   291

        )

   292

{

   293

    ConfigList::const_iterator configIter;

   294

    stringstream str;

   295

    Info info;

   296

    typedef list<Info> InfoList;

   297

    InfoList list;

   298

    InfoList::const_iterator iter;

   299

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   300

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   301

    ec_ioctl_slave_t slave;

   302

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

   303

   304

    for (configIter = configList.begin();

   305

            configIter != configList.end();

   306

            configIter++) {

   307

   308

        str << dec << configIter->alias;

   309

        info.alias = str.str();

   310

        str.clear();

   311

        str.str("");

   312

   313

        str << configIter->position;

   314

        info.pos = str.str();

   315

        str.clear();

   316

        str.str("");

   317

   318

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

   319

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

   320

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

   321

        info.ident = str.str();

   322

        str.clear();

   323

        str.str("");

   324

   325

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

   326

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

   327

   328

            str << dec << configIter->slave_position;

   329

            info.slavePos = str.str();

   330

            str.clear();

   331

            str.str("");

   332

   333

            info.state = alStateString(slave.al_state);

   334

        } else {

   335

            str << "-";

   336

            info.slavePos = str.str();

   337

            str.clear();

   338

            str.str("");

   339

   340

            str << "-";

   341

            info.state = str.str();

   342

            str.clear();

   343

            str.str("");

   344

        }

   345

   346

        list.push_back(info);

   347

   348

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

   349

            maxAliasWidth = info.alias.length();

   350

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

   351

            maxPosWidth = info.pos.length();

   352

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

   353

            maxSlavePosWidth = info.slavePos.length();

   354

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

   355

            maxStateWidth = info.state.length();

   356

    }

   357

   358

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

   359

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

   360

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

   361

            << ":" << left

   362

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

   363

            << "  "

   364

            << iter->ident

   365

            << "  "

   366

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

   367

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

   368

            << endl;

   369

    }

   370

}

   371

   372

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