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

string dataTypeStr;

    27

    28

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

    29

    30

void printUsage()

    31

{

    32

    cerr

    33

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

    34

		<< "Commands:" << endl

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

        << "  sdo_download (sd)  Write an Sdo entry." << endl

    43

        << "  sdo_upload (su)    Read an Sdo entry." << endl

    45

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

    46

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

    47

		<< "Global options:" << endl

    48

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

    49

		<< DEFAULT_MASTER << endl

    50

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

    51

        << endl

    52

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

    53

        << endl

    54

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

    55

        << endl

    56

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

    57

        << endl

    58

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

    59

        << "  --quiet   -q           Show less output." << endl

    60

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

    61

}

    62

    63

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

    64

    65

void getOptions(int argc, char **argv)

    66

{

    67

    int c, argCount, optionIndex, number;

    68

	char *remainder;

    69

    70

    static struct option longOptions[] = {

    71

        //name,    has_arg,           flag, val

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

        {}

    79

    };

    80

    81

    do {

    82

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

    83

    84

        switch (c) {

    85

            case 'm':

    86

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

    87

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

    88

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

    89

                    printUsage();

    90

                    exit(1);

    91

                }

    92

				masterIndex = number;

    93

                break;

    94

    95

            case 's':

    96

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

    97

                    slavePosition = -1;

    98

                } else {

    99

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

   100

                    if (remainder == optarg || *remainder

   101

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

   102

                        cerr << "Invalid slave position "

   103

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

   104

                        printUsage();

   105

                        exit(1);

   106

                    }

   107

                    slavePosition = number;

   108

                }

   109

                break;

   110

   111

            case 'd':

   112

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

   113

                    domainIndex = -1;

   114

                } else {

   115

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

   116

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

   117

                        cerr << "Invalid domain index "

   118

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

   119

                        printUsage();

   120

                        exit(1);

   121

                    }

   122

                    domainIndex = number;

   123

                }

   124

                break;

   125

   126

            case 't':

   127

                dataTypeStr = optarg;

   128

                break;

   129

   130

            case 'q':

   131

                quiet = true;

   132

                break;

   133

   134

            case 'h':

   135

            case '?':

   136

                printUsage();

   137

                exit(0);

   138

   139

            default:

   140

                break;

   141

        }

   142

    }

   143

    while (c != -1);

   144

   145

	argCount = argc - optind;

   146

   147

	if (!argCount) {

   148

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

   149

		printUsage();

   150

        exit(1);

   151

	}

   152

   153

    command = argv[optind];

   154

    while (++optind < argc)

   155

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

   156

}

   157

   158

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

   159

   160

int main(int argc, char **argv)

   161

{

   162

    Master master;

   163

   164

	getOptions(argc, argv);

   165

   166

    try {

   167

        master.setIndex(masterIndex);

   168

   169

        if (command == "data") {

   170

            master.outputData(domainIndex);

   171

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

   172

            master.setDebug(commandArgs);

   173

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

   174

            master.showDomains(domainIndex);

   175

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

   176

            master.listSlaves();

   177

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

   178

            master.showMaster();

   179

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

   180

            master.listPdos(slavePosition, quiet);

   181

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

   182

            master.listSdos(slavePosition, quiet);

   183

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

   184

            master.sdoDownload(slavePosition, dataTypeStr, commandArgs);

   185

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

   186

            master.sdoUpload(slavePosition, dataTypeStr, commandArgs);

   189

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

   190

            master.requestStates(slavePosition, commandArgs);

   191

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

   192

            master.generateXml(slavePosition);

   193

        } else {

   194

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

   195

            printUsage();

   196

            exit(1);

   197

        }

   198

    } catch (MasterException &e) {

   199

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

   200

        exit(1);

   201

    }

   202

   203

	return 0;

   204

}

   205

   206

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