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

void Command::setSkin(const string &s)

   222

{

   223

    skin = s;

   224

};

   225

   226

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

   227

   228

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

   229

{

   230

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

   231

}

   232

   233

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

   234

   235

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

   236

{

   237

    unsigned int i;

   238

    size_t pos = 0;

   239

   240

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

   241

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

   242

        if (pos == string::npos)

   243

            return false;

   244

    }

   245

   246

    return true;

   247

}

   248

   249

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

   250

   251

string Command::numericInfo()

   252

{

   253

    stringstream str;

   254

   255

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

   256

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

   257

        << endl;

   258

   259

    return str.str();

   260

}

   261

   262

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

   263

   264

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

   265

{

   266

    throw InvalidUsageException(s);

   267

}

   268

   269

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

   270

   271

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

   272

{

   273

    throw CommandException(msg);

   274

}

   275

   276

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

   277

   278

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

   279

{

   280

    throw CommandException(s);

   281

}

   282

   283

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

   284

   285

void Command::throwSingleSlaveRequired(unsigned int size) const

   286

{

   287

    stringstream err;

   288

   289

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

   290

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

   291

   292

    throwInvalidUsageException(err);

   293

}

   294

   295

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

   296

   297

Command::MasterIndexList Command::getMasterIndices() const

   298

{

   299

    MasterIndexList indices;

   300

   301

    try {

   302

        MasterIndexParser p;

   303

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

   304

    } catch (MasterDeviceException &e) {

   305

        stringstream err;

   306

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

   307

        throwCommandException(err);

   308

    } catch (runtime_error &e) {

   309

        stringstream err;

   310

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

   311

        throwInvalidUsageException(err);

   312

    }

   313

   314

    return indices;

   315

}

   316

   317

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

   318

   319

unsigned int Command::getSingleMasterIndex() const

   320

{

   321

    MasterIndexList masterIndices = getMasterIndices();

   322

   323

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

   324

        stringstream err;

   325

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

   326

        throwInvalidUsageException(err);

   327

    }

   328

   329

    return masterIndices.front();

   330

}

   331

   332

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

   333

   334

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

   335

{

   336

    ec_ioctl_master_t master;

   337

    unsigned int i;

   338

    ec_ioctl_slave_t slave;

   339

    SlaveList list;

   340

   341

    m.getMaster(&master);

   342

   343

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

   344

        PositionParser pp(master.slave_count);

   345

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

   346

        NumberListParser::List::const_iterator pi;

   347

   348

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

   349

            if (*pi < master.slave_count) {

   350

                m.getSlave(&slave, *pi);

   351

                list.push_back(slave);

   352

            }

   353

        }

   354

    } else { // aliases given

   355

        SlaveAliasParser ap(master, m);

   356

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

   357

        NumberListParser::List::const_iterator ai;

   358

   359

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

   360

   361

            // gather slaves with that alias (and following)

   362

            uint16_t lastAlias = 0;

   363

            vector<ec_ioctl_slave_t> aliasSlaves;

   364

   365

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

   366

                m.getSlave(&slave, i);

   367

                if (slave.alias) {

   368

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

   369

                        // ignore multiple ocurrences of the same alias to

   370

                        // assure consistency for the position argument

   371

                        break;

   372

                    }

   373

                    lastAlias = slave.alias;

   374

                }

   375

                if (lastAlias == *ai) {

   376

                    aliasSlaves.push_back(slave);

   377

                }

   378

            }

   379

   380

            PositionParser pp(aliasSlaves.size());

   381

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

   382

            NumberListParser::List::const_iterator pi;

   383

   384

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

   385

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

   386

                    list.push_back(aliasSlaves[*pi]);

   387

                }

   388

            }

   389

        }

   390

    }

   391

   392

    return list;

   393

}

   394

   395

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

   396

   397

bool operator<(

   398

        const ec_ioctl_config_t &a,

   399

        const ec_ioctl_config_t &b

   400

        )

   401

{

   402

    return a.alias < b.alias

   403

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

   404

}

   405

   406

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

   407

   408

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

   409

{

   410

    unsigned int i;

   411

    ec_ioctl_master_t master;

   412

    ec_ioctl_config_t config;

   413

    ConfigList list;

   414

    stringstream err;

   415

   416

    m.getMaster(&master);

   417

   418

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

   419

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

   420

            m.getConfig(&config, i);

   421

            list.push_back(config);

   422

        }

   423

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

   424

        ConfigMap configs;

   425

        uint16_t maxAlias = 0;

   426

   427

        // fill cascaded map structure with all configs

   428

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

   429

            m.getConfig(&config, i);

   430

            AliasMap &aliasMap = configs[config.alias];

   431

            aliasMap[config.position] = config;

   432

            if (config.alias > maxAlias) {

   433

                maxAlias = config.alias;

   434

            }

   435

        }

   436

   437

        ConfigAliasParser ap(maxAlias);

   438

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

   439

        NumberListParser::List::const_iterator ai;

   440

   441

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

   442

   443

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

   444

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

   445

                continue;

   446

            }

   447

   448

            AliasMap &aliasMap = configs[*ai];

   449

            AliasPositionParser pp(aliasMap);

   450

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

   451

            NumberListParser::List::const_iterator pi;

   452

   453

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

   454

                AliasMap::const_iterator ci;

   455

   456

                ci = aliasMap.find(*pi);

   457

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

   458

                    list.push_back(ci->second);

   459

                }

   460

            }

   461

        }

   462

    }

   463

   464

    list.sort();

   465

    return list;

   466

}

   467

   468

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

   469

   470

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

   471

{

   472

    ec_ioctl_master_t master;

   473

    DomainList list;

   474

   475

    m.getMaster(&master);

   476

   477

    PositionParser pp(master.domain_count);

   478

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

   479

    NumberListParser::List::const_iterator di;

   480

   481

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

   482

        if (*di < master.domain_count) {

   483

            ec_ioctl_domain_t d;

   484

            m.getDomain(&d, *di);

   485

            list.push_back(d);

   486

        }

   487

    }

   488

   489

    return list;

   490

}

   491

   492

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

   493