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

#define DEFAULT_COMMAND "slaves"

    20

#define DEFAULT_SLAVEPOSITION -1

    21

#define DEFAULT_DOMAININDEX -1

    22

    23

static unsigned int masterIndex = DEFAULT_MASTER;

    24

static int slavePosition = DEFAULT_SLAVEPOSITION;

    25

static int domainIndex = DEFAULT_DOMAININDEX;

    26

static string command = DEFAULT_COMMAND;

    27

vector<string> commandArgs;

    28

    29

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

    30

    31

void printUsage()

    32

{

    33

    cerr

    34

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

    35

		<< "Commands:" << endl

    36

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

    37

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

    38

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

    39

        << "  list (ls, slaves)  List all slaves (former 'lsec')." << endl

    40

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

    41

        << "  pdos               List Pdo mapping of given slaves." << endl

    42

        << "  state              Request slave state(s)." << endl

    43

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

    44

		<< "Global options:" << endl

    45

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

    46

		<< DEFAULT_MASTER << endl

    47

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

    48

        << endl

    49

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

    50

        << endl

    51

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

    52

        << endl

    53

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

    54

        << endl

    55

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

    56

}

    57

    58

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

    59

    60

void getOptions(int argc, char **argv)

    61

{

    62

    int c, argCount, optionIndex, number;

    63

	char *remainder;

    64

    65

    static struct option longOptions[] = {

    66

        //name,    has_arg,           flag, val

    67

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

    68

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

    69

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

    70

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

    71

        {}

    72

    };

    73

    74

    do {

    75

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

    76

    77

        switch (c) {

    78

            case 'm':

    79

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

    80

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

    81

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

    82

                    printUsage();

    83

                    exit(1);

    84

                }

    85

				masterIndex = number;

    86

                break;

    87

    88

            case 's':

    89

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

    90

                    slavePosition = -1;

    91

                } else {

    92

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

    93

                    if (remainder == optarg || *remainder

    94

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

    95

                        cerr << "Invalid slave position "

    96

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

    97

                        printUsage();

    98

                        exit(1);

    99

                    }

   100

                    slavePosition = number;

   101

                }

   102

                break;

   103

   104

            case 'd':

   105

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

   106

                    domainIndex = -1;

   107

                } else {

   108

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

   109

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

   110

                        cerr << "Invalid domain index "

   111

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

   112

                        printUsage();

   113

                        exit(1);

   114

                    }

   115

                    domainIndex = number;

   116

                }

   117

                break;

   118

   119

            case 'h':

   120

            case '?':

   121

                printUsage();

   122

                exit(0);

   123

   124

            default:

   125

                break;

   126

        }

   127

    }

   128

    while (c != -1);

   129

   130

	argCount = argc - optind;

   131

   132

	if (!argCount) {

   133

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

   134

		printUsage();

   135

        exit(1);

   136

	}

   137

   138

    command = argv[optind];

   139

    while (++optind < argc)

   140

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

   141

}

   142

   143

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

   144

   145

int main(int argc, char **argv)

   146

{

   147

    Master master;

   148

   149

	getOptions(argc, argv);

   150

   151

    try {

   152

        master.open(masterIndex);

   153

   154

        if (command == "data") {

   155

            master.outputData(domainIndex);

   156

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

   157

            master.setDebug(commandArgs);

   158

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

   159

            master.showDomains(domainIndex);

   160

		} else if (command == "list" || command == "ls" || command == "slaves") {

   161

            master.listSlaves();

   162

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

   163

            master.showMaster();

   164

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

   165

            master.listPdos(slavePosition);

   166

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

   167

            master.requestStates(slavePosition, commandArgs);

   168

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

   169

            master.generateXml(slavePosition);

   170

        } else {

   171

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

   172

            printUsage();

   173

            exit(1);

   174

        }

   175

    } catch (MasterException &e) {

   176

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

   177

        exit(1);

   178

    }

   179

   180

	return 0;

   181

}

   182

   183

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