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 "Command.h"

    33

#include "MasterDevice.h"

    34

#include "NumberListParser.h"

    35

    36

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

    37

    38

class MasterIndexParser:

    39

    public NumberListParser

    40

{

    41

    unsigned int getMax()

    42

    {

    43

        MasterDevice dev;

    44

        dev.setIndex(0U);

    45

        dev.open(MasterDevice::Read);

    46

        return dev.getMasterCount() - 1;

    47

    };

    48

};

    49

    50

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

    51

    52

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

    53

    name(name),

    54

    briefDesc(briefDesc),

    55

    verbosity(Normal)

    56

{

    57

}

    58

    59

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

    60

    61

Command::~Command()

    62

{

    63

}

    64

    65

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

    66

    67

void Command::setMasters(const string &m)

    68

{

    69

    masters = m;

    70

};

    71

    72

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

    73

    74

void Command::setVerbosity(Verbosity v)

    75

{

    76

    verbosity = v;

    77

};

    78

    79

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

    80

    81

void Command::setAlias(int a)

    82

{

    83

    alias = a;

    84

};

    85

    86

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

    87

    88

void Command::setPosition(int p)

    89

{

    90

    position = p;

    91

};

    92

    93

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

    94

    95

void Command::setDomain(int d)

    96

{

    97

    domain = d;

    98

};

    99

   100

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

   101

   102

void Command::setDataType(const string &t)

   103

{

   104

    dataType = t;

   105

};

   106

   107

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

   108

   109

void Command::setForce(bool f)

   110

{

   111

    force = f;

   112

};

   113

   114

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

   115

   116

void Command::setOutputFile(const string &f)

   117

{

   118

    outputFile = f;

   119

};

   120

   121

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

   122

   123

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

   124

{

   125

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

   126

}

   127

   128

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

   129

   130

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

   131

{

   132

    unsigned int i;

   133

    size_t pos = 0;

   134

   135

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

   136

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

   137

        if (pos == string::npos)

   138

            return false;

   139

    }

   140

   141

    return true;

   142

}

   143

   144

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

   145

   146

string Command::numericInfo()

   147

{

   148

    stringstream str;

   149

   150

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

   151

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

   152

        << endl;

   153

   154

    return str.str();

   155

}

   156

   157

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

   158

   159

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

   160

{

   161

    throw InvalidUsageException(s);

   162

}

   163

   164

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

   165

   166

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

   167

{

   168

    throw CommandException(msg);

   169

}

   170

   171

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

   172

   173

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

   174

{

   175

    throw CommandException(s);

   176

}

   177

   178

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

   179

   180

void Command::throwSingleSlaveRequired(unsigned int size) const

   181

{

   182

    stringstream err;

   183

   184

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

   185

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

   186

   187

    throwInvalidUsageException(err);

   188

}

   189

   190

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

   191

   192

Command::MasterIndexList Command::getMasterIndices() const

   193

{

   194

    MasterIndexList indices;

   195

   196

    try {

   197

        MasterIndexParser p;

   198

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

   199

    } catch (MasterDeviceException &e) {

   200

        stringstream err;

   201

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

   202

        throwCommandException(err);

   203

    } catch (runtime_error &e) {

   204

        stringstream err;

   205

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

   206

        throwInvalidUsageException(err);

   207

    }

   208

   209

    return indices;

   210

}

   211

   212

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

   213

   214

unsigned int Command::getSingleMasterIndex() const

   215

{

   216

    MasterIndexList masterIndices = getMasterIndices();

   217

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

   218

        stringstream err;

   219

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

   220

        throwInvalidUsageException(err);

   221

    }

   222

    return masterIndices.front();

   223

}

   224

   225

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

   226

   227

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

   228

{

   229

    ec_ioctl_master_t master;

   230

    unsigned int i, aliasIndex;

   231

    uint16_t lastAlias;

   232

    ec_ioctl_slave_t slave;

   233

    SlaveList list;

   234

   235

    m.getMaster(&master);

   236

   237

    if (alias == -1) { // no alias given

   238

        if (position == -1) { // no alias and position given

   239

            // all items

   240

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

   241

                m.getSlave(&slave, i);

   242

                list.push_back(slave);

   243

            }

   244

        } else { // no alias, but position given

   245

            // one item by position

   246

            m.getSlave(&slave, position);

   247

            list.push_back(slave);

   248

        }

   249

    } else { // alias given

   250

        if (position == -1) { // alias, but no position given

   251

            // take all items with a given alias

   252

            lastAlias = 0;

   253

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

   254

                m.getSlave(&slave, i);

   255

                if (slave.alias) {

   256

                    lastAlias = slave.alias;

   257

                }

   258

                if (lastAlias == (uint16_t) alias) {

   259

                    list.push_back(slave);

   260

                }

   261

            }

   262

        } else { // alias and position given

   263

            lastAlias = 0;

   264

            aliasIndex = 0;

   265

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

   266

                m.getSlave(&slave, i);

   267

                if (slave.alias && slave.alias == (uint16_t) alias) {

   268

                    lastAlias = slave.alias;

   269

                    aliasIndex = 0;

   270

                }

   271

                if (lastAlias && aliasIndex == (unsigned int) position) {

   272

                    list.push_back(slave);

   273

                }

   274

                aliasIndex++;

   275

            }

   276

        }

   277

    }

   278

   279

    return list;

   280

}

   281

   282

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

   283

   284

bool operator<(

   285

        const ec_ioctl_config_t &a,

   286

        const ec_ioctl_config_t &b

   287

        )

   288

{

   289

    return a.alias < b.alias

   290

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

   291

}

   292

   293

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

   294

   295

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

   296

{

   297

    unsigned int i;

   298

    ec_ioctl_master_t master;

   299

    ec_ioctl_config_t config;

   300

    ConfigList list;

   301

    stringstream err;

   302

   303

    m.getMaster(&master);

   304

   305

    if (alias == -1) { // no alias given

   306

        if (position == -1) { // no alias and position given

   307

            // all items

   308

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

   309

                m.getConfig(&config, i);

   310

                list.push_back(config);

   311

            }

   312

        } else { // no alias, but position given

   313

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

   314

                m.getConfig(&config, i);

   315

                if (!config.alias && config.position == position) {

   316

                    list.push_back(config);

   317

                    break; // there can be at most one matching

   318

                }

   319

            }

   320

        }

   321

    } else { // alias given

   322

        if (position == -1) { // alias, but no position given

   323

            // take all items with a given alias

   324

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

   325

                m.getConfig(&config, i);

   326

                if (config.alias == alias) {

   327

                    list.push_back(config);

   328

                }

   329

            }

   330

        } else { // alias and position given

   331

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

   332

                m.getConfig(&config, i);

   333

                if (config.alias == alias && config.position == position) {

   334

                    list.push_back(config);

   335

                    break; // there can be at most one matching

   336

                }

   337

            }

   338

        }

   339

    }

   340

   341

    list.sort();

   342

    return list;

   343

}

   344

   345

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

   346

   347

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

   348

{

   349

    ec_ioctl_domain_t d;

   350

    DomainList list;

   351

   352

    if (domain == -1) {

   353

        ec_ioctl_master_t master;

   354

        unsigned int i;

   355

   356

        m.getMaster(&master);

   357

   358

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

   359

            m.getDomain(&d, i);

   360

            list.push_back(d);

   361

        }

   362

    } else {

   363

        m.getDomain(&d, domain);

   364

        list.push_back(d);

   365

    }

   366

   367

    return list;

   368

}

   369

   370

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

   371

   372

string Command::alStateString(uint8_t state)

   373

{

   374

    string ret;

   375

   376

    switch (state & EC_SLAVE_STATE_MASK) {

   377

        case 1: ret = "INIT"; break;

   378

        case 2: ret = "PREOP"; break;

   379

        case 3: ret = "BOOT"; break;

   380

        case 4: ret = "SAFEOP"; break;

   381

        case 8: ret = "OP"; break;

   382

        default: ret = "???";

   383

    }

   384

   385

    if (state & EC_SLAVE_STATE_ACK_ERR) { 

   386

        ret += "+ERROR";

   387

    }

   388

   389

    return ret;

   390

}

   391

   392

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