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

    emergency(false),

   155

    force(false)

   156

{

   157

}

   158

   159

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

   160

   161

Command::~Command()

   162

{

   163

}

   164

   165

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

   166

   167

void Command::setMasters(const string &m)

   168

{

   169

    masters = m;

   170

};

   171

   172

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

   173

   174

void Command::setVerbosity(Verbosity v)

   175

{

   176

    verbosity = v;

   177

};

   178

   179

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

   180

   181

void Command::setAliases(const string &a)

   182

{

   183

    aliases = a;

   184

};

   185

   186

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

   187

   188

void Command::setPositions(const string &p)

   189

{

   190

    positions = p;

   191

};

   192

   193

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

   194

   195

void Command::setDomains(const string &d)

   196

{

   197

    domains = d;

   198

};

   199

   200

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

   201

   202

void Command::setDataType(const string &t)

   203

{

   204

    dataType = t;

   205

};

   206

   207

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

   208

   209

void Command::setEmergency(bool e)

   210

{

   211

    emergency = e;

   212

};

   213

   214

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

   215

   216

void Command::setForce(bool f)

   217

{

   218

    force = f;

   219

};

   220

   221

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

   222

   223

void Command::setOutputFile(const string &f)

   224

{

   225

    outputFile = f;

   226

};

   227

   228

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

   229

   230

void Command::setSkin(const string &s)

   231

{

   232

    skin = s;

   233

};

   234

   235

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

   236

   237

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

   238

{

   239

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

   240

}

   241

   242

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

   243

   244

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

   245

{

   246

    unsigned int i;

   247

    size_t pos = 0;

   248

   249

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

   250

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

   251

        if (pos == string::npos)

   252

            return false;

   253

    }

   254

   255

    return true;

   256

}

   257

   258

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

   259

   260

string Command::numericInfo()

   261

{

   262

    stringstream str;

   263

   264

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

   265

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

   266

        << endl;

   267

   268

    return str.str();

   269

}

   270

   271

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

   272

   273

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

   274

{

   275

    throw InvalidUsageException(s);

   276

}

   277

   278

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

   279

   280

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

   281

{

   282

    throw CommandException(msg);

   283

}

   284

   285

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

   286

   287

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

   288

{

   289

    throw CommandException(s);

   290

}

   291

   292

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

   293

   294

void Command::throwSingleSlaveRequired(unsigned int size) const

   295

{

   296

    stringstream err;

   297

   298

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

   299

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

   300

   301

    throwInvalidUsageException(err);

   302

}

   303

   304

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

   305

   306

Command::MasterIndexList Command::getMasterIndices() const

   307

{

   308

    MasterIndexList indices;

   309

   310

    try {

   311

        MasterIndexParser p;

   312

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

   313

    } catch (MasterDeviceException &e) {

   314

        stringstream err;

   315

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

   316

        throwCommandException(err);

   317

    } catch (runtime_error &e) {

   318

        stringstream err;

   319

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

   320

        throwInvalidUsageException(err);

   321

    }

   322

   323

    return indices;

   324

}

   325

   326

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

   327

   328

unsigned int Command::getSingleMasterIndex() const

   329

{

   330

    MasterIndexList masterIndices = getMasterIndices();

   331

   332

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

   333

        stringstream err;

   334

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

   335

        throwInvalidUsageException(err);

   336

    }

   337

   338

    return masterIndices.front();

   339

}

   340

   341

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

   342

   343

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

   344

{

   345

    ec_ioctl_master_t master;

   346

    unsigned int i;

   347

    ec_ioctl_slave_t slave;

   348

    SlaveList list;

   349

   350

    m.getMaster(&master);

   351

   352

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

   353

        PositionParser pp(master.slave_count);

   354

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

   355

        NumberListParser::List::const_iterator pi;

   356

   357

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

   358

            if (*pi < master.slave_count) {

   359

                m.getSlave(&slave, *pi);

   360

                list.push_back(slave);

   361

            }

   362

        }

   363

    } else { // aliases given

   364

        SlaveAliasParser ap(master, m);

   365

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

   366

        NumberListParser::List::const_iterator ai;

   367

   368

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

   369

   370

            // gather slaves with that alias (and following)

   371

            uint16_t lastAlias = 0;

   372

            vector<ec_ioctl_slave_t> aliasSlaves;

   373

   374

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

   375

                m.getSlave(&slave, i);

   376

                if (slave.alias) {

   377

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

   378

                        // ignore multiple ocurrences of the same alias to

   379

                        // assure consistency for the position argument

   380

                        break;

   381

                    }

   382

                    lastAlias = slave.alias;

   383

                }

   384

                if (lastAlias == *ai) {

   385

                    aliasSlaves.push_back(slave);

   386

                }

   387

            }

   388

   389

            PositionParser pp(aliasSlaves.size());

   390

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

   391

            NumberListParser::List::const_iterator pi;

   392

   393

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

   394

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

   395

                    list.push_back(aliasSlaves[*pi]);

   396

                }

   397

            }

   398

        }

   399

    }

   400

   401

    return list;

   402

}

   403

   404

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

   405

   406

bool operator<(

   407

        const ec_ioctl_config_t &a,

   408

        const ec_ioctl_config_t &b

   409

        )

   410

{

   411

    return a.alias < b.alias

   412

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

   413

}

   414

   415

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

   416

   417

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

   418

{

   419

    unsigned int i;

   420

    ec_ioctl_master_t master;

   421

    ec_ioctl_config_t config;

   422

    ConfigList list;

   423

    stringstream err;

   424

   425

    m.getMaster(&master);

   426

   427

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

   428

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

   429

            m.getConfig(&config, i);

   430

            list.push_back(config);

   431

        }

   432

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

   433

        ConfigMap configs;

   434

        uint16_t maxAlias = 0;

   435

   436

        // fill cascaded map structure with all configs

   437

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

   438

            m.getConfig(&config, i);

   439

            AliasMap &aliasMap = configs[config.alias];

   440

            aliasMap[config.position] = config;

   441

            if (config.alias > maxAlias) {

   442

                maxAlias = config.alias;

   443

            }

   444

        }

   445

   446

        ConfigAliasParser ap(maxAlias);

   447

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

   448

        NumberListParser::List::const_iterator ai;

   449

   450

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

   451

   452

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

   453

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

   454

                continue;

   455

            }

   456

   457

            AliasMap &aliasMap = configs[*ai];

   458

            AliasPositionParser pp(aliasMap);

   459

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

   460

            NumberListParser::List::const_iterator pi;

   461

   462

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

   463

                AliasMap::const_iterator ci;

   464

   465

                ci = aliasMap.find(*pi);

   466

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

   467

                    list.push_back(ci->second);

   468

                }

   469

            }

   470

        }

   471

    }

   472

   473

    list.sort();

   474

    return list;

   475

}

   476

   477

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

   478

   479

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

   480

        const ec_ioctl_master_t &io)

   481

{

   482

    DomainList list;

   483

   484

    PositionParser pp(io.domain_count);

   485

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

   486

    NumberListParser::List::const_iterator di;

   487

   488

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

   489

        if (*di < io.domain_count) {

   490

            ec_ioctl_domain_t d;

   491

            m.getDomain(&d, *di);

   492

            list.push_back(d);

   493

        }