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 <getopt.h>

    31

#include <libgen.h> // basename()

    32

#include <stdlib.h>

    33

    34

#include <iostream>

    35

#include <iomanip>

    36

using namespace std;

    37

    38

#include "CommandAlias.h"

    39

#include "CommandConfig.h"

    40

#include "CommandCStruct.h"

    41

#include "CommandData.h"

    42

#include "CommandDebug.h"

    43

#include "CommandDomains.h"

    44

#include "CommandDownload.h"

    45

#ifdef EC_EOE

    46

# include "CommandEoe.h"

    47

#endif

    48

#include "CommandFoeRead.h"

    49

#include "CommandFoeWrite.h"

    50

#include "CommandGraph.h"

    51

#include "CommandMaster.h"

    52

#include "CommandPdos.h"

    53

#include "CommandRegRead.h"

    54

#include "CommandRegWrite.h"

    55

#include "CommandSdos.h"

    56

#include "CommandSiiRead.h"

    57

#include "CommandSiiWrite.h"

    58

#include "CommandSlaves.h"

    59

#include "CommandSoeRead.h"

    60

#include "CommandSoeWrite.h"

    61

#include "CommandStates.h"

    62

#include "CommandUpload.h"

    63

#include "CommandVersion.h"

    64

#include "CommandXml.h"

    65

    66

#include "NumberListParser.h"

    67

#include "MasterDevice.h"

    68

    69

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

    70

    71

typedef list<Command *> CommandList;

    72

CommandList commandList;

    73

    74

string binaryBaseName;

    75

string commandName;

    76

Command::StringVector commandArgs;

    77

    78

// option variables

    79

list<unsigned int> masterIndices;

    80

string masterIndexList = "-"; // all masters

    81

int slavePosition = -1;

    82

int slaveAlias = -1;

    83

int domainIndex = -1;

    84

string dataTypeStr;

    85

Command::Verbosity verbosity = Command::Normal;

    86

bool force = false;

    87

bool helpRequested = false;

    88

string outputFile;

    89

    90

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

    91

    92

string usage()

    93

{

    94

    stringstream str;

    95

    CommandList::const_iterator ci;

    96

    size_t maxWidth = 0;

    97

    98

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

    99

        if ((*ci)->getName().length() > maxWidth) {

   100

            maxWidth = (*ci)->getName().length();

   101

        }

   102

    }

   103

   104

    str << "Usage: " << binaryBaseName << " <COMMAND> [OPTIONS] [ARGUMENTS]"

   105

        << endl << endl

   106

        << "Commands (can be abbreviated):" << endl;

   107

   108

    str << left;

   109

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

   110

        str << "  " << setw(maxWidth) << (*ci)->getName()

   111

            << "  " << (*ci)->getBriefDescription() << endl;

   112

    }

   113

   114

    str << endl

   115

        << "Global options:" << endl

   116

        << "  --master  -m <master>  Index of the master to use. Default: 0."

   117

        << endl

   118

        << "  --force   -f           Force a command." << endl

   119

        << "  --quiet   -q           Output less information." << endl

   120

        << "  --verbose -v           Output more information." << endl

   121

        << "  --help    -h           Show this help." << endl

   122

        << endl

   123

        << Command::numericInfo()

   124

        << endl

   125

        << "Call '" << binaryBaseName

   126

        << " <COMMAND> --help' for command-specific help." << endl

   127

        << endl

   128

        << "Send bug reports to " << PACKAGE_BUGREPORT << "." << endl;

   129

   130

    return str.str();

   131

}

   132

   133

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

   134

   135

class MasterIndexParser:

   136

    public NumberListParser

   137

{

   138

    unsigned int getMax()

   139

    {

   140

        MasterDevice dev;

   141

        dev.setIndex(0U);

   142

        dev.open(MasterDevice::Read);

   143

        return dev.getMasterCount() - 1;

   144

    };

   145

};

   146

   147

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

   148

   149

void getOptions(int argc, char **argv)

   150

{

   151

    int c, argCount;

   152

    stringstream str;

   153

   154

    static struct option longOptions[] = {

   155

        //name,         has_arg,           flag, val

   156

        {"master",      required_argument, NULL, 'm'},

   157

        {"alias",       required_argument, NULL, 'a'},

   158

        {"position",    required_argument, NULL, 'p'},

   159

        {"domain",      required_argument, NULL, 'd'},

   160

        {"type",        required_argument, NULL, 't'},

   161

        {"output-file", required_argument, NULL, 'o'},

   162

        {"force",       no_argument,       NULL, 'f'},

   163

        {"quiet",       no_argument,       NULL, 'q'},

   164

        {"verbose",     no_argument,       NULL, 'v'},

   165

        {"help",        no_argument,       NULL, 'h'},

   166

        {}

   167

    };

   168

   169

    do {

   170

        c = getopt_long(argc, argv, "m:a:p:d:t:o:fqvh", longOptions, NULL);

   171

   172

        switch (c) {

   173

            case 'm':

   174

                masterIndexList = optarg;

   175

                break;

   176

   177

            case 'a':

   178

                str.clear();

   179

                str.str("");

   180

                str << optarg;

   181

                str >> resetiosflags(ios::basefield) // guess base from prefix

   182

                    >> slaveAlias;

   183

                if (str.fail() || slaveAlias < 0 || slaveAlias > 0xFFFF) {

   184

                    cerr << "Invalid slave alias " << optarg << "!" << endl

   185

                        << endl << usage();

   186

                    exit(1);

   187

                }

   188

                break;

   189

   190

            case 'p':

   191

                str.clear();

   192

                str.str("");

   193

                str << optarg;

   194

                str >> resetiosflags(ios::basefield) // guess base from prefix

   195

                    >> slavePosition;

   196

                if (str.fail()

   197

                        || slavePosition < 0 || slavePosition > 0xFFFF) {

   198

                    cerr << "Invalid slave position " << optarg << "!" << endl

   199

                        << endl << usage();

   200

                    exit(1);

   201

                }

   202

                break;

   203

   204

            case 'd':

   205

                str.clear();

   206

                str.str("");

   207

                str << optarg;

   208

                str >> resetiosflags(ios::basefield) // guess base from prefix

   209

                    >> domainIndex;

   210

                if (str.fail() || domainIndex < 0) {

   211

                    cerr << "Invalid domain index " << optarg << "!" << endl

   212

                        << endl << usage();

   213

                    exit(1);

   214

                }

   215

                break;

   216

   217

            case 't':

   218

                dataTypeStr = optarg;

   219

                break;

   220

   221

            case 'o':

   222

                outputFile = optarg;

   223

                break;

   224

   225

            case 'f':

   226

                force = true;

   227

                break;

   228

   229

            case 'q':

   230

                verbosity = Command::Quiet;

   231

                break;

   232

   233

            case 'v':

   234

                verbosity = Command::Verbose;

   235

                break;

   236

   237

            case 'h':

   238

                helpRequested = true;

   239

                break;

   240

   241

            case '?':

   242

                cerr << endl << usage();

   243

                exit(1);

   244

   245

            default:

   246

                break;

   247

        }

   248

    }

   249

    while (c != -1);

   250

   251

    argCount = argc - optind;

   252

   253

    if (!argCount) {

   254

        if (helpRequested) {

   255

            cout << usage();

   256

            exit(0);

   257

        } else {

   258

            cerr << "Please specify a command!" << endl

   259

                << endl << usage();

   260

            exit(1);

   261

        }

   262

    }

   263

   264

    try {

   265

        MasterIndexParser p;

   266

        masterIndices = p.parse(masterIndexList.c_str());

   267

    } catch (MasterDeviceException &e) {

   268

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

   269

        exit(1);

   270

    } catch (runtime_error &e) {

   271

        cerr << "Invalid master argument " << masterIndexList

   272

            << ": " << e.what() << endl

   273

            << endl << usage();

   274

        exit(1);

   275

    }

   276

   277

    commandName = argv[optind];

   278

    while (++optind < argc)

   279

        commandArgs.push_back(string(argv[optind]));

   280

}

   281

   282

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

   283

   284

list<Command *> getMatchingCommands(const string &cmdStr)

   285

{

   286

    CommandList::iterator ci;

   287

    list<Command *> res;

   288

   289

    // find matching commands from beginning of the string

   290

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

   291

        if ((*ci)->matchesSubstr(cmdStr)) {

   292

            res.push_back(*ci);

   293

        }

   294

    }

   295

   296

    if (!res.size()) { // nothing found

   297

        // find /any/ matching commands

   298

        for (ci = commandList.begin(); ci != commandList.end(); ci++) {

   299

            if ((*ci)->matchesAbbrev(cmdStr)) {

   300

                res.push_back(*ci);

   301

            }

   302

        }

   303

    }

   304

   305

    return res;

   306

}

   307

   308

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

   309

   310

int main(int argc, char **argv)

   311

{

   312

    int retval = 0;

   313

    list<Command *> matchingCommands;

   314

    list<Command *>::const_iterator ci;

   315

    Command *cmd;

   316

   317

    binaryBaseName = basename(argv[0]);

   318

   319

    commandList.push_back(new CommandAlias());

   320

    commandList.push_back(new CommandConfig());

   321

    commandList.push_back(new CommandCStruct());

   322

    commandList.push_back(new CommandData());

   323

    commandList.push_back(new CommandDebug());

   324

    commandList.push_back(new CommandDomains());

   325

    commandList.push_back(new CommandDownload());

   326

#ifdef EC_EOE

   327

    commandList.push_back(new CommandEoe());

   328

#endif

   329

    commandList.push_back(new CommandFoeRead());

   330

    commandList.push_back(new CommandFoeWrite());

   331

    commandList.push_back(new CommandGraph());

   332

    commandList.push_back(new CommandMaster());

   333

    commandList.push_back(new CommandPdos());

   334

    commandList.push_back(new CommandRegRead());

   335

    commandList.push_back(new CommandRegWrite());

   336

    commandList.push_back(new CommandSdos());

   337

    commandList.push_back(new CommandSiiRead());

   338

    commandList.push_back(new CommandSiiWrite());

   339

    commandList.push_back(new CommandSlaves());

   340

    commandList.push_back(new CommandSoeRead());

   341

    commandList.push_back(new CommandSoeWrite());

   342

    commandList.push_back(new CommandStates());

   343

    commandList.push_back(new CommandUpload());

   344

    commandList.push_back(new CommandVersion());

   345

    commandList.push_back(new CommandXml());

   346

   347

    getOptions(argc, argv);

   348

   349

    matchingCommands = getMatchingCommands(commandName);

   350

   351

    if (masterIndices.empty()) {

   352

        cerr << "List of master indices may not be empty!" << endl

   353

            << endl << usage();

   354

        exit(1);

   355

    }

   356

   357

    if (matchingCommands.size()) {

   358

        if (matchingCommands.size() == 1) {

   359

            cmd = matchingCommands.front();

   360

            if (!helpRequested) {

   361

                try {

   362

                    cmd->setMasterIndices(masterIndices);

   363

                    cmd->setVerbosity(verbosity);

   364

                    cmd->setAlias(slaveAlias);

   365

                    cmd->setPosition(slavePosition);

   366

                    cmd->setDomain(domainIndex);

   367

                    cmd->setDataType(dataTypeStr);

   368

                    cmd->setOutputFile(outputFile);

   369

                    cmd->setForce(force);

   370

                    cmd->execute(commandArgs);

   371

                } catch (InvalidUsageException &e) {

   372

                    cerr << e.what() << endl << endl;

   373

                    cerr << binaryBaseName << " " << cmd->helpString();

   374

                    retval = 1;

   375

                } catch (CommandException &e) {

   376

                    cerr << e.what() << endl;

   377

                    retval = 1;

   378

                } catch (MasterDeviceException &e) {

   379

                    cerr << e.what() << endl;

   380

                    retval = 1;

   381

                }

   382

            } else {

   383

                cout << binaryBaseName << " " << cmd->helpString();

   384

            }

   385

        } else {

   386

            cerr << "Ambiguous command abbreviation! Matching:" << endl;

   387

            for (ci = matchingCommands.begin();

   388

                    ci != matchingCommands.end();

   389

                    ci++) {

   390

                cerr << (*ci)->getName() << endl;

   391

            }

   392

            cerr << endl << usage();

   393

            retval = 1;

   394

        }

   395

    } else {

   396

        cerr << "Unknown command " << commandName << "!" << endl

   397

            << endl << usage();

   398

        retval = 1;

   399

    }

   400

   401

    return retval;

   402

}

   403

   404

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