1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <iostream>

     8

#include <iomanip>

     9

using namespace std;

    10

    11

#include "CommandUpload.h"

    12

#include "coe_datatypes.h"

    13

#include "byteorder.h"

    14

    15

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

    16

    17

CommandUpload::CommandUpload():

    18

    Command("upload", "Read an Sdo entry from a slave.")

    19

{

    20

}

    21

    22

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

    23

    24

string CommandUpload::helpString() const

    25

{

    26

    stringstream str;

    27

    28

    str << getName() << " [OPTIONS] <INDEX> <SUBINDEX>" << endl

    29

        << endl

    30

        << getBriefDescription() << endl

    31

        << endl

    32

        << "The data type of the Sdo entry is taken from the Sdo" << endl

    33

        << "dictionary by default. It can be overridden with the" << endl

    34

        << "--type option. If the slave does not support the Sdo" << endl

    35

        << "information service or the Sdo is not in the dictionary," << endl

    36

        << "the --type option is mandatory."  << endl

    37

        << endl

    38

        << "These are the valid Sdo entry data types:" << endl

    39

        << "  int8, int16, int32, uint8, uint16, uint32, string." << endl

    40

        << endl

    41

        << "Arguments:" << endl

    42

        << "  INDEX    is the Sdo index and must be an unsigned" << endl

    43

        << "           16 bit number." << endl

    44

        << "  SUBINDEX is the Sdo entry subindex and must be an" << endl

    45

        << "           unsigned 8 bit number." << endl

    46

        << endl

    47

        << "Command-specific options:" << endl

    48

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

    49

        << "                      (mandatory)." << endl

    50

        << "  --type  -t <type>   Sdo entry data type (see above)." << endl

    51

        << endl

    52

        << numericInfo();

    53

    54

    return str.str();

    55

}

    56

    57

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

    58

    59

void CommandUpload::execute(MasterDevice &m, const StringVector &args)

    60

{

    62

    stringstream err, strIndex, strSubIndex;

    63

    int sval;

    64

    ec_ioctl_slave_sdo_upload_t data;

    65

    unsigned int uval;

    66

    const CoEDataType *dataType = NULL;

    67

    68

    if (args.size() != 2) {

    69

        err << "'" << getName() << "' takes two arguments!";

    70

        throwInvalidUsageException(err);

    71

    }

    72

    73

    strIndex << args[0];

    74

    strIndex

    75

        >> resetiosflags(ios::basefield) // guess base from prefix

    76

        >> data.sdo_index;

    77

    if (strIndex.fail()) {

    78

        err << "Invalid Sdo index '" << args[0] << "'!";

    79

        throwInvalidUsageException(err);

    80

    }

    81

    82

    strSubIndex << args[1];

    83

    strSubIndex

    84

        >> resetiosflags(ios::basefield) // guess base from prefix

    85

        >> uval;

    86

    if (strSubIndex.fail() || uval > 0xff) {

    87

        err << "Invalid Sdo subindex '" << args[1] << "'!";

    88

        throwInvalidUsageException(err);

    89

    }

    90

    data.sdo_entry_subindex = uval;

    91

   100

    if (dataTypeStr != "") { // data type specified

   101

        if (!(dataType = findDataType(dataTypeStr))) {

   102

            err << "Invalid data type '" << dataTypeStr << "'!";

   103

            throwInvalidUsageException(err);

   104

        }

   105

    } else { // no data type specified: fetch from dictionary

   106

        ec_ioctl_slave_sdo_entry_t entry;

   107

   108

        try {

   110

                    data.sdo_index, data.sdo_entry_subindex);

   111

        } catch (MasterDeviceException &e) {

   112

            err << "Failed to determine Sdo entry data type. "

   113

                << "Please specify --type.";

   114

            throwCommandException(err);

   115

        }

   116

        if (!(dataType = findDataType(entry.data_type))) {

   117

            err << "Pdo entry has unknown data type 0x"

   118

                << hex << setfill('0') << setw(4) << entry.data_type << "!"

   119

                << " Please specify --type.";

   120

            throwCommandException(err);

   121

        }

   122

    }

   123

   124

    if (dataType->byteSize) {

   125

        data.target_size = dataType->byteSize;

   126

    } else {

   127

        data.target_size = DefaultBufferSize;

   128

    }

   129

   130

    data.target = new uint8_t[data.target_size + 1];

   131

   132

	try {

   133

		m.sdoUpload(&data);

   134

	} catch (MasterDeviceException &e) {

   135

        delete [] data.target;

   136

        throw e;

   137

    }

   138

   139

    m.close();

   140

   141

    if (dataType->byteSize && data.data_size != dataType->byteSize) {

   142

        err << "Data type mismatch. Expected " << dataType->name

   143

            << " with " << dataType->byteSize << " byte, but got "

   144

            << data.data_size << " byte.";

   145

        throwCommandException(err);

   146

    }

   147

   148

    cout << setfill('0');

   149

    switch (dataType->coeCode) {

   150

        case 0x0002: // int8

   151

            sval = *(int8_t *) data.target;

   152

            cout << sval << " 0x" << hex << setw(2) << sval << endl;

   153

            break;

   154

        case 0x0003: // int16

   155

            sval = le16tocpu(*(int16_t *) data.target);

   156

            cout << sval << " 0x" << hex << setw(4) << sval << endl;

   157

            break;

   158

        case 0x0004: // int32

   159

            sval = le32tocpu(*(int32_t *) data.target);

   160

            cout << sval << " 0x" << hex << setw(8) << sval << endl;

   161

            break;

   162

        case 0x0005: // uint8

   163

            uval = (unsigned int) *(uint8_t *) data.target;

   164

            cout << uval << " 0x" << hex << setw(2) << uval << endl;

   165

            break;

   166

        case 0x0006: // uint16

   167

            uval = le16tocpu(*(uint16_t *) data.target);

   168

            cout << uval << " 0x" << hex << setw(4) << uval << endl;

   169

            break;

   170

        case 0x0007: // uint32

   171

            uval = le32tocpu(*(uint32_t *) data.target);

   172

            cout << uval << " 0x" << hex << setw(8) << uval << endl;

   173

            break;

   174

        case 0x0009: // string

   175

            cout << string((const char *) data.target, data.data_size)

   176

                << endl;

   177

            break;

   178

        default:

   179

            printRawData(data.target, data.data_size); // FIXME

   180

            break;

   181

    }

   182

   183

    delete [] data.target;

   184

}

   185

   186

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

   187

   188

void CommandUpload::printRawData(

   189

		const uint8_t *data,

   190

		unsigned int size

   191

		)

   192

{

   193

    cout << hex << setfill('0');

   194

    while (size--) {

   195

        cout << "0x" << setw(2) << (unsigned int) *data++;

   196

        if (size)

   197

            cout << " ";

   198

    }

   199

    cout << endl;

   200

}

   201

   202

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