1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <iostream>

     8

#include <iomanip>

     9

#include <sstream>

    10

using namespace std;

    11

    12

#include "globals.h"

    13

#include "sii_crc.h"

    14

    15

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

    16

    17

const char *help_alias =

    18

    "[OPTIONS] <ALIAS>\n"

    19

    "\n"

    20

    "Write the secondary slave address (alias) for either\n"

    21

    "one or for multiple slaves.\n"

    22

    "\n"

    23

    "Arguments:\n"

    24

    "  ALIAS must be a 16 bit unsigned integer, specified\n"

    25

    "        either in decimal (no prefix), octal (prefix '0')\n"

    26

    "        or hexadecimal (prefix '0x').\n"

    27

    "\n"

    28

    "Command-specific options:\n"

    29

    "  -s <SLAVE>  Write the alias of the slave with the given\n"

    30

    "              ring position. If this option is not\n"

    31

    "              specified, the alias of all slaves is set.\n"

    32

    "              The --force option is required in this\n"

    33

    "              case.\n";

    34

    35

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

    36

    37

void writeSlaveAlias(uint16_t, uint16_t);

    38

    39

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

    40

    41

/** Writes the Secondary slave address (alias) to the slave's SII.

    42

 */

    43

void command_alias(void)

    44

{

    45

    uint16_t alias;

    46

    stringstream err, strAlias;

    47

    int number;

    48

    unsigned int numSlaves, i;

    49

    50

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

    51

        err << "'" << commandName << "' takes exactly one argument!";

    52

        throw InvalidUsageException(err);

    53

    }

    54

    55

    strAlias << commandArgs[0];

    56

    strAlias

    57

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

    58

        >> number;

    59

    if (strAlias.fail() || number < 0x0000 || number > 0xffff) {

    60

        err << "Invalid alias '" << commandArgs[0] << "'!";

    61

        throw InvalidUsageException(err);

    62

    }

    63

    alias = number;

    64

    65

    if (slavePosition == -1) {

    66

        if (!force) {

    67

            err << "This will write the alias addresses of all slaves to "

    68

                << alias << "! Please specify --force to proceed.";

    70

        }

    71

    72

        masterDev.open(MasterDevice::ReadWrite);

    73

        numSlaves = masterDev.slaveCount();

    74

    75

        for (i = 0; i < numSlaves; i++) {

    76

            writeSlaveAlias(i, alias);

    77

        }

    78

    } else {

    79

        masterDev.open(MasterDevice::ReadWrite);

    80

        writeSlaveAlias(slavePosition, alias);

    81

    }

    82

}

    83

    84

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

    85

    86

/** Writes the Secondary slave address (alias) to the slave's SII.

    87

 */

    88

void writeSlaveAlias(

    89

        uint16_t slavePosition,

    90

        uint16_t alias

    91

        )

    92

{

    93

    ec_ioctl_slave_sii_t data;

    94

    ec_ioctl_slave_t slave;

    95

    stringstream err;

    96

    uint8_t crc;

    97

    98

    masterDev.getSlave(&slave, slavePosition);

    99

   100

    if (slave.sii_nwords < 8) {

   101

        err << "Current SII contents are too small to set an alias "

   102

            << "(" << slave.sii_nwords << " words)!";

   104

    }

   105

   106

    // read first 8 SII words

   107

    data.slave_position = slavePosition;

   108

    data.offset = 0;

   109

    data.nwords = 8;

   110

    data.words = new uint16_t[data.nwords];

   111

   112

    try {

   113

        masterDev.readSii(&data);

   114

    } catch (MasterDeviceException &e) {

   115

        delete [] data.words;

   116

        err << "Failed to read SII: " << e.what();

   118

    }

   119

   120

    // write new alias address in word 4

   121

    data.words[4] = cputole16(alias);

   122

   123

    // calculate checksum over words 0 to 6

   124

    crc = calcSiiCrc((const uint8_t *) data.words, 14);

   125

   126

    // write new checksum into first byte of word 7

   127

    *(uint8_t *) (data.words + 7) = crc;

   128

   129

    // write first 8 words with new alias and checksum

   130

    try {

   131

        masterDev.writeSii(&data);

   132

    } catch (MasterDeviceException &e) {

   133

        delete [] data.words;

   134

        err << "Failed to read SII: " << e.what();

   136

    }

   137

   138

    delete [] data.words;

   139

}

   140

   141

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