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 "CommandCrc.h"

    41

#include "CommandCStruct.h"

    42

#include "CommandData.h"

    43

#include "CommandDebug.h"

    44

#include "CommandDomains.h"

    45

#include "CommandDownload.h"

    46

#ifdef EC_EOE

    47

# include "CommandEoe.h"

    48

#endif

    49

#include "CommandFoeRead.h"

    50

#include "CommandFoeWrite.h"

    51

#include "CommandGraph.h"

    52

#include "CommandMaster.h"

    53

#include "CommandPdos.h"

    54

#include "CommandRegRead.h"

    55

#include "CommandRegWrite.h"

    56

#include "CommandRescan.h"

    57

#include "CommandSdos.h"

    58

#include "CommandSiiRead.h"

    59

#include "CommandSiiWrite.h"

    60

#include "CommandSlaves.h"

    61

#include "CommandSoeRead.h"

    62

#include "CommandSoeWrite.h"

    63

#include "CommandStates.h"

    64

#include "CommandUpload.h"

    65

#include "CommandVersion.h"

    66

#include "CommandXml.h"

    67

    68

#include "MasterDevice.h"

    69

    70

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

    71

    72

typedef list<Command *> CommandList;

    73

CommandList commandList;

    74

    75

string binaryBaseName;

    76

string commandName;

    77

Command::StringVector commandArgs;

    78

    79

// option variables

    80

string masters = "-"; // all masters

    81

string positions = "-"; // all positions

    82

string aliases = "-"; // all aliases

    83

string domains = "-"; // all domains

    84

string dataTypeStr;

    85

Command::Verbosity verbosity = Command::Normal;

    86

bool force = false;

    87

bool emergency = false;

    88

bool helpRequested = false;

    89

string outputFile;

    90

string skin;

    91

    92

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

    93

    94

string usage()

    95

{

    96

    stringstream str;

    97

    CommandList::const_iterator ci;

    98

    size_t maxWidth = 0;

    99

   100

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

   101

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

   102

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

   103

        }

   104

    }

   105

   106

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

   107

        << endl << endl

   108

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

   109

   110

    str << left;

   111

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

   112

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

   113

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

   114

    }

   115

   116

    str << endl

   117

        << "Global options:" << endl

   118

        << "  --master  -m <master>  Comma separated list of masters" << endl

   119

        << "                         to select, ranges are allowed." << endl

   120

        << "                         Examples: '1,3', '5-7,9', '-3'." << endl

   121

        << "                         Default: '-' (all)."

   122

        << endl

   123

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

   124

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

   125

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

   126

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

   127

        << endl

   128

        << Command::numericInfo()

   129

        << endl

   130

        << "Call '" << binaryBaseName

   131

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

   132

        << endl

   133

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

   134

   135

    return str.str();

   136

}

   137

   138

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

   139

   140

void getOptions(int argc, char **argv)

   141

{

   142

    int c, argCount;

   143

    stringstream str;

   144

   145

    static struct option longOptions[] = {

   146

        //name,         has_arg,           flag, val

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

        {"skin",        required_argument, NULL, 's'},

   154

        {"emergency",   no_argument,       NULL, 'e'},

   155

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

   156

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

   157

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

   158

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

   159

        {}

   160

    };

   161

   162

    do {

   163

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

   164

   165

        switch (c) {

   166

            case 'm':

   167

                masters = optarg;

   168

                break;

   169

   170

            case 'a':

   171

                aliases = optarg;

   172

                break;

   173

   174

            case 'p':

   175

                positions = optarg;

   176

                break;

   177

   178

            case 'd':

   179

                domains = optarg;

   180

                break;

   181

   182

            case 't':

   183

                dataTypeStr = optarg;

   184

                break;

   185

   186

            case 'o':

   187

                outputFile = optarg;

   188

                break;

   189

   190

            case 's':

   191

                skin = optarg;

   192

                break;

   193

   194

            case 'e':

   195

                emergency = true;

   196

                break;

   197

   198

            case 'f':

   199

                force = true;

   200

                break;

   201

   202

            case 'q':

   203

                verbosity = Command::Quiet;

   204

                break;

   205

   206

            case 'v':

   207

                verbosity = Command::Verbose;

   208

                break;

   209

   210

            case 'h':

   211

                helpRequested = true;

   212

                break;

   213

   214

            case '?':

   215

                cerr << endl << usage();

   216

                exit(1);

   217

   218

            default:

   219

                break;

   220

        }

   221

    }

   222

    while (c != -1);

   223

   224

    argCount = argc - optind;

   225

   226

    if (!argCount) {

   227

        if (helpRequested) {

   228

            cout << usage();

   229

            exit(0);

   230

        } else {

   231

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

   232

                << endl << usage();

   233

            exit(1);

   234

        }

   235

    }

   236

   237

    commandName = argv[optind];

   238

    while (++optind < argc)

   239

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

   240

}

   241

   242

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

   243

   244

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

   245

{

   246

    CommandList::iterator ci;

   247

    list<Command *> res;

   248

   249

    // find matching commands from beginning of the string

   250

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

   251

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

   252

            res.push_back(*ci);

   253

        }

   254

    }

   255

   256

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

   257

        // find /any/ matching commands

   258

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

   259

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

   260

                res.push_back(*ci);

   261

            }

   262

        }

   263

    }

   264

   265

    return res;

   266

}

   267

   268

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

   269

   270

int main(int argc, char **argv)

   271

{

   272

    int retval = 0;

   273

    list<Command *> matchingCommands;

   274

    list<Command *>::const_iterator ci;

   275

    Command *cmd;

   276

   277

    binaryBaseName = basename(argv[0]);

   278

   279

    commandList.push_back(new CommandAlias());

   280

    commandList.push_back(new CommandConfig());

   281

    commandList.push_back(new CommandCrc());

   282

    commandList.push_back(new CommandCStruct());

   283

    commandList.push_back(new CommandData());

   284

    commandList.push_back(new CommandDebug());

   285

    commandList.push_back(new CommandDomains());

   286

    commandList.push_back(new CommandDownload());

   287

#ifdef EC_EOE

   288

    commandList.push_back(new CommandEoe());

   289

#endif

   290

    commandList.push_back(new CommandFoeRead());

   291

    commandList.push_back(new CommandFoeWrite());

   292

    commandList.push_back(new CommandGraph());

   293

    commandList.push_back(new CommandMaster());

   294

    commandList.push_back(new CommandPdos());

   295

    commandList.push_back(new CommandRegRead());

   296

    commandList.push_back(new CommandRegWrite());

   297

    commandList.push_back(new CommandRescan());

   298

    commandList.push_back(new CommandSdos());

   299

    commandList.push_back(new CommandSiiRead());

   300

    commandList.push_back(new CommandSiiWrite());

   301

    commandList.push_back(new CommandSlaves());

   302

    commandList.push_back(new CommandSoeRead());

   303

    commandList.push_back(new CommandSoeWrite());

   304

    commandList.push_back(new CommandStates());

   305

    commandList.push_back(new CommandUpload());

   306

    commandList.push_back(new CommandVersion());

   307

    commandList.push_back(new CommandXml());

   308

   309

    getOptions(argc, argv);

   310

   311

    matchingCommands = getMatchingCommands(commandName);

   312

   313

    if (matchingCommands.size()) {

   314

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

   315

            cmd = matchingCommands.front();

   316

            if (!helpRequested) {

   317

                try {

   318

                    cmd->setMasters(masters);

   319

                    cmd->setVerbosity(verbosity);

   320

                    cmd->setAliases(aliases);

   321

                    cmd->setPositions(positions);

   322

                    cmd->setDomains(domains);

   323

                    cmd->setDataType(dataTypeStr);

   324

                    cmd->setOutputFile(outputFile);

   325

                    cmd->setSkin(skin);

   326

                    cmd->setEmergency(emergency);

   327

                    cmd->setForce(force);

   328

                    cmd->execute(commandArgs);

   329

                } catch (InvalidUsageException &e) {

   330

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

   331

                    cerr << cmd->helpString(binaryBaseName);

   332

                    retval = 1;

   333

                } catch (CommandException &e) {

   334

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

   335

                    retval = 1;

   336

                } catch (MasterDeviceException &e) {

   337

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

   338

                    retval = 1;

   339

                }

   340

            } else {

   341

                cout << cmd->helpString(binaryBaseName);

   342

            }

   343

        } else {

   344

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

   345

            for (ci = matchingCommands.begin();

   346

                    ci != matchingCommands.end();

   347

                    ci++) {

   348

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

   349

            }

   350

            cerr << endl << usage();

   351

            retval = 1;

   352

        }

   353

    } else {

   354

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

   355

            << endl << usage();

   356

        retval = 1;

   357

    }

   358

   359

    return retval;

   360

}

   361

   362

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