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

    35

#include "Command.h"

    36

#include "MasterDevice.h"

    37

#include "NumberListParser.h"

    38

    39

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

    40

    41

class MasterIndexParser:

    42

    public NumberListParser

    43

{

   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

   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;

   310

    ec_ioctl_slave_t slave;

   311

    SlaveList list;

   312

   313

    m.getMaster(&master);

   314

   321

            list.push_back(slave);

   322

        }

   334

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

   335

                m.getSlave(&slave, i);

   336

                if (slave.alias) {

   342

                    lastAlias = slave.alias;

   343

                }

   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

   411

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

   412

                m.getConfig(&config, i);

   436

                }

   437

            }

   438

        }

   439

    }

   440

   441

    list.sort();

   442

    return list;

   443

}

   444

   445

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

   446

   447

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

   448

{

   450

    DomainList list;

   451

   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

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