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 string &msg) const

   150

{

   151

    throw CommandException(msg);

   152

}

   153

   154

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

   155

   156

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

   157

{

   158

    throw CommandException(s);

   159

}

   160

   161

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

   162

   163

void Command::throwSingleSlaveRequired(unsigned int size) const

   164

{

   165

    stringstream err;

   166

   167

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

   168

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

   169

   170

    throwInvalidUsageException(err);

   171

}

   172

   173

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

   174

   175

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

   176

{

   177

    ec_ioctl_master_t master;

   178

    unsigned int i, aliasIndex;

   179

    uint16_t lastAlias;

   180

    ec_ioctl_slave_t slave;

   181

    SlaveList list;

   182

   183

    m.getMaster(&master);

   184

   185

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

   186

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

   187

            // all items

   188

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

   189

                m.getSlave(&slave, i);

   190

                list.push_back(slave);

   191

            }

   192

        } else { // no alias, but position given

   193

            // one item by position

   194

            m.getSlave(&slave, position);

   195

            list.push_back(slave);

   196

        }

   197

    } else { // alias given

   198

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

   199

            // take all items with a given alias

   200

            lastAlias = 0;

   201

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

   202

                m.getSlave(&slave, i);

   203

                if (slave.alias) {

   204

                    lastAlias = slave.alias;

   205

                }

   206

                if (lastAlias == (uint16_t) alias) {

   207

                    list.push_back(slave);

   208

                }

   209

            }

   210

        } else { // alias and position given

   211

            lastAlias = 0;

   212

            aliasIndex = 0;

   213

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

   214

                m.getSlave(&slave, i);

   215

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

   216

                    lastAlias = slave.alias;

   217

                    aliasIndex = 0;

   218

                }

   219

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

   220

                    list.push_back(slave);

   221

                }

   222

                aliasIndex++;

   223

            }

   224

        }

   225

    }

   226

   227

    return list;

   228

}

   229

   230

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

   231

   232

bool operator<(

   233

        const ec_ioctl_config_t &a,

   234

        const ec_ioctl_config_t &b

   235

        )

   236

{

   237

    return a.alias < b.alias

   238

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

   239

}

   240

   241

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

   242

   243

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

   244

{

   245

    unsigned int i;

   246

    ec_ioctl_master_t master;

   247

    ec_ioctl_config_t config;

   248

    ConfigList list;

   249

    stringstream err;

   250

   251

    m.getMaster(&master);

   252

   253

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

   254

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

   255

            // all items

   256

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

   257

                m.getConfig(&config, i);

   258

                list.push_back(config);

   259

            }

   260

        } else { // no alias, but position given

   261

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

   262

                m.getConfig(&config, i);

   263

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

   264

                    list.push_back(config);

   265

                    break; // there can be at most one matching

   266

                }

   267

            }

   268

        }

   269

    } else { // alias given

   270

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

   271

            // take all items with a given alias

   272

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

   273

                m.getConfig(&config, i);

   274

                if (config.alias == alias) {

   275

                    list.push_back(config);

   276

                }

   277

            }

   278

        } else { // alias and position given

   279

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

   280

                m.getConfig(&config, i);

   281

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

   282

                    list.push_back(config);

   283

                    break; // there can be at most one matching

   284

                }

   285

            }

   286

        }

   287

    }

   288

   289

    list.sort();

   290

    return list;

   291

}

   292

   293

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

   294

   295

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

   296

{

   297

    ec_ioctl_domain_t d;

   298

    DomainList list;

   299

   300

    if (domain == -1) {

   301

        ec_ioctl_master_t master;

   302

        unsigned int i;

   303

   304

        m.getMaster(&master);

   305

   306

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

   307

            m.getDomain(&d, i);

   308

            list.push_back(d);

   309

        }

   310

    } else {

   311

        m.getDomain(&d, domain);

   312

        list.push_back(d);

   313

    }

   314

   315

    return list;

   316

}

   317

   318

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

   319

   320

string Command::alStateString(uint8_t state)

   321

{

   322

    switch (state) {

   323

        case 1: return "INIT";

   324

        case 2: return "PREOP";

   325

        case 3: return "BOOT";

   326

        case 4: return "SAFEOP";

   327

        case 8: return "OP";

   328

        default: return "???";

   329

    }

   330

}

   331

   332

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