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

    41

#include "CommandDebug.h"

    42

#include "CommandDomains.h"

    43

#include "CommandDownload.h"

    44

#include "CommandEoe.h"

    45

#include "CommandFoeRead.h"

    46

#include "CommandFoeWrite.h"

    47

#include "CommandGraph.h"

    48

#include "CommandMaster.h"

    49

#include "CommandPdos.h"

    50

#include "CommandRegRead.h"

    51

#include "CommandRegWrite.h"

    52

#include "CommandSdos.h"

    53

#include "CommandSiiRead.h"

    54

#include "CommandSiiWrite.h"

    55

#include "CommandSlaves.h"

    56

#include "CommandStates.h"

    57

#include "CommandUpload.h"

    58

#include "CommandVersion.h"

    59

#include "CommandXml.h"

    60

    61

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

    62

    63

typedef list<Command *> CommandList;

    64

CommandList commandList;

    65

    66

MasterDevice masterDev;

    67

    68

string binaryBaseName;

    69

string commandName;

    70

Command::StringVector commandArgs;

    71

    72

// option variables

    73

unsigned int masterIndex = 0;

    74

int slavePosition = -1;

    75

int slaveAlias = -1;

    76

int domainIndex = -1;

    77

string dataTypeStr;

    78

Command::Verbosity verbosity = Command::Normal;

    79

bool force = false;

    80

bool helpRequested = false;

    81

string outputFile;

    82

    83

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

    84

    85

string usage()

    86

{

    87

    stringstream str;

    88

    CommandList::const_iterator ci;

    89

    size_t maxWidth = 0;

    90

    91

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

    92

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

    93

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

    94

        }

    95

    }

    96

    97

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

    98

        << endl << endl

    99

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

   100

   101

    str << left;

   102

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

   103

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

   104

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

   105

    }

   106

   107

    str << endl

   108

		<< "Global options:" << endl

   109

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

   110

		<< endl

   111

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

   112

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

   113

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

   114

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

   115

        << endl

   116

        << Command::numericInfo()

   117

        << endl

   118

        << "Call '" << binaryBaseName

   119

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

   120

        << endl

   121

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

   122

   123

    return str.str();

   124

}

   125

   126

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

   127

   128

void getOptions(int argc, char **argv)

   129

{

   130

    int c, argCount;

   131

    stringstream str;

   132

   133

    static struct option longOptions[] = {

   134

        //name,         has_arg,           flag, val

   135

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

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

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

   143

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

   144

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

   145

        {}

   146

    };

   147

   148

    do {

   149

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

   150

   151

        switch (c) {

   152

            case 'm':

   153

                str.clear();

   154

                str.str("");

   155

                str << optarg;

   156

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

   157

                    >> masterIndex;

   158

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

   159

                    cerr << "Invalid master number " << optarg << "!" << endl

   160

                        << endl << usage();

   161

                    exit(1);

   162

                }

   163

                break;

   164

   165

            case 'a':

   166

                str.clear();

   167

                str.str("");

   168

                str << optarg;

   169

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

   170

                    >> slaveAlias;

   171

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

   172

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

   173

                        << endl << usage();

   174

                    exit(1);

   175

                }

   176

                break;

   177

   178

            case 'p':

   179

                str.clear();

   180

                str.str("");

   181

                str << optarg;

   182

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

   183

                    >> slavePosition;

   184

                if (str.fail()

   185

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

   186

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

   187

                        << endl << usage();

   188

                    exit(1);

   189

                }

   190

                break;

   191

   192

            case 'd':

   193

                str.clear();

   194

                str.str("");

   195

                str << optarg;

   196

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

   197

                    >> domainIndex;

   198

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

   199

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

   200

                        << endl << usage();

   201

                    exit(1);

   202

                }

   203

                break;

   204

   205

            case 't':

   206

                dataTypeStr = optarg;

   207

                break;

   208

   209

            case 'o':

   210

                outputFile = optarg;

   211

                break;

   212

   213

            case 'f':

   214

                force = true;

   215

                break;

   216

   217

            case 'q':

   218

                verbosity = Command::Quiet;

   219

                break;

   220

   221

            case 'v':

   222

                verbosity = Command::Verbose;

   223

                break;

   224

   225

            case 'h':

   226

                helpRequested = true;

   227

                break;

   228

   229

            case '?':

   230

                cerr << endl << usage();

   231

                exit(1);

   232

   233

            default:

   234

                break;

   235

        }

   236

    }

   237

    while (c != -1);

   238

   239

	argCount = argc - optind;

   240

   241

    if (!argCount) {

   242

        if (helpRequested) {

   243

            cout << usage();

   244

            exit(0);

   245

        } else {

   246

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

   247

                << endl << usage();

   248

            exit(1);

   249

        }

   250

	}

   251

   252

    commandName = argv[optind];

   253

    while (++optind < argc)

   254

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

   255

}

   256

   257

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

   258

   259

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

   260

{

   261

    CommandList::iterator ci;

   262

    list<Command *> res;

   263

   264

    // find matching commands from beginning of the string

   265

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

   266

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

   267

            res.push_back(*ci);

   268

        }

   269

    }

   270

   271

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

   272

        // find /any/ matching commands

   273

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

   274

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

   275

                res.push_back(*ci);

   276

            }

   277

        }

   278

    }

   279

   280

    return res;

   281

}

   282

   283

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

   284

   285

int main(int argc, char **argv)

   286

{

   287

    int retval = 0;

   288

    list<Command *> matchingCommands;

   289

    list<Command *>::const_iterator ci;

   290

    Command *cmd;

   291

   292

    binaryBaseName = basename(argv[0]);

   293

   294

    commandList.push_back(new CommandAlias());

   295

    commandList.push_back(new CommandConfig());

   296

    commandList.push_back(new CommandData());

   297

    commandList.push_back(new CommandDebug());

   298

    commandList.push_back(new CommandDomains());

   299

    commandList.push_back(new CommandDownload());

   300

    commandList.push_back(new CommandEoe());

   301

    commandList.push_back(new CommandFoeRead());

   302

    commandList.push_back(new CommandFoeWrite());

   303

    commandList.push_back(new CommandGraph());

   304

    commandList.push_back(new CommandMaster());

   305

    commandList.push_back(new CommandPdos());

   306

    commandList.push_back(new CommandRegRead());

   307

    commandList.push_back(new CommandRegWrite());

   308

    commandList.push_back(new CommandSdos());

   309

    commandList.push_back(new CommandSiiRead());

   310

    commandList.push_back(new CommandSiiWrite());

   311

    commandList.push_back(new CommandSlaves());

   312

    commandList.push_back(new CommandStates());

   313

    commandList.push_back(new CommandUpload());

   314

    commandList.push_back(new CommandVersion());

   315

    commandList.push_back(new CommandXml());

   316

   317

	getOptions(argc, argv);

   318

   319

    matchingCommands = getMatchingCommands(commandName);

   320

    masterDev.setIndex(masterIndex);

   321

   322

    if (matchingCommands.size()) {

   323

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

   324

            cmd = matchingCommands.front();

   325

            if (!helpRequested) {

   326

                try {

   327

                    cmd->setVerbosity(verbosity);

   328

                    cmd->setAlias(slaveAlias);

   329

                    cmd->setPosition(slavePosition);

   330

                    cmd->setDomain(domainIndex);

   331

                    cmd->setDataType(dataTypeStr);

   332

                    cmd->setOutputFile(outputFile);

   333

                    cmd->setForce(force);

   334

                    cmd->execute(masterDev, commandArgs);

   335

                } catch (InvalidUsageException &e) {

   336

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

   337

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

   338

                    retval = 1;

   339

                } catch (CommandException &e) {

   340

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

   341

                    retval = 1;

   342

                } catch (MasterDeviceException &e) {

   343

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

   344

                    retval = 1;

   345

                }

   346

            } else {

   347

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

   348

            }

   349

        } else {

   350

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

   351

            for (ci = matchingCommands.begin();

   352

                    ci != matchingCommands.end();

   353

                    ci++) {

   354

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

   355

            }

   356

            cerr << endl << usage();

   357

            retval = 1;

   358

        }

   359

    } else {

   360

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

   361

            << endl << usage();

   362

        retval = 1;

   363

    }

   364

   365

	return retval;

   366

}

   367

   368

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