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

    33

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

    34

    35

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

    36

    name(name),

    37

    briefDesc(briefDesc),

    38

    verbosity(Normal)

    39

{

    40

}

    41

    42

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

    43

    44

Command::~Command()

    45

{

    46

}

    47

    48

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

    49

    50

void Command::setMasterIndices(const MasterIndexList &indices)

    51

{

    52

    masterIndices = indices;

    53

};

    54

    55

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

    56

    57

void Command::setVerbosity(Verbosity v)

    58

{

    59

    verbosity = v;

    60

};

    61

    62

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

    63

    64

void Command::setAlias(int a)

    65

{

    66

    alias = a;

    67

};

    68

    69

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

    70

    71

void Command::setPosition(int p)

    72

{

    73

    position = p;

    74

};

    75

    76

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

    77

    78

void Command::setDomain(int d)

    79

{

    80

    domain = d;

    81

};

    82

    83

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

    84

    85

void Command::setDataType(const string &t)

    86

{

    87

    dataType = t;

    88

};

    89

    90

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

    91

    92

void Command::setForce(bool f)

    93

{

    94

    force = f;

    95

};

    96

    97

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

    98

    99

void Command::setOutputFile(const string &f)

   100

{

   101

    outputFile = f;

   102

};

   103

   104

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

   105

   106

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

   107

{

   108

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

   109

}

   110

   111

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

   112

   113

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

   114

{

   115

    unsigned int i;

   116

    size_t pos = 0;

   117

   118

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

   119

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

   120

        if (pos == string::npos)

   121

            return false;

   122

    }

   123

   124

    return true;

   125

}

   126

   127

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

   128

   129

string Command::numericInfo()

   130

{

   131

    stringstream str;

   132

   133

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

   134

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

   135

        << endl;

   136

   137

    return str.str();

   138

}

   139

   140

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

   141

   142

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

   143

{

   144

    throw InvalidUsageException(s);

   145

}

   146

   147

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

   148

   149

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

   150

{

   151

    throw CommandException(s);

   152

}

   153

   154

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

   155

   156

void Command::throwSingleSlaveRequired(unsigned int size) const

   157

{

   158

    stringstream err;

   159

   160

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

   161

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

   162

   163

    throwInvalidUsageException(err);

   164

}

   165

   166

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

   167

   168

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

   169

{

   170

    ec_ioctl_master_t master;

   171

    unsigned int i, aliasIndex;

   172

    uint16_t lastAlias;

   173

    ec_ioctl_slave_t slave;

   174

    SlaveList list;

   175

   176

    m.getMaster(&master);

   177

   178

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

   179

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

   180

            // all items

   181

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

   182

                m.getSlave(&slave, i);

   183

                list.push_back(slave);

   184

            }

   185

        } else { // no alias, but position given

   186

            // one item by position

   187

            m.getSlave(&slave, position);

   188

            list.push_back(slave);

   189

        }

   190

    } else { // alias given

   191

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

   192

            // take all items with a given alias

   193

            lastAlias = 0;

   194

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

   195

                m.getSlave(&slave, i);

   196

                if (slave.alias) {

   197

                    lastAlias = slave.alias;

   198

                }

   199

                if (lastAlias == (uint16_t) alias) {

   200

                    list.push_back(slave);

   201

                }

   202

            }

   203

        } else { // alias and position given

   204

            lastAlias = 0;

   205

            aliasIndex = 0;

   206

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

   207

                m.getSlave(&slave, i);

   208

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

   209

                    lastAlias = slave.alias;

   210

                    aliasIndex = 0;

   211

                }

   212

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

   213

                    list.push_back(slave);

   214

                }

   215

                aliasIndex++;

   216

            }

   217

        }

   218

    }

   219

   220

    return list;

   221

}

   222

   223

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

   224

   225

bool operator<(

   226

        const ec_ioctl_config_t &a,

   227

        const ec_ioctl_config_t &b

   228

        )

   229

{

   230

    return a.alias < b.alias

   231

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

   232

}

   233

   234

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

   235

   236

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

   237

{

   238

    unsigned int i;

   239

    ec_ioctl_master_t master;

   240

    ec_ioctl_config_t config;

   241

    ConfigList list;

   242

    stringstream err;

   243

   244

    m.getMaster(&master);

   245

   246

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

   247

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

   248

            // all items

   249

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

   250

                m.getConfig(&config, i);

   251

                list.push_back(config);

   252

            }

   253

        } else { // no alias, but position given

   254

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

   255

                m.getConfig(&config, i);

   256

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

   257

                    list.push_back(config);

   258

                    break; // there can be at most one matching

   259

                }

   260

            }

   261

        }

   262

    } else { // alias given

   263

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

   264

            // take all items with a given alias

   265

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

   266

                m.getConfig(&config, i);

   267

                if (config.alias == alias) {

   268

                    list.push_back(config);

   269

                }

   270

            }

   271

        } else { // alias and position given

   272

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

   273

                m.getConfig(&config, i);

   274

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

   275

                    list.push_back(config);

   276

                    break; // there can be at most one matching

   277

                }

   278

            }

   279

        }

   280

    }

   281

   282

    list.sort();

   283

    return list;

   284

}

   285

   286

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

   287

   288

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

   289

{

   290

    ec_ioctl_domain_t d;

   291

    DomainList list;

   292

   293

    if (domain == -1) {

   294

        ec_ioctl_master_t master;

   295

        unsigned int i;

   296

   297

        m.getMaster(&master);

   298

   299

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

   300

            m.getDomain(&d, i);

   301

            list.push_back(d);

   302

        }

   303

    } else {

   304

        m.getDomain(&d, domain);

   305

        list.push_back(d);

   306

    }

   307

   308

    return list;

   309

}

   310

   311

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

   312

   313

string Command::alStateString(uint8_t state)

   314

{

   315

    switch (state) {

   316

        case 1: return "INIT";

   317

        case 2: return "PREOP";

   318

        case 3: return "BOOT";

   319

        case 4: return "SAFEOP";

   320

        case 8: return "OP";

   321

        default: return "???";

   322

    }

   323

}

   324

   325

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