mirror of
https://gitlab.com/etherlab.org/ethercat.git
synced 2026-02-07 04:11:50 +08:00
381 lines
11 KiB
C++
381 lines
11 KiB
C++
/*****************************************************************************
|
|
*
|
|
* $Id$
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include <getopt.h>
|
|
#include <libgen.h> // basename()
|
|
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <list>
|
|
using namespace std;
|
|
|
|
#include "globals.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
string binaryBaseName;
|
|
unsigned int masterIndex = 0;
|
|
int slavePosition = -1;
|
|
int domainIndex = -1;
|
|
string commandName;
|
|
vector<string> commandArgs;
|
|
Verbosity verbosity = Normal;
|
|
string dataTypeStr;
|
|
bool force = false;
|
|
|
|
bool helpRequested = false;
|
|
|
|
MasterDevice masterDev;
|
|
|
|
/*****************************************************************************/
|
|
|
|
struct Command {
|
|
const char *name;
|
|
void (*func)(void);
|
|
const char *helpString;
|
|
const char *briefDesc;
|
|
|
|
int execute(void) const;
|
|
void displayHelp(void) const;
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define DEFINE_EXTERN_COMMAND(name) \
|
|
void command_##name(void); \
|
|
extern const char *help_##name
|
|
|
|
#define INIT_COMMAND(name, desc) \
|
|
{#name, command_##name, help_##name, desc}
|
|
|
|
DEFINE_EXTERN_COMMAND(alias);
|
|
DEFINE_EXTERN_COMMAND(config);
|
|
DEFINE_EXTERN_COMMAND(data);
|
|
DEFINE_EXTERN_COMMAND(debug);
|
|
DEFINE_EXTERN_COMMAND(domains);
|
|
DEFINE_EXTERN_COMMAND(master);
|
|
DEFINE_EXTERN_COMMAND(pdos);
|
|
DEFINE_EXTERN_COMMAND(sdos);
|
|
DEFINE_EXTERN_COMMAND(sdo_download);
|
|
DEFINE_EXTERN_COMMAND(sdo_upload);
|
|
DEFINE_EXTERN_COMMAND(slaves);
|
|
DEFINE_EXTERN_COMMAND(sii_read);
|
|
DEFINE_EXTERN_COMMAND(sii_write);
|
|
DEFINE_EXTERN_COMMAND(states);
|
|
DEFINE_EXTERN_COMMAND(xml);
|
|
|
|
static const Command commands[] = {
|
|
INIT_COMMAND(alias, "Write alias addresses."),
|
|
INIT_COMMAND(config, "Show bus configuration."),
|
|
INIT_COMMAND(data, "Output binary domain process data."),
|
|
INIT_COMMAND(debug, "Set the master's debug level."),
|
|
INIT_COMMAND(domains, "Show domain information."),
|
|
INIT_COMMAND(master, "Show master information."),
|
|
INIT_COMMAND(pdos, "List Pdo assignment/mapping."),
|
|
INIT_COMMAND(sdos, "List Sdo dictionaries."),
|
|
INIT_COMMAND(sdo_download, "Write an Sdo entry."),
|
|
INIT_COMMAND(sdo_upload, "Read an Sdo entry."),
|
|
INIT_COMMAND(slaves, "Show slaves."),
|
|
INIT_COMMAND(sii_read, "Output a slave's SII contents."),
|
|
INIT_COMMAND(sii_write, "Write slave's SII contents."),
|
|
INIT_COMMAND(states, "Request slave states."),
|
|
INIT_COMMAND(xml, "Generate slave information XML."),
|
|
};
|
|
|
|
static const Command *cmdEnd = commands + sizeof(commands) / sizeof(Command);
|
|
|
|
/*****************************************************************************/
|
|
|
|
void printUsage()
|
|
{
|
|
const Command *cmd;
|
|
size_t maxWidth = 0;
|
|
|
|
for (cmd = commands; cmd < cmdEnd; cmd++) {
|
|
if (strlen(cmd->name) > maxWidth) {
|
|
maxWidth = strlen(cmd->name);
|
|
}
|
|
}
|
|
|
|
cerr
|
|
<< "Usage: " << binaryBaseName << " <COMMAND> [OPTIONS]" << endl
|
|
<< "Commands:" << endl;
|
|
|
|
cerr << left;
|
|
for (cmd = commands; cmd < cmdEnd; cmd++) {
|
|
cerr << " " << setw(maxWidth) << cmd->name
|
|
<< " " << cmd->briefDesc << endl;
|
|
}
|
|
|
|
cerr
|
|
<< "Commands can be generously abbreviated." << endl
|
|
<< "Global options:" << endl
|
|
<< " --master -m <master> Index of the master to use. Default: 0"
|
|
<< endl
|
|
<< " --slave -s <index> Positive numerical ring position,"
|
|
<< endl
|
|
<< " or 'all' for all slaves (default)."
|
|
<< endl
|
|
<< " or 'all' for all domains (default)."
|
|
<< endl
|
|
<< " --type -t <type> Forced Sdo data type." << endl
|
|
<< " --force -f Force action." << endl
|
|
<< " --quiet -q Output less information." << endl
|
|
<< " --verbose -v Output more information." << endl
|
|
<< " --help -h Show this help." << endl
|
|
<< "Call '" << binaryBaseName
|
|
<< " <COMMAND> --help' for command-specific help." << endl
|
|
<< "Send bug reports to " << PACKAGE_BUGREPORT << "." << endl;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
void getOptions(int argc, char **argv)
|
|
{
|
|
int c, argCount, optionIndex, number;
|
|
char *remainder;
|
|
|
|
static struct option longOptions[] = {
|
|
//name, has_arg, flag, val
|
|
{"master", required_argument, NULL, 'm'},
|
|
{"slave", required_argument, NULL, 's'},
|
|
{"domain", required_argument, NULL, 'd'},
|
|
{"type", required_argument, NULL, 't'},
|
|
{"force", no_argument, NULL, 'f'},
|
|
{"quiet", no_argument, NULL, 'q'},
|
|
{"verbose", no_argument, NULL, 'v'},
|
|
{"help", no_argument, NULL, 'h'},
|
|
{}
|
|
};
|
|
|
|
do {
|
|
c = getopt_long(argc, argv, "m:s:d:t:fqvh", longOptions, &optionIndex);
|
|
|
|
switch (c) {
|
|
case 'm':
|
|
number = strtoul(optarg, &remainder, 0);
|
|
if (remainder == optarg || *remainder || number < 0) {
|
|
cerr << "Invalid master number " << optarg << "!" << endl;
|
|
printUsage();
|
|
exit(1);
|
|
}
|
|
masterIndex = number;
|
|
break;
|
|
|
|
case 's':
|
|
if (!strcmp(optarg, "all")) {
|
|
slavePosition = -1;
|
|
} else {
|
|
number = strtoul(optarg, &remainder, 0);
|
|
if (remainder == optarg || *remainder
|
|
|| number < 0 || number > 0xFFFF) {
|
|
cerr << "Invalid slave position "
|
|
<< optarg << "!" << endl;
|
|
printUsage();
|
|
exit(1);
|
|
}
|
|
slavePosition = number;
|
|
}
|
|
break;
|
|
|
|
case 'd':
|
|
if (!strcmp(optarg, "all")) {
|
|
domainIndex = -1;
|
|
} else {
|
|
number = strtoul(optarg, &remainder, 0);
|
|
if (remainder == optarg || *remainder || number < 0) {
|
|
cerr << "Invalid domain index "
|
|
<< optarg << "!" << endl;
|
|
printUsage();
|
|
exit(1);
|
|
}
|
|
domainIndex = number;
|
|
}
|
|
break;
|
|
|
|
case 't':
|
|
dataTypeStr = optarg;
|
|
break;
|
|
|
|
case 'f':
|
|
force = true;
|
|
break;
|
|
|
|
case 'q':
|
|
verbosity = Quiet;
|
|
break;
|
|
|
|
case 'v':
|
|
verbosity = Verbose;
|
|
break;
|
|
|
|
case 'h':
|
|
helpRequested = true;
|
|
break;
|
|
|
|
case '?':
|
|
printUsage();
|
|
exit(1);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
while (c != -1);
|
|
|
|
argCount = argc - optind;
|
|
|
|
if (!argCount) {
|
|
if (!helpRequested) {
|
|
cerr << "Please specify a command!" << endl;
|
|
}
|
|
printUsage();
|
|
exit(!helpRequested);
|
|
}
|
|
|
|
commandName = argv[optind];
|
|
while (++optind < argc)
|
|
commandArgs.push_back(string(argv[optind]));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int Command::execute() const
|
|
{
|
|
try {
|
|
func();
|
|
} catch (InvalidUsageException &e) {
|
|
cerr << e.what() << endl << endl;
|
|
displayHelp();
|
|
return 1;
|
|
} catch (ExecutionFailureException &e) {
|
|
cerr << e.what() << endl;
|
|
return 1;
|
|
} catch (MasterDeviceException &e) {
|
|
cerr << e.what() << endl;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
void Command::displayHelp() const
|
|
{
|
|
cerr << binaryBaseName << " " << commandName << " " << helpString;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
bool substrMatch(const string &abb, const string &full)
|
|
{
|
|
return full.substr(0, abb.length()) == abb;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
bool abbrevMatch(const string &abb, const string &full)
|
|
{
|
|
unsigned int abbIndex;
|
|
size_t fullPos = 0;
|
|
|
|
for (abbIndex = 0; abbIndex < abb.length(); abbIndex++) {
|
|
fullPos = full.find(abb[abbIndex], fullPos);
|
|
if (fullPos == string::npos)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
list<const Command *> getMatchingCommands(const string &cmdStr)
|
|
{
|
|
const Command *cmd;
|
|
list<const Command *> res;
|
|
|
|
// find matching commands from beginning of the string
|
|
for (cmd = commands; cmd < cmdEnd; cmd++) {
|
|
if (substrMatch(cmdStr, cmd->name)) {
|
|
res.push_back(cmd);
|
|
}
|
|
}
|
|
|
|
if (!res.size()) { // nothing found
|
|
// find /any/ matching commands
|
|
for (cmd = commands; cmd < cmdEnd; cmd++) {
|
|
if (abbrevMatch(cmdStr, cmd->name)) {
|
|
res.push_back(cmd);
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int retval = 0;
|
|
list<const Command *> commands;
|
|
list<const Command *>::const_iterator ci;
|
|
const Command *cmd;
|
|
|
|
binaryBaseName = basename(argv[0]);
|
|
getOptions(argc, argv);
|
|
|
|
commands = getMatchingCommands(commandName);
|
|
|
|
if (commands.size()) {
|
|
if (commands.size() == 1) {
|
|
cmd = commands.front();
|
|
if (!helpRequested) {
|
|
masterDev.setIndex(masterIndex);
|
|
retval = cmd->execute();
|
|
} else {
|
|
cmd->displayHelp();
|
|
}
|
|
} else {
|
|
cerr << "Ambiguous command abbreviation! Matching:" << endl;
|
|
for (ci = commands.begin(); ci != commands.end(); ci++) {
|
|
cerr << (*ci)->name << endl;
|
|
}
|
|
cerr << endl;
|
|
printUsage();
|
|
retval = 1;
|
|
}
|
|
} else {
|
|
cerr << "Unknown command " << commandName << "!" << endl << endl;
|
|
printUsage();
|
|
retval = 1;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
void printRawData(
|
|
const uint8_t *data,
|
|
unsigned int size
|
|
)
|
|
{
|
|
cout << hex << setfill('0');
|
|
while (size--) {
|
|
cout << "0x" << setw(2) << (unsigned int) *data++;
|
|
if (size)
|
|
cout << " ";
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
/****************************************************************************/
|