1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <getopt.h>

     8

     9

#include <iostream>

    10

#include <string>

    11

#include <vector>

    12

using namespace std;

    13

    14

#include "Master.h"

    15

    16

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

    17

    18

#define DEFAULT_MASTER 0

    19

    20

static unsigned int masterIndex = DEFAULT_MASTER;

    21

static int slavePosition = -1;

    22

static int domainIndex = -1;

    23

static string command;

    24

vector<string> commandArgs;

    25

static bool quiet = false;

    26

static bool verbose = false;

    27

string dataTypeStr;

    28

bool force = false;

    29

    30

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

    31

    32

void printUsage()

    33

{

    34

    cerr

    35

        << "Usage: ethercat <COMMAND> [OPTIONS]" << endl

    36

		<< "Commands:" << endl

    37

        << "  alias         Write alias addresses." << endl

    38

        << "  config        Show bus configuration." << endl

    39

        << "  data          Output binary domain process data." << endl

    40

        << "  debug         Set the master's debug level." << endl

    41

        << "  domain        Show domain information." << endl

    42

        << "  master        Show master information." << endl

    43

        << "  pdos          List Pdo assignment/mapping." << endl

    44

        << "  sdo_download  Write an Sdo entry." << endl

    45

        << "  sdos          List Sdo dictionaries." << endl

    46

        << "  sdo_upload    Read an Sdo entry." << endl

    47

        << "  sii_read      Output a slave's SII contents." << endl

    48

        << "  sii_write     Write slave's SII contents." << endl

    49

        << "  slaves        Show slaves." << endl

    50

        << "  state         Request slave states." << endl

    51

        << "  xml           Generate slave information xmls." << endl

    52

		<< "Global options:" << endl

    53

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

    54

		<< DEFAULT_MASTER << endl

    55

        << "  --slave   -s <index>   Positive numerical ring position,"

    56

        << endl

    57

        << "                         or 'all' for all slaves (default)."

    58

        << endl

    59

        << "  --domain  -d <index>   Positive numerical index,"

    60

        << endl

    61

        << "                         or 'all' for all domains (default)."

    62

        << endl

    63

        << "  --type    -t <type>    Forced Sdo data type." << endl

    64

        << "  --force   -f           Force action." << endl

    65

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

    66

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

    67

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

    68

}

    69

    70

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

    71

    72

void getOptions(int argc, char **argv)

    73

{

    74

    int c, argCount, optionIndex, number;

    75

	char *remainder;

    76

    77

    static struct option longOptions[] = {

    78

        //name,     has_arg,           flag, val

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

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

    86

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

    87

        {}

    88

    };

    89

    90

    do {

    91

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

    92

    93

        switch (c) {

    94

            case 'm':

    95

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

    96

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

    97

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

    98

                    printUsage();

    99

                    exit(1);

   100

                }

   101

				masterIndex = number;

   102

                break;

   103

   104

            case 's':

   105

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

   106

                    slavePosition = -1;

   107

                } else {

   108

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

   109

                    if (remainder == optarg || *remainder

   110

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

   111

                        cerr << "Invalid slave position "

   112

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

   113

                        printUsage();

   114

                        exit(1);

   115

                    }

   116

                    slavePosition = number;

   117

                }

   118

                break;

   119

   120

            case 'd':

   121

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

   122

                    domainIndex = -1;

   123

                } else {

   124

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

   125

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

   126

                        cerr << "Invalid domain index "

   127

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

   128

                        printUsage();

   129

                        exit(1);

   130

                    }

   131

                    domainIndex = number;

   132

                }

   133

                break;

   134

   135

            case 't':

   136

                dataTypeStr = optarg;

   137

                break;

   138

   139

            case 'f':

   140

                force = true;

   141

                break;

   142

   143

            case 'q':

   144

                quiet = true;

   145

                verbose = false;

   146

                break;

   147

   148

            case 'v':

   149

                verbose = true;

   150

                quiet = false;

   151

                break;

   152

   153

            case 'h':

   154

            case '?':

   155

                printUsage();

   156

                exit(0);

   157

   158

            default:

   159

                break;

   160

        }

   161

    }

   162

    while (c != -1);

   163

   164

	argCount = argc - optind;

   165

   166

	if (!argCount) {

   167

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

   168

		printUsage();

   169

        exit(1);

   170

	}

   171

   172

    command = argv[optind];

   173

    while (++optind < argc)

   174

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

   175

}

   176

   177

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

   178

   179

int main(int argc, char **argv)

   180

{

   181

    Master master;

   182

   183

	getOptions(argc, argv);

   184

   185

    try {

   186

        master.setIndex(masterIndex);

   187

   188

        if (command == "alias") {

   189

            master.writeAlias(slavePosition, force, commandArgs);

   190

        } else if (command == "config") {

   191

            master.showConfigs(verbose);

   192

        } else if (command == "data") {

   193

            master.outputData(domainIndex);

   194

        } else if (command == "debug") {

   195

            master.setDebug(commandArgs);

   196

        } else if (command == "domain") {

   197

            master.showDomains(domainIndex);

   198

		} else if (command == "master") {

   199

            master.showMaster();

   200

        } else if (command == "pdos") {

   201

            master.listPdos(slavePosition, quiet);

   202

        } else if (command == "sdos") {

   203

            master.listSdos(slavePosition, quiet);

   204

        } else if (command == "sdo_download" || command == "sd") {

   205

            master.sdoDownload(slavePosition, dataTypeStr, commandArgs);

   206

        } else if (command == "sdo_upload" || command == "su") {

   207

            master.sdoUpload(slavePosition, dataTypeStr, commandArgs);

   208

		} else if (command == "slave" || command == "slaves"

   209

                || command == "list" || command == "ls") {

   210

            master.showSlaves(slavePosition, verbose);

   211

        } else if (command == "sii_read" || command == "sr") {

   212

            master.siiRead(slavePosition);

   213

        } else if (command == "sii_write" || command == "sw") {

   214

            master.siiWrite(slavePosition, force, commandArgs);

   215

        } else if (command == "state") {

   216

            master.requestStates(slavePosition, commandArgs);

   217

        } else if (command == "xml") {

   218

            master.generateXml(slavePosition);

   219

        } else {

   220

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

   221

            printUsage();

   222

            exit(1);

   223

        }

   224

    } catch (MasterException &e) {

   225

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

   226

        exit(1);

   227

    }

   228

   229

	return 0;

   230

}

   231

   232

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