1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <iostream>

     8

#include <iomanip>

     9

using namespace std;

    10

    11

#include "globals.h"

    12

#include "coe_datatypes.h"

    13

    14

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

    15

    16

// FIXME

    17

const char *help_upload =

    18

    "[OPTIONS]\n"

    19

    "\n"

    20

    "\n"

    21

    "Command-specific options:\n";

    22

    23

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

    24

    25

void command_upload(void)

    26

{

    28

    int sval;

    29

    ec_ioctl_slave_sdo_upload_t data;

    30

    unsigned int uval;

    31

    const CoEDataType *dataType = NULL;

    32

    33

    if (slavePosition < 0) {

    37

    }

    38

    data.slave_position = slavePosition;

    39

    40

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

    43

    }

    44

    45

    strIndex << commandArgs[0];

    46

    strIndex

    47

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

    48

        >> data.sdo_index;

    49

    if (strIndex.fail()) {

    50

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

    52

    }

    53

    54

    strSubIndex << commandArgs[1];

    55

    strSubIndex

    56

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

    57

        >> uval;

    58

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

    59

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

    61

    }

    62

    data.sdo_entry_subindex = uval;

    63

    64

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

    65

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

    66

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

    68

        }

    69

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

    70

        ec_ioctl_slave_sdo_entry_t entry;

    71

    72

        masterDev.open(MasterDevice::Read);

    73

    74

        try {

    75

            masterDev.getSdoEntry(&entry, slavePosition,

    76

                    data.sdo_index, data.sdo_entry_subindex);

    77

        } catch (MasterDeviceException &e) {

    78

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

    79

                << "Please specify --type.";

    81

        }

    82

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

    83

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

    84

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

    85

                << " Please specify --type.";

    87

        }

    88

    }

    89

    90

    if (dataType->byteSize) {

    91

        data.target_size = dataType->byteSize;

    92

    } else {

    93

        data.target_size = DefaultBufferSize;

    94

    }

    95

    96

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

    97

    98

    masterDev.open(MasterDevice::Read);

    99

   100

	try {

   101

		masterDev.sdoUpload(&data);

   102

	} catch (MasterDeviceException &e) {

   103

        delete [] data.target;

   104

        throw e;

   105

    }

   106

   107

    masterDev.close();

   108

   109

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

   110

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

   111

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

   112

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

   114

    }

   115

   116

    cout << setfill('0');

   117

    switch (dataType->coeCode) {

   118

        case 0x0002: // int8

   119

            sval = *(int8_t *) data.target;

   120

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

   121

            break;

   122

        case 0x0003: // int16

   123

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

   124

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

   125

            break;

   126

        case 0x0004: // int32

   127

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

   128

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

   129

            break;

   130

        case 0x0005: // uint8

   131

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

   132

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

   133

            break;

   134

        case 0x0006: // uint16

   135

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

   136

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

   137

            break;

   138

        case 0x0007: // uint32

   139

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

   140

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

   141

            break;

   142

        case 0x0009: // string

   143

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

   144

                << endl;

   145

            break;

   146

        default:

   147

            printRawData(data.target, data.data_size);

   148

            break;

   149

    }

   150

   151

    delete [] data.target;

   152

}

   153

   154

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