1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <getopt.h>

     8

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

     9

    10

#include <iostream>

    11

#include <iomanip>

    12

#include <string>

    13

#include <vector>

    14

#include <list>

    15

using namespace std;

    16

    17

#include "globals.h"

    18

    19

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

    20

    21

string binaryBaseName;

    22

unsigned int masterIndex = 0;

    23

int slavePosition = -1;

    24

int domainIndex = -1;

    25

string commandName;

    26

vector<string> commandArgs;

    27

Verbosity verbosity = Normal;

    28

string dataTypeStr;

    29

bool force = false;

    30

    31

bool helpRequested = false;

    32

    33

MasterDevice masterDev;

    34

    35

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

    36

    37

struct Command {

    38

    const char *name;

    39

    void (*func)(void);

    40

    const char *helpString;

    41

    const char *briefDesc;

    42

    43

    int execute(void) const;

    44

    void displayHelp(void) const;

    45

};

    46

    47

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

    48

    49

#define DEFINE_EXTERN_COMMAND(name) \

    50

    void command_##name(void); \

    51

    extern const char *help_##name

    52

    53

#define INIT_COMMAND(name, desc) \

    54

    {#name, command_##name, help_##name, desc}

    55

    56

DEFINE_EXTERN_COMMAND(alias);

    57

DEFINE_EXTERN_COMMAND(config);

    58

DEFINE_EXTERN_COMMAND(data);

    59

DEFINE_EXTERN_COMMAND(debug);

    60

DEFINE_EXTERN_COMMAND(domains);

    61

DEFINE_EXTERN_COMMAND(master);

    62

DEFINE_EXTERN_COMMAND(pdos);

    63

DEFINE_EXTERN_COMMAND(sdos);

    64

DEFINE_EXTERN_COMMAND(download);

    65

DEFINE_EXTERN_COMMAND(upload);

    66

DEFINE_EXTERN_COMMAND(slaves);

    67

DEFINE_EXTERN_COMMAND(sii_read);

    68

DEFINE_EXTERN_COMMAND(sii_write);

    69

DEFINE_EXTERN_COMMAND(states);

    70

DEFINE_EXTERN_COMMAND(xml);

    71

    72

static const Command commands[] = {

    73

    INIT_COMMAND(alias, "Write alias addresses."),

    74

    INIT_COMMAND(config, "Show bus configuration."),

    75

    INIT_COMMAND(data, "Output binary domain process data."),

    76

    INIT_COMMAND(debug, "Set the master's debug level."),

    77

    INIT_COMMAND(domains, "Show domain information."),

    78

    INIT_COMMAND(master, "Show master information."),

    79

    INIT_COMMAND(pdos, "List Pdo assignment/mapping."),

    80

    INIT_COMMAND(sdos, "List Sdo dictionaries."),

    81

    INIT_COMMAND(download, "Write an Sdo entry."),

    82

    INIT_COMMAND(upload, "Read an Sdo entry."),

    83

    INIT_COMMAND(slaves, "Show slaves."),

    84

    INIT_COMMAND(sii_read, "Output a slave's SII contents."),

    85

    INIT_COMMAND(sii_write, "Write slave's SII contents."),

    86

    INIT_COMMAND(states, "Request slave states."),

    87

    INIT_COMMAND(xml, "Generate slave information XML."),

    88

};

    89

    90

static const Command *cmdEnd = commands + sizeof(commands) / sizeof(Command);

    91

    92

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

    93

    94

void printUsage()

    95

{

    96

    const Command *cmd;

    97

    size_t maxWidth = 0;

    98

    99

    for (cmd = commands; cmd < cmdEnd; cmd++) {

   100

        if (strlen(cmd->name) > maxWidth) {

   101

            maxWidth = strlen(cmd->name);

   102

        }

   103

    }

   104

   105

    cerr

   106

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

   107

        << endl << endl

   108

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

   109

   110

    cerr << left;

   111

    for (cmd = commands; cmd < cmdEnd; cmd++) {

   112

        cerr << "  " << setw(maxWidth) << cmd->name

   113

            << " " << cmd->briefDesc << endl;

   114

    }

   115

   116

    cerr

   117

        << endl

   118

		<< "Global options:" << endl

   119

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

   120

		<< endl

   121

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

   122

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

   123

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

   124

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

   125

        << endl

   126

        << "Numerical values can be specified either with decimal "

   127

        << "(no prefix)," << endl

   128

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

   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

   136

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

   137

   138

void getOptions(int argc, char **argv)

   139

{

   140

    int c, argCount, optionIndex, number;

   141

	char *remainder;

   142

   143

    static struct option longOptions[] = {

   144

        //name,     has_arg,           flag, val

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

        {}

   154

    };

   155

   156

    do {

   157

        c = getopt_long(argc, argv, "m:s:d:t:fqvh", longOptions, &optionIndex);

   158

   159

        switch (c) {

   160

            case 'm':

   161

                number = strtoul(optarg, &remainder, 0);

   162

                if (remainder == optarg || *remainder || number < 0) {

   163

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

   164

                    printUsage();

   165

                    exit(1);

   166

                }

   167

				masterIndex = number;

   168

                break;

   169

   170

            case 's':

   171

                if (!strcmp(optarg, "all")) {

   172

                    slavePosition = -1;

   173

                } else {

   174

                    number = strtoul(optarg, &remainder, 0);

   175

                    if (remainder == optarg || *remainder

   176

                            || number < 0 || number > 0xFFFF) {

   177

                        cerr << "Invalid slave position "

   178

                            << optarg << "!" << endl;

   179

                        printUsage();

   180

                        exit(1);

   181

                    }

   182

                    slavePosition = number;

   183

                }

   184

                break;

   185

   186

            case 'd':

   187

                if (!strcmp(optarg, "all")) {

   188

                    domainIndex = -1;

   189

                } else {

   190

                    number = strtoul(optarg, &remainder, 0);

   191

                    if (remainder == optarg || *remainder || number < 0) {

   192

                        cerr << "Invalid domain index "

   193

							<< optarg << "!" << endl;

   194

                        printUsage();

   195

                        exit(1);

   196

                    }

   197

                    domainIndex = number;

   198

                }

   199

                break;

   200

   201

            case 't':

   202

                dataTypeStr = optarg;

   203

                break;

   204

   205

            case 'f':

   206

                force = true;

   207

                break;

   208

   209

            case 'q':

   210

                verbosity = Quiet;

   211

                break;

   212

   213

            case 'v':

   214

                verbosity = Verbose;

   215

                break;

   216

   217

            case 'h':

   218

                helpRequested = true;

   219

                break;

   220

   221

            case '?':

   222

                printUsage();

   223

                exit(1);

   224

   225

            default:

   226

                break;

   227

        }

   228

    }

   229

    while (c != -1);

   230

   231

	argCount = argc - optind;

   232

   233

    if (!argCount) {

   234

        if (!helpRequested) {

   235

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

   236

        }

   237

        printUsage();

   238

        exit(!helpRequested);

   239

	}

   240

   241

    commandName = argv[optind];

   242

    while (++optind < argc)

   243

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

   244

}

   245

   246

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

   247

   248

int Command::execute() const

   249

{

   250

    try {

   251

        func();

   252

    } catch (InvalidUsageException &e) {

   253

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

   254

        displayHelp();

   255

        return 1;

   256

    } catch (CommandException &e) {

   257

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

   258

        return 1;

   259

    } catch (MasterDeviceException &e) {

   260

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

   261

        return 1;

   262

    }

   263

   264

    return 0;

   265

}

   266

   267

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

   268

   269

void Command::displayHelp() const

   270

{

   271

    cerr << binaryBaseName << " " << commandName << " " << helpString;

   272

}

   273

   274

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

   275

   276

bool substrMatch(const string &abb, const string &full)

   277

{

   278

    return full.substr(0, abb.length()) == abb;

   279

}

   280

   281

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

   282

   283

bool abbrevMatch(const string &abb, const string &full)

   284

{

   285

    unsigned int abbIndex;

   286

    size_t fullPos = 0;

   287

   288

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

   289

        fullPos = full.find(abb[abbIndex], fullPos);

   290

        if (fullPos == string::npos)

   291

            return false;

   292

    }

   293

   294

    return true;

   295

}

   296

   297

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

   298

   299

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

   300

{

   301

    const Command *cmd;

   302

    list<const Command *> res;

   303

   304

    // find matching commands from beginning of the string

   305

    for (cmd = commands; cmd < cmdEnd; cmd++) {

   306

        if (substrMatch(cmdStr, cmd->name)) {

   307

            res.push_back(cmd);

   308

        }

   309

    }

   310

   311

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

   312

        // find /any/ matching commands

   313

        for (cmd = commands; cmd < cmdEnd; cmd++) {

   314

            if (abbrevMatch(cmdStr, cmd->name)) {

   315

                res.push_back(cmd);

   316

            }

   317

        }

   318

    }

   319

   320

    return res;

   321

}

   322

   323

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

   324

   325

int main(int argc, char **argv)

   326

{

   327

    int retval = 0;

   328

    list<const Command *> commands;

   329

    list<const Command *>::const_iterator ci;

   330

    const Command *cmd;

   331

   332

    binaryBaseName = basename(argv[0]);

   333

	getOptions(argc, argv);

   334

   335

    commands = getMatchingCommands(commandName);

   336

   337

    if (commands.size()) {

   338

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

   339

            cmd = commands.front();

   340

            commandName = cmd->name;

   341

            if (!helpRequested) {

   342

                masterDev.setIndex(masterIndex);

   343

                retval = cmd->execute();

   344

            } else {

   345

                cmd->displayHelp();

   346

            }

   347

        } else {

   348

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

   349

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

   350

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

   351

            }

   352

            cerr << endl;

   353

            printUsage();

   354

            retval = 1;

   355

        }

   356

    } else {

   357

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

   358

        printUsage();

   359

        retval = 1;

   360

    }

   361

   362

	return retval;

   363

}

   364

   365

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

   366

   367

void printRawData(

   368

		const uint8_t *data,

   369

		unsigned int size

   370

		)

   371

{

   372

    cout << hex << setfill('0');

   373

    while (size--) {

   374

        cout << "0x" << setw(2) << (unsigned int) *data++;

   375

        if (size)

   376

            cout << " ";

   377

    }

   378

    cout << endl;

   379

}

   380

   381

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