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

typedef map<uint16_t, ec_ioctl_config_t> AliasMap;

    42

typedef map<uint16_t, AliasMap> ConfigMap;

    43

    44

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

    45

    46

class MasterIndexParser:

    47

    public NumberListParser

    48

{

    49

    protected:

    50

        int getMax() {

    51

            MasterDevice dev;

    52

            dev.setIndex(0U);

    53

            dev.open(MasterDevice::Read);

    54

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

    55

        };

    56

};

    57

    58

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

    59

    60

class SlaveAliasParser:

    61

    public NumberListParser

    62

{

    63

    public:

    64

        SlaveAliasParser(ec_ioctl_master_t &master, MasterDevice &dev):

    65

            master(master), dev(dev) {}

    66

    67

    protected:

    68

        int getMax() {

    69

            unsigned int i;

    70

    71

            uint16_t maxAlias = 0;

    72

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

    73

                ec_ioctl_slave_t slave;

    74

                dev.getSlave(&slave, i);

    75

                if (slave.alias > maxAlias) {

    76

                    maxAlias = slave.alias;

    77

                }

    78

            }

    79

            return maxAlias ? maxAlias : -1;

    80

        };

    81

    82

    private:

    83

        ec_ioctl_master_t &master;

    84

        MasterDevice &dev;

    85

};

    86

    87

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

    88

    89

class ConfigAliasParser:

    90

    public NumberListParser

    91

{

    92

    public:

    93

        ConfigAliasParser(unsigned int maxAlias):

    94

            maxAlias(maxAlias) {}

    95

    96

    protected:

    97

        int getMax() { return maxAlias; };

    98

    99

    private:

   100

        unsigned int maxAlias;

   101

};

   102

   103

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

   104

   105

class PositionParser:

   106

    public NumberListParser

   107

{

   108

    public:

   109

        PositionParser(unsigned int count):

   110

            count(count) {}

   111

   112

    protected:

   113

        int getMax() {

   114

            return count - 1;

   115

        };

   116

   117

    private:

   118

        const unsigned int count;

   119

};

   120

   121

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

   122

   123

class AliasPositionParser:

   124

    public NumberListParser

   125

{

   126

    public:

   127

        AliasPositionParser(const AliasMap &aliasMap):

   128

            aliasMap(aliasMap) {}

   129

   130

    protected:

   131

        int getMax() {

   132

            AliasMap::const_iterator i;

   133

            int maxPos = -1;

   134

   135

            for (i = aliasMap.begin(); i != aliasMap.end(); i++) {

   136

                if (i->first > maxPos) {

   137

                    maxPos = i->first;

   138

                }

   139

            }

   140

   141

            return maxPos;

   142

        };

   143

   144

    private:

   145

        const AliasMap &aliasMap;

   146

};

   147

   148

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

   149

   150

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

   151

    name(name),

   152

    briefDesc(briefDesc),

   153

    verbosity(Normal)

   154

{

   155

}

   156

   157

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

   158

   159

Command::~Command()

   160

{

   161

}

   162

   163

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

   164

   165

void Command::setMasters(const string &m)

   166

{

   167

    masters = m;

   168

};

   169

   170

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

   171

   172

void Command::setVerbosity(Verbosity v)

   173

{

   174

    verbosity = v;

   175

};

   176

   177

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

   178

   179

void Command::setAliases(const string &a)

   180

{

   181

    aliases = a;

   182

};

   183

   184

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

   185

   186

void Command::setPositions(const string &p)

   187

{

   188

    positions = p;

   189

};

   190

   191

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

   192

   193

void Command::setDomains(const string &d)

   194

{

   195

    domains = d;

   196

};

   197

   198

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

   199

   200

void Command::setDataType(const string &t)

   201

{

   202

    dataType = t;

   203

};

   204

   205

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

   206

   207

void Command::setForce(bool f)

   208

{

   209

    force = f;

   210

};

   211

   212

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

   213

   214

void Command::setOutputFile(const string &f)

   215

{

   216

    outputFile = f;

   217

};

   218

   219

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

   220

   221

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

   222

{

   223

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

   224

}

   225

   226

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

   227

   228

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

   229

{

   230

    unsigned int i;

   231

    size_t pos = 0;

   232

   233

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

   234

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

   235

        if (pos == string::npos)

   236

            return false;

   237

    }

   238

   239

    return true;

   240

}

   241

   242

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

   243

   244

string Command::numericInfo()

   245

{

   246

    stringstream str;

   247

   248

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

   249

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

   250

        << endl;

   251

   252

    return str.str();

   253

}

   254

   255

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

   256

   257

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

   258

{

   259

    throw InvalidUsageException(s);

   260

}

   261

   262

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

   263

   264

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

   265

{

   266

    throw CommandException(msg);

   267

}

   268

   269

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

   270

   271

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

   272

{

   273

    throw CommandException(s);

   274

}

   275

   276

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

   277

   278

void Command::throwSingleSlaveRequired(unsigned int size) const

   279

{

   280

    stringstream err;

   281

   282

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

   283

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

   284

   285

    throwInvalidUsageException(err);

   286

}

   287

   288

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

   289

   290

Command::MasterIndexList Command::getMasterIndices() const

   291

{

   292

    MasterIndexList indices;

   293

   294

    try {

   295

        MasterIndexParser p;

   296

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

   297

    } catch (MasterDeviceException &e) {

   298

        stringstream err;

   299

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

   300

        throwCommandException(err);

   301

    } catch (runtime_error &e) {

   302

        stringstream err;

   303

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

   304

        throwInvalidUsageException(err);

   305

    }

   306

   307

    return indices;

   308

}

   309

   310

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

   311

   312

unsigned int Command::getSingleMasterIndex() const

   313

{

   314

    MasterIndexList masterIndices = getMasterIndices();

   315

   316

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

   317

        stringstream err;

   318

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

   319

        throwInvalidUsageException(err);

   320

    }

   321

   322

    return masterIndices.front();

   323

}

   324

   325

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

   326

   327

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

   328

{

   329

    ec_ioctl_master_t master;

   330

    unsigned int i;

   331

    ec_ioctl_slave_t slave;

   332

    SlaveList list;

   333

   334

    m.getMaster(&master);

   335

   336

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

   337

        PositionParser pp(master.slave_count);

   338

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

   339

        NumberListParser::List::const_iterator pi;

   340

   341

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

   342

            if (*pi < master.slave_count) {

   343

                m.getSlave(&slave, *pi);

   344

                list.push_back(slave);

   345

            }

   346

        }

   347

    } else { // aliases given

   348

        SlaveAliasParser ap(master, m);

   349

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

   350

        NumberListParser::List::const_iterator ai;

   351

   352

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

   353

   354

            // gather slaves with that alias (and following)

   355

            uint16_t lastAlias = 0;

   356

            vector<ec_ioctl_slave_t> aliasSlaves;

   357

   358

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

   359

                m.getSlave(&slave, i);

   360

                if (slave.alias) {

   361

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

   362

                        // ignore multiple ocurrences of the same alias to

   363

                        // assure consistency for the position argument

   364

                        break;

   365

                    }

   366

                    lastAlias = slave.alias;

   367

                }

   368

                if (lastAlias == *ai) {

   369

                    aliasSlaves.push_back(slave);

   370

                }

   371

            }

   372

   373

            PositionParser pp(aliasSlaves.size());

   374

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

   375

            NumberListParser::List::const_iterator pi;

   376

   377

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

   378

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

   379

                    list.push_back(aliasSlaves[*pi]);

   380

                }

   381

            }

   382

        }

   383

    }

   384

   385

    return list;

   386

}

   387

   388

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

   389

   390

bool operator<(

   391

        const ec_ioctl_config_t &a,

   392

        const ec_ioctl_config_t &b

   393

        )

   394

{

   395

    return a.alias < b.alias

   396

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

   397

}

   398

   399

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

   400

   401

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

   402

{

   403

    unsigned int i;

   404

    ec_ioctl_master_t master;

   405

    ec_ioctl_config_t config;

   406

    ConfigList list;

   407

    stringstream err;

   408

   409

    m.getMaster(&master);

   410

   411

    if (aliases == "-" && positions == "-") { // shortcut

   412

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

   413

            m.getConfig(&config, i);

   414

            list.push_back(config);

   415

        }

   416

    } else { // take the long way home...

   417

        ConfigMap configs;

   418

        uint16_t maxAlias = 0;

   419

   420

        // fill cascaded map structure with all configs

   421

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

   422

            m.getConfig(&config, i);

   423

            AliasMap &aliasMap = configs[config.alias];

   424

            aliasMap[config.position] = config;

   425

            if (config.alias > maxAlias) {

   426

                maxAlias = config.alias;

   427

            }

   428

        }

   429

   430

        ConfigAliasParser ap(maxAlias);

   431

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

   432

        NumberListParser::List::const_iterator ai;

   433

   434

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

   435

   436

            ConfigMap::iterator ci = configs.find(*ai);

   437

            if (ci == configs.end()) {

   438

                continue;

   439

            }

   440

   441

            AliasMap &aliasMap = configs[*ai];

   442

            AliasPositionParser pp(aliasMap);

   443

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

   444

            NumberListParser::List::const_iterator pi;

   445

   446

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

   447

                AliasMap::const_iterator ci;

   448

   449

                ci = aliasMap.find(*pi);

   450

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

   451

                    list.push_back(ci->second);

   452

                }

   453

            }

   454

        }

   455

    }

   456

   457

    list.sort();

   458

    return list;

   459

}

   460

   461

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

   462

   463

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

   464

{

   465

    ec_ioctl_master_t master;

   466

    DomainList list;

   467

   468

    m.getMaster(&master);

   469

   470

    PositionParser pp(master.domain_count);

   471

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

   472

    NumberListParser::List::const_iterator di;

   473

   474

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

   475

        if (*di < master.domain_count) {

   476

            ec_ioctl_domain_t d;

   477

            m.getDomain(&d, *di);

   478

            list.push_back(d);

   479

        }

   480

    }

   481

   482

    return list;

   483

}

   484

   485

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

   486

   487

string Command::alStateString(uint8_t state)

   488

{

   489

    string ret;

   490

   491

    switch (state & EC_SLAVE_STATE_MASK) {

   492

        case 1: ret = "INIT"; break;

   493

        case 2: ret = "PREOP"; break;