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

    33

using namespace std;

    34

    35

#include "Command.h"

    36

#include "MasterDevice.h"

    37

#include "NumberListParser.h"

    38

    39

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

    40

    41

class MasterIndexParser:

    42

    public NumberListParser

    43

{

    44

    protected:

    45

        int getMax() {

    46

            MasterDevice dev;

    47

            dev.setIndex(0U);

    48

            dev.open(MasterDevice::Read);

    49

            return (int) dev.getMasterCount() - 1;

    50

        };

    51

};

    52

    53

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

    54

    55

class SlaveAliasParser:

    56

    public NumberListParser

    57

{

    58

    public:

    59

        SlaveAliasParser(ec_ioctl_master_t &master, MasterDevice &dev):

    60

            master(master), dev(dev) {}

    61

    62

    protected:

    63

        int getMax() {

    64

            unsigned int i;

    65

    66

            uint16_t maxAlias = 0;

    67

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

    68

                ec_ioctl_slave_t slave;

    69

                dev.getSlave(&slave, i);

    70

                if (slave.alias > maxAlias) {

    71

                    maxAlias = slave.alias;

    72

                }

    73

            }

    74

            return maxAlias ? maxAlias : -1;

    75

        };

    76

    77

    private:

    78

        ec_ioctl_master_t &master;

    79

        MasterDevice &dev;

    80

};

    81

    82

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

    83

    84

class ConfigAliasParser:

    85

    public NumberListParser

    86

{

    87

    public:

    88

        ConfigAliasParser(ec_ioctl_master_t &master, MasterDevice &dev):

    89

            master(master), dev(dev) {}

    90

    91

    protected:

    92

        int getMax() {

    93

            unsigned int i;

    94

    95

            uint16_t maxAlias = 0;

    96

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

    97

                ec_ioctl_config_t config;

    98

                dev.getConfig(&config, i);

    99

                if (config.alias > maxAlias) {

   100

                    maxAlias = config.alias;

   101

                }

   102

            }

   103

            return maxAlias ? maxAlias : -1;

   104

        };

   105

   106

    private:

   107

        ec_ioctl_master_t &master;

   108

        MasterDevice &dev;

   109

};

   110

   111

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

   112

   113

class PositionParser:

   114

    public NumberListParser

   115

{

   116

    public:

   117

        PositionParser(unsigned int count):

   118

            count(count) {}

   119

   120

    protected:

   121

        int getMax() {

   122

            return count - 1;

   123

        };

   124

   125

    private:

   126

        const unsigned int count;

   127

};

   128

   129

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

   130

   131

Command::Command(const string &name, const string &briefDesc):

   132

    name(name),

   133

    briefDesc(briefDesc),

   134

    verbosity(Normal)

   135

{

   136

}

   137

   138

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

   139

   140

Command::~Command()

   141

{

   142

}

   143

   144

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

   145

   146

void Command::setMasters(const string &m)

   147

{

   148

    masters = m;

   149

};

   150

   151

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

   152

   153

void Command::setVerbosity(Verbosity v)

   154

{

   155

    verbosity = v;

   156

};

   157

   158

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

   159

   160

void Command::setAliases(const string &a)

   161

{

   162

    aliases = a;

   163

};

   164

   165

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

   166

   167

void Command::setPositions(const string &p)

   168

{

   169

    positions = p;

   170

};

   171

   172

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

   173

   174

void Command::setDomains(const string &d)

   175

{

   176

    domains = d;

   177

};

   178

   179

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

   180

   181

void Command::setDataType(const string &t)

   182

{

   183

    dataType = t;

   184

};

   185

   186

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

   187

   188

void Command::setForce(bool f)

   189

{

   190

    force = f;

   191

};

   192

   193

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

   194

   195

void Command::setOutputFile(const string &f)

   196

{

   197

    outputFile = f;

   198

};

   199

   200

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

   201

   202

bool Command::matchesSubstr(const string &cmd) const

   203

{

   204

    return name.substr(0, cmd.length()) == cmd;

   205

}

   206

   207

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

   208

   209

bool Command::matchesAbbrev(const string &abb) const

   210

{

   211

    unsigned int i;

   212

    size_t pos = 0;

   213

   214

    for (i = 0; i < abb.length(); i++) {

   215

        pos = name.find(abb[i], pos);

   216

        if (pos == string::npos)

   217

            return false;

   218

    }

   219

   220

    return true;

   221

}

   222

   223

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

   224

   225

string Command::numericInfo()

   226

{

   227

    stringstream str;

   228

   229

    str << "Numerical values can be specified either with decimal (no" << endl

   230

        << "prefix), octal (prefix '0') or hexadecimal (prefix '0x') base."

   231

        << endl;

   232

   233

    return str.str();

   234

}

   235

   236

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

   237

   238

void Command::throwInvalidUsageException(const stringstream &s) const

   239

{

   240

    throw InvalidUsageException(s);

   241

}

   242

   243

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

   244

   245

void Command::throwCommandException(const string &msg) const

   246

{

   247

    throw CommandException(msg);

   248

}

   249

   250

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

   251

   252

void Command::throwCommandException(const stringstream &s) const

   253

{

   254

    throw CommandException(s);

   255

}

   256

   257

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

   258

   259

void Command::throwSingleSlaveRequired(unsigned int size) const

   260

{

   261

    stringstream err;

   262

   263

    err << "The slave selection matches " << size << " slaves. '"

   264

        << name << "' requires a single slave.";

   265

   266

    throwInvalidUsageException(err);

   267

}

   268

   269

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

   270

   271

Command::MasterIndexList Command::getMasterIndices() const

   272

{

   273

    MasterIndexList indices;

   274

   275

    try {

   276

        MasterIndexParser p;

   277

        indices = p.parse(masters.c_str());

   278

    } catch (MasterDeviceException &e) {

   279

        stringstream err;

   280

        err << "Failed to obtain number of masters: " << e.what();

   281

        throwCommandException(err);

   282

    } catch (runtime_error &e) {

   283

        stringstream err;

   284

        err << "Invalid master argument '" << masters << "': " << e.what();

   285

        throwInvalidUsageException(err);

   286

    }

   287

   288

    return indices;

   289

}

   290

   291

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

   292

   293

unsigned int Command::getSingleMasterIndex() const

   294

{

   295

    MasterIndexList masterIndices = getMasterIndices();

   296

    if (masterIndices.size() != 1) {

   297

        stringstream err;

   298

        err << getName() << " requires to select a single master!";

   299

        throwInvalidUsageException(err);

   300

    }

   301

    return masterIndices.front();

   302

}

   303

   304

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

   305

   306

Command::SlaveList Command::selectedSlaves(MasterDevice &m)

   307

{

   308

    ec_ioctl_master_t master;

   309

    unsigned int i;

   310

    ec_ioctl_slave_t slave;

   311

    SlaveList list;

   312

   313

    m.getMaster(&master);

   314

   315

    if (aliases == "-") { // no alias given

   316

        PositionParser pp(master.slave_count);

   317

        NumberListParser::List posList = pp.parse(positions.c_str());

   318

        NumberListParser::List::const_iterator pi;

   319

        for (pi = posList.begin(); pi != posList.end(); pi++) {

   320

            m.getSlave(&slave, *pi);

   321

            list.push_back(slave);

   322

        }

   323

    } else { // aliases given

   324

        SlaveAliasParser ap(master, m);

   325

        NumberListParser::List aliasList = ap.parse(aliases.c_str());

   326

        NumberListParser::List::const_iterator ai;

   327

   328

        for (ai = aliasList.begin(); ai != aliasList.end(); ai++) {

   329

   330

            // gather slaves with that alias (and following)

   331

            uint16_t lastAlias = 0;

   332

            vector<ec_ioctl_slave_t> aliasSlaves;

   333

   334

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

   335

                m.getSlave(&slave, i);

   336

                if (slave.alias) {

   337

                    if (lastAlias && lastAlias == *ai && slave.alias != *ai) {

   338

                        // ignore multiple ocurrences of the same alias to

   339

                        // assure consistency for the position argument

   340

                        break;

   341

                    }

   342

                    lastAlias = slave.alias;

   343

                }

   344

                if (lastAlias == *ai) {

   345

                    aliasSlaves.push_back(slave);

   346

                }

   347

            }

   348

   349

            PositionParser pp(aliasSlaves.size());

   350

            NumberListParser::List posList = pp.parse(positions.c_str());

   351

            NumberListParser::List::const_iterator pi;

   352

   353

            for (pi = posList.begin(); pi != posList.end(); pi++) {

   354

                if (*pi < aliasSlaves.size()) {

   355

                    list.push_back(aliasSlaves[*pi]);

   356

                } else {

   357

                    stringstream err;

   358

                    err << "Warning: Slave " << *ai << ":" << *pi

   359

                        << " does not exist on master " << m.getIndex();

   360

                    throwCommandException(err);

   361

                }

   362

            }

   363

        }

   364

    }

   365

   366

    return list;

   367

}

   368

   369

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

   370

   371

bool operator<(

   372

        const ec_ioctl_config_t &a,

   373

        const ec_ioctl_config_t &b

   374

        )

   375

{

   376

    return a.alias < b.alias

   377

        || (a.alias == b.alias && a.position < b.position);

   378

}

   379

   380

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

   381

   382

Command::ConfigList Command::selectedConfigs(MasterDevice &m)

   383

{

   384

    unsigned int i;

   385

    ec_ioctl_master_t master;

   386

    ec_ioctl_config_t config;

   387

    ConfigList list;

   388

    stringstream err;

   389

   390

    m.getMaster(&master);

   391

   392

    if (aliases == "-") { // no alias given

   393

        PositionParser pp(master.config_count);

   394

        NumberListParser::List posList = pp.parse(positions.c_str());

   395

        NumberListParser::List::const_iterator pi;

   396

        for (pi = posList.begin(); pi != posList.end(); pi++) {

   397

            m.getConfig(&config, *pi); // FIXME use sorted list

   398

            list.push_back(config);

   399

        }

   400

    } else { // alias given

   401

        ConfigAliasParser ap(master, m);

   402

        NumberListParser::List aliasList = ap.parse(aliases.c_str());

   403

        NumberListParser::List::const_iterator ai;

   404

   405

        for (ai = aliasList.begin(); ai != aliasList.end(); ai++) {

   406

   407

            // gather configs with that alias

   408

            map<uint16_t, ec_ioctl_config_t> aliasConfigs;

   409

   410

            int maxPos = -1;

   411

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

   412

                m.getConfig(&config, i);

   413

                if (config.alias == *ai) {

   414

                    aliasConfigs[config.position] = config;

   415

                    if (config.position > maxPos) {

   416

                        maxPos = config.position;

   417

                    }

   418

                }

   419

            }

   420

   421

            PositionParser pp(maxPos + 1);

   422

            NumberListParser::List posList = pp.parse(positions.c_str());

   423

            NumberListParser::List::const_iterator pi;

   424

   425

            for (pi = posList.begin(); pi != posList.end(); pi++) {

   426

                map<uint16_t, ec_ioctl_config_t>::const_iterator ci;

   427

                ci = aliasConfigs.find(*pi);

   428

   429

                if (ci != aliasConfigs.end()) {

   430

                    list.push_back(ci->second);

   431

                } else { 

   432

                    stringstream err;

   433

                    err << "Warning: Config " << *ai << ":" << *pi

   434

                        << " does not exist on master " << m.getIndex();

   435

                    throwCommandException(err);

   436

                }

   437

            }

   438

        }

   439

    }

   440

   441

    list.sort();

   442

    return list;

   443

}

   444

   445

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

   446

   447

Command::DomainList Command::selectedDomains(MasterDevice &m)

   448

{

   449

    ec_ioctl_master_t master;

   450

    DomainList list;

   451

   452

    m.getMaster(&master);

   453

   454

    PositionParser pp(master.domain_count);

   455

    NumberListParser::List domList = pp.parse(domains.c_str());

   456

    NumberListParser::List::const_iterator di;

   457

   458

    for (di = domList.begin(); di != domList.end(); di++) {

   459

        ec_ioctl_domain_t d;

   460

        m.getDomain(&d, *di);

   461

        list.push_back(d);

   462

    }

   463

   464

    return list;

   465

}

   466

   467

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

   468

   469

string Command::alStateString(uint8_t state)

   470

{

   471

    string ret;

   472

   473

    switch (state & EC_SLAVE_STATE_MASK) {

   474

        case 1: ret = "INIT"; break;

   475

        case 2: ret = "PREOP"; break;

   476

        case 3: ret = "BOOT"; break;

   477

        case 4: ret = "SAFEOP"; break;

   478

        case 8: ret = "OP"; break;

   479

        default: ret = "???";

   480

    }

   481

   482

    if (state & EC_SLAVE_STATE_ACK_ERR) { 

   483

        ret += "+ERROR";

   484

    }

   485

   486

    return ret;

   487

}

   488

   489

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