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

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

    29

    30

#include "Command.h"

    31

#include "MasterDevice.h"

    32

#include "NumberListParser.h"

    33

    34

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

    35

    36

class MasterIndexParser:

    37

    public NumberListParser

    38

{

    39

    unsigned int getMax()

    40

    {

    41

        MasterDevice dev;

    42

        dev.setIndex(0U);

    43

        dev.open(MasterDevice::Read);

    44

        return dev.getMasterCount() - 1;

    45

    };

    46

};

    47

    48

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

    49

    50

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

    51

    name(name),

    52

    briefDesc(briefDesc),

    53

    verbosity(Normal)

    54

{

    55

}

    56

    57

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

    58

    59

Command::~Command()

    60

{

    61

}

    62

    63

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

    64

    65

void Command::setMasters(const string &m)

    66

{

    67

    masters = m;

    68

};

    69

    70

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

    71

    72

void Command::setVerbosity(Verbosity v)

    73

{

    74

    verbosity = v;

    75

};

    76

    77

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

    78

    79

void Command::setAlias(int a)

    80

{

    81

    alias = a;

    82

};

    83

    84

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

    85

    86

void Command::setPosition(int p)

    87

{

    88

    position = p;

    89

};

    90

    91

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

    92

    93

void Command::setDomain(int d)

    94

{

    95

    domain = d;

    96

};

    97

    98

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

    99

   100

void Command::setDataType(const string &t)

   101

{

   102

    dataType = t;

   103

};

   104

   105

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

   106

   107

void Command::setForce(bool f)

   108

{

   109

    force = f;

   110

};

   111

   112

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

   113

   114

void Command::setOutputFile(const string &f)

   115

{

   116

    outputFile = f;

   117

};

   118

   119

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

   120

   121

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

   122

{

   123

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

   124

}

   125

   126

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

   127

   128

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

   129

{

   130

    unsigned int i;

   131

    size_t pos = 0;

   132

   133

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

   134

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

   135

        if (pos == string::npos)

   136

            return false;

   137

    }

   138

   139

    return true;

   140

}

   141

   142

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

   143

   144

string Command::numericInfo()

   145

{

   146

    stringstream str;

   147

   148

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

   149

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

   150

        << endl;

   151

   152

    return str.str();

   153

}

   154

   155

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

   156

   157

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

   158

{

   159

    throw InvalidUsageException(s);

   160

}

   161

   162

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

   163

   164

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

   165

{

   166

    throw CommandException(msg);

   167

}

   168

   169

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

   170

   171

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

   172

{

   173

    throw CommandException(s);

   174

}

   175

   176

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

   177

   178

void Command::throwSingleSlaveRequired(unsigned int size) const

   179

{

   180

    stringstream err;

   181

   182

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

   183

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

   184

   185

    throwInvalidUsageException(err);

   186

}

   187

   188

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

   189

   190

Command::MasterIndexList Command::getMasterIndices() const

   191

{

   192

	MasterIndexList indices;

   193

   194

    try {

   195

        MasterIndexParser p;

   196

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

   197

    } catch (MasterDeviceException &e) {

   198

		stringstream err;

   199

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

   200

		throwCommandException(err);

   201

    } catch (runtime_error &e) {

   202

		stringstream err;

   203

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

   204

		throwInvalidUsageException(err);

   205

    }

   206

   207

	return indices;

   208

}

   209

   210

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

   211

   212

unsigned int Command::getSingleMasterIndex() const

   213

{

   214

	MasterIndexList masterIndices = getMasterIndices();

   215

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

   216

		stringstream err;

   217

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

   218

        throwInvalidUsageException(err);

   219

    }

   220

	return masterIndices.front();

   221

}

   222

   223

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

   224

   225

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

   226

{

   227

    ec_ioctl_master_t master;

   228

    unsigned int i, aliasIndex;

   229

    uint16_t lastAlias;

   230

    ec_ioctl_slave_t slave;

   231

    SlaveList list;

   232

   233

    m.getMaster(&master);

   234

   235

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

   236

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

   237

            // all items

   238

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

   239

                m.getSlave(&slave, i);

   240

                list.push_back(slave);

   241

            }

   242

        } else { // no alias, but position given

   243

            // one item by position

   244

            m.getSlave(&slave, position);

   245

            list.push_back(slave);

   246

        }

   247

    } else { // alias given

   248

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

   249

            // take all items with a given alias

   250

            lastAlias = 0;

   251

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

   252

                m.getSlave(&slave, i);

   253

                if (slave.alias) {

   254

                    lastAlias = slave.alias;

   255

                }

   256

                if (lastAlias == (uint16_t) alias) {

   257

                    list.push_back(slave);

   258

                }

   259

            }

   260

        } else { // alias and position given

   261

            lastAlias = 0;

   262

            aliasIndex = 0;

   263

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

   264

                m.getSlave(&slave, i);

   265

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

   266

                    lastAlias = slave.alias;

   267

                    aliasIndex = 0;

   268

                }

   269

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

   270

                    list.push_back(slave);

   271

                }

   272

                aliasIndex++;

   273

            }

   274

        }

   275

    }

   276

   277

    return list;

   278

}

   279

   280

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

   281

   282

bool operator<(

   283

        const ec_ioctl_config_t &a,

   284

        const ec_ioctl_config_t &b

   285

        )

   286

{

   287

    return a.alias < b.alias

   288

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

   289

}

   290

   291

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

   292

   293

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

   294

{

   295

    unsigned int i;

   296

    ec_ioctl_master_t master;

   297

    ec_ioctl_config_t config;

   298

    ConfigList list;

   299

    stringstream err;

   300

   301

    m.getMaster(&master);

   302

   303

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

   304

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

   305

            // all items

   306

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

   307

                m.getConfig(&config, i);

   308

                list.push_back(config);

   309

            }

   310

        } else { // no alias, but position given

   311

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

   312

                m.getConfig(&config, i);

   313

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

   314

                    list.push_back(config);

   315

                    break; // there can be at most one matching

   316

                }

   317

            }

   318

        }

   319

    } else { // alias given

   320

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

   321

            // take all items with a given alias

   322

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

   323

                m.getConfig(&config, i);

   324

                if (config.alias == alias) {

   325

                    list.push_back(config);

   326

                }

   327

            }

   328

        } else { // alias and position given

   329

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

   330

                m.getConfig(&config, i);

   331

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

   332

                    list.push_back(config);

   333

                    break; // there can be at most one matching

   334

                }

   335

            }

   336

        }

   337

    }

   338

   339

    list.sort();

   340

    return list;

   341

}

   342

   343

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

   344

   345

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

   346

{

   347

    ec_ioctl_domain_t d;

   348

    DomainList list;

   349

   350

    if (domain == -1) {

   351

        ec_ioctl_master_t master;

   352

        unsigned int i;

   353

   354

        m.getMaster(&master);

   355

   356

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

   357

            m.getDomain(&d, i);

   358

            list.push_back(d);

   359

        }

   360

    } else {

   361

        m.getDomain(&d, domain);

   362

        list.push_back(d);

   363

    }

   364

   365

    return list;

   366

}

   367

   368

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

   369

   370

string Command::alStateString(uint8_t state)

   371

{

   372

    switch (state) {

   373

        case 1: return "INIT";

   374

        case 2: return "PREOP";

   375

        case 3: return "BOOT";

   376

        case 4: return "SAFEOP";

   377

        case 8: return "OP";

   378

        default: return "???";

   379

    }

   380

}

   381

   382

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