1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <getopt.h>

     8

     9

#include <iostream>

    10

#include <string>

    11

using namespace std;

    12

    13

#include "Master.h"

    14

    15

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

    16

    17

#define DEFAULT_MASTER 0

    18

#define DEFAULT_COMMAND "slaves"

    19

#define DEFAULT_SLAVEPOSITION -1

    20

#define DEFAULT_DOMAININDEX -1

    21

    22

static unsigned int masterIndex = DEFAULT_MASTER;

    23

static int slavePosition = DEFAULT_SLAVEPOSITION;

    24

static int domainIndex = DEFAULT_DOMAININDEX;

    25

static string command = DEFAULT_COMMAND;

    26

    27

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

    28

    29

void printUsage()

    30

{

    31

    cerr

    32

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

    33

		<< "Commands:" << endl

    34

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

    35

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

    36

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

    37

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

    38

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

    39

		<< "Global options:" << endl

    40

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

    42

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

    43

        << endl

    45

        << endl

    46

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

    47

        << endl

    50

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

    51

}

    52

    53

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

    54

    55

void getOptions(int argc, char **argv)

    56

{

    57

    int c, argCount, optionIndex, number;

    58

	char *remainder;

    59

    60

    static struct option longOptions[] = {

    61

        //name,    has_arg,           flag, val

    62

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

    63

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

    64

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

    65

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

    66

        {}

    67

    };

    68

    69

    do {

    70

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

    71

    72

        switch (c) {

    73

            case 'm':

    74

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

    75

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

    76

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

    77

                    printUsage();

    78

                    exit(1);

    79

                }

    80

				masterIndex = number;

    81

                break;

    82

    83

            case 's':

    84

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

    85

                    slavePosition = -1;

    86

                } else {

    87

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

    88

                    if (remainder == optarg || *remainder

    89

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

    90

                        cerr << "Invalid slave position "

    91

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

    92

                        printUsage();

    93

                        exit(1);

    94

                    }

    95

                    slavePosition = number;

    96

                }

    97

                break;

    98

    99

            case 'd':

   100

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

   101

                    domainIndex = -1;

   102

                } else {

   103

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

   104

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

   105

                        cerr << "Invalid domain index "

   106

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

   107

                        printUsage();

   108

                        exit(1);

   109

                    }

   110

                    domainIndex = number;

   111

                }

   112

                break;

   113

   114

            case 'h':

   115

            case '?':

   116

                printUsage();

   117

                exit(0);

   118

   119

            default:

   120

                break;

   121

        }

   122

    }

   123

    while (c != -1);

   124

   125

	argCount = argc - optind;

   126

   127

	if (!argCount) {

   128

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

   129

		printUsage();

   130

        exit(1);

   131

	}

   132

   133

    command = argv[optind];

   134

}

   135

   136

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

   137

   138

int main(int argc, char **argv)

   139

{

   140

    Master master;

   141

   142

	getOptions(argc, argv);

   143

   144

    try {

   145

        master.open(masterIndex);

   146

   147

        if (command == "data") {

   148

            master.outputData(domainIndex);

   149

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

   150

            master.showDomains(domainIndex);

   151

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

   152

            master.listSlaves();

   153

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

   154

            master.listPdos(slavePosition);

   155

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

   156

            master.generateXml(slavePosition);

   157

        } else {

   158

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

   159

            printUsage();

   160

            exit(1);

   161

        }

   162

    } catch (MasterException &e) {

   163

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

   164

        exit(1);

   165

    }

   166

   167

	return 0;

   168

}

   169

   170

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