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

    32

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

    33

    34

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

    35

    name(name),

    36

    briefDesc(briefDesc),

    37

    verbosity(Normal)

    38

{

    39

}

    40

    41

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

    42

    43

Command::~Command()

    44

{

    45

}

    46

    47

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

    48

    49

void Command::setVerbosity(Verbosity v)

    50

{

    51

    verbosity = v;

    52

};

    53

    54

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

    55

    56

void Command::setAlias(int a)

    57

{

    58

    alias = a;

    59

};

    60

    61

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

    62

    63

void Command::setPosition(int p)

    64

{

    65

    position = p;

    66

};

    67

    68

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

    69

    70

void Command::setDomain(int d)

    71

{

    72

    domain = d;

    73

};

    74

    75

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

    76

    77

void Command::setDataType(const string &t)

    78

{

    79

    dataType = t;

    80

};

    81

    82

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

    83

    84

void Command::setForce(bool f)

    85

{

    86

    force = f;

    87

};

    88

    89

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

    90

    91

void Command::setOutputFile(const string &f)

    92

{

    93

    outputFile = f;

    94

};

    95

    96

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

    97

    98

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

    99

{

   100

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

   101

}

   102

   103

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

   104

   105

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

   106

{

   107

    unsigned int i;

   108

    size_t pos = 0;

   109

   110

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

   111

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

   112

        if (pos == string::npos)

   113

            return false;

   114

    }

   115

   116

    return true;

   117

}

   118

   119

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

   120

   121

string Command::numericInfo()

   122

{

   123

    stringstream str;

   124

   125

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

   126

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

   127

        << endl;

   128

   129

    return str.str();

   130

}

   131

   132

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

   133

   134

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

   135

{

   136

    throw InvalidUsageException(s);

   137

}

   138

   139

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

   140

   141

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

   142

{

   143

    throw CommandException(s);

   144

}

   145

   146

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

   147

   148

void Command::throwSingleSlaveRequired(unsigned int size) const

   149

{

   150

    stringstream err;

   151

   152

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

   153

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

   154

   155

    throwInvalidUsageException(err);

   156

}

   157

   158

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

   159

   160

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

   161

{

   162

    ec_ioctl_master_t master;

   163

    unsigned int i, aliasIndex;

   164

    uint16_t lastAlias;

   165

    ec_ioctl_slave_t slave;

   166

    SlaveList list;

   167

   168

    m.getMaster(&master);

   169

   170

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

   171

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

   172

            // all items

   173

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

   174

                m.getSlave(&slave, i);

   175

                list.push_back(slave);

   176

            }

   177

        } else { // no alias, but position given

   178

            // one item by position

   179

            m.getSlave(&slave, position);

   180

            list.push_back(slave);

   181

        }

   182

    } else { // alias given

   183

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

   184

            // take all items with a given alias

   185

            lastAlias = 0;

   186

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

   187

                m.getSlave(&slave, i);

   188

                if (slave.alias) {

   189

                    lastAlias = slave.alias;

   190

                }

   191

                if (lastAlias == (uint16_t) alias) {

   192

                    list.push_back(slave);

   193

                }

   194

            }

   195

        } else { // alias and position given

   196

            lastAlias = 0;

   197

            aliasIndex = 0;

   198

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

   199

                m.getSlave(&slave, i);

   200

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

   201

                    lastAlias = slave.alias;

   202

                    aliasIndex = 0;

   203

                }

   204

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

   205

                    list.push_back(slave);

   206

                }

   207

                aliasIndex++;

   208

            }

   209

        }

   210

    }

   211

   212

    return list;

   213

}

   214

   215

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

   216

   217

bool operator<(

   218

        const ec_ioctl_config_t &a,

   219

        const ec_ioctl_config_t &b

   220

        )

   221

{

   222

    return a.alias < b.alias

   223

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

   224

}

   225

   226

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

   227

   228

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

   229

{

   230

    unsigned int i;

   231

    ec_ioctl_master_t master;

   232

    ec_ioctl_config_t config;

   233

    ConfigList list;

   234

    stringstream err;

   235

   236

    m.getMaster(&master);

   237

   238

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

   239

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

   240

            // all items

   241

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

   242

                m.getConfig(&config, i);

   243

                list.push_back(config);

   244

            }

   245

        } else { // no alias, but position given

   246

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

   247

                m.getConfig(&config, i);

   248

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

   249

                    list.push_back(config);

   250

                    break; // there can be at most one matching

   251

                }

   252

            }

   253

        }

   254

    } else { // alias given

   255

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

   256

            // take all items with a given alias

   257

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

   258

                m.getConfig(&config, i);

   259

                if (config.alias == alias) {

   260

                    list.push_back(config);

   261

                }

   262

            }

   263

        } else { // alias and position given

   264

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

   265

                m.getConfig(&config, i);

   266

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

   267

                    list.push_back(config);

   268

                    break; // there can be at most one matching

   269

                }

   270

            }

   271

        }

   272

    }

   273

   274

    list.sort();

   275

    return list;

   276

}

   277

   278

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

   279

   280

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

   281

{

   282

    ec_ioctl_domain_t d;

   283

    DomainList list;

   284

   285

    if (domain == -1) {

   286

        ec_ioctl_master_t master;

   287

        unsigned int i;

   288

   289

        m.getMaster(&master);

   290

   291

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

   292

            m.getDomain(&d, i);

   293

            list.push_back(d);

   294

        }

   295

    } else {

   296

        m.getDomain(&d, domain);

   297

        list.push_back(d);

   298

    }

   299

   300

    return list;

   301

}

   302

   303

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

   304

   305

string Command::alStateString(uint8_t state)

   306

{

   307

    switch (state) {

   308

        case 1: return "INIT";

   309

        case 2: return "PREOP";

   310

        case 3: return "BOOT";

   311

        case 4: return "SAFEOP";

   312

        case 8: return "OP";

   313

        default: return "???";

   314

    }

   315

}

   316

   317

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