1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <list>

     8

#include <iostream>

     9

#include <iomanip>

    10

#include <sstream>

    11

using namespace std;

    12

    13

#include "CommandConfig.h"

    14

#include "byteorder.h"

    15

    16

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

    17

    18

CommandConfig::CommandConfig():

    19

    Command("config", "Show slave configurations.")

    20

{

    21

}

    22

    23

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

    24

    25

string CommandConfig::helpString() const

    26

{

    27

    stringstream str;

    28

    29

    str << getName() << " [OPTIONS]" << endl

    30

    	<< endl

    31

    	<< getBriefDescription() << endl

    32

    	<< endl

    33

    	<< "Without the --verbose option, slave configurations are" << endl

    34

    	<< "output one-per-line. Example:" << endl

    35

    	<< endl

    36

    	<< "1001:0  0x0000003b/0x02010000  3  OP" << endl

    37

    	<< "|       |                      |  |" << endl

    38

    	<< "|       |                      |  \\- Application-layer" << endl

    39

    	<< "|       |                      |     state of the attached" << endl

    40

    	<< "|       |                      |     slave, or '-', if no" << endl

    41

    	<< "|       |                      |     slave is attached." << endl

    42

    	<< "|       |                      \\- Absolute decimal ring" << endl

    43

    	<< "|       |                         position of the attached" << endl

    44

    	<< "|       |                         slave, or '-' if none" << endl

    45

    	<< "|       |                         attached." << endl

    46

    	<< "|       \\- Expected vendor ID and product code (both" << endl

    47

    	<< "|          hexadecimal)." << endl

    48

    	<< "\\- Alias address and relative position (both decimal)." << endl

    49

    	<< endl

    52

        << endl

    53

        << "Configuration selection:" << endl

    54

        << "  Slave configurations can be selected with" << endl

    55

        << "  the --alias and --position parameters as follows:" << endl

    56

        << endl

    57

        << "  1) If neither the --alias nor the --position option" << endl

    58

        << "     is given, all slave configurations are displayed." << endl

    59

        << "  2) If only the --position option is given, an alias" << endl

    60

        << "     of zero is assumed (see 4))." << endl

    61

        << "  3) If only the --alias option is given, all slave" << endl

    62

        << "     configurations with the given alias address" << endl

    63

        << "     are displayed." << endl

    64

        << "  4) If both the --alias and the --position option are" << endl

    65

        << "     given, the selection can match a single" << endl

    66

        << "     configuration, that is displayed, if it exists." << endl

    67

    	<< endl

    68

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

    69

        << "  --alias    -a <alias>  Configuration alias (see above)." << endl

    70

        << "  --position -p <pos>    Relative position (see above)." << endl

    71

    	<< "  --verbose  -v          Show detailed configurations." << endl

    72

        << endl

    73

        << numericInfo();

    74

    75

	return str.str();

    76

}

    77

    78

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

    79

    80

/** Lists the bus configuration.

    81

 */

    82

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

    83

{

    84

    ConfigList configs;

    85

    86

    m.open(MasterDevice::Read);

    87

    configs = selectedConfigs(m);

    88

    89

    if (getVerbosity() == Verbose) {

    90

        showDetailedConfigs(m, configs);

    91

    } else {

    92

        listConfigs(m, configs);

    93

    }

    94

}

    95

    96

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

    97

    98

/** Lists the complete bus configuration.

    99

 */

   100

void CommandConfig::showDetailedConfigs(

   101

		MasterDevice &m,

   102

		const ConfigList &configList

   103

		)

   104

{

   105

    ConfigList::const_iterator configIter;

   106

    unsigned int j, k, l;

   107

    ec_ioctl_slave_t slave;

   108

    ec_ioctl_config_pdo_t pdo;

   109

    ec_ioctl_config_pdo_entry_t entry;

   110

    ec_ioctl_config_sdo_t sdo;

   111

   112

    for (configIter = configList.begin();

   113

            configIter != configList.end();

   114

            configIter++) {

   115

   116

        cout << "Alias: "

   117

            << dec << configIter->alias << endl

   118

            << "Position: " << configIter->position << endl

   119

            << "Vendor Id: 0x"

   120

            << hex << setfill('0')

   121

            << setw(8) << configIter->vendor_id << endl

   122

            << "Product code: 0x"

   123

            << setw(8) << configIter->product_code << endl

   124

            << "Attached slave: ";

   125

   126

        if (configIter->slave_position != -1) {

   127

            m.getSlave(&slave, configIter->slave_position);

   128

            cout << dec << configIter->slave_position

   129

                << " (" << alStateString(slave.al_state) << ")" << endl;

   130

        } else {

   131

            cout << "none" << endl;

   132

        }

   133

   134

        for (j = 0; j < EC_MAX_SYNC_MANAGERS; j++) {

   135

            if (configIter->syncs[j].pdo_count) {

   136

                cout << "SM" << dec << j << " ("

   137

                    << (configIter->syncs[j].dir == EC_DIR_INPUT

   138

                            ? "Input" : "Output") << ")" << endl;

   139

                for (k = 0; k < configIter->syncs[j].pdo_count; k++) {

   140

                    m.getConfigPdo(&pdo, configIter->config_index, j, k);

   141

   143

   144

                    for (l = 0; l < pdo.entry_count; l++) {

   145

                        m.getConfigPdoEntry(&entry,

   146

                                configIter->config_index, j, k, l);

   147

   149

                            << setw(4) << entry.index << ":"

   150

                            << setw(2) << (unsigned int) entry.subindex

   151

                            << ", " << dec << setfill(' ')

   152

                            << setw(2) << (unsigned int) entry.bit_length

   153

                            << " bit" << endl;

   154

                    }

   155

                }

   156

            }

   157

        }

   158

   160

        if (configIter->sdo_count) {

   161

            for (j = 0; j < configIter->sdo_count; j++) {

   162

                m.getConfigSdo(&sdo, configIter->config_index, j);

   163

   164

                cout << "  0x"

   165

                    << hex << setfill('0')

   166

                    << setw(4) << sdo.index << ":"

   167

                    << setw(2) << (unsigned int) sdo.subindex

   168

                    << ", " << dec << sdo.size << " byte: " << hex;

   169

   170

                switch (sdo.size) {

   171

                    case 1:

   172

                        cout << "0x" << setw(2)

   173

                            << (unsigned int) *(uint8_t *) &sdo.data;

   174

                        break;

   175

                    case 2:

   176

                        cout << "0x" << setw(4)

   177

                            << le16tocpu(*(uint16_t *) &sdo.data);

   178

                        break;

   179

                    case 4:

   180

                        cout << "0x" << setw(8)

   181

                            << le32tocpu(*(uint32_t *) &sdo.data);

   182

                        break;

   183

                    default:

   184

                        cout << "???";

   185

                }

   186

   187

                cout << endl;

   188

            }

   189

        } else {

   190

            cout << "  None." << endl;

   191

        }

   192

   193

        cout << endl;

   194

    }

   195

}

   196

   197

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

   198

   199

/** Lists the bus configuration.

   200

 */

   201

void CommandConfig::listConfigs(

   202

        MasterDevice &m,

   203

        const ConfigList &configList

   204

        )

   205

{

   206

    ConfigList::const_iterator configIter;

   207

    stringstream str;

   208

    Info info;

   209

    typedef list<Info> InfoList;

   210

    InfoList list;

   211

    InfoList::const_iterator iter;

   212

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   213

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   214

    ec_ioctl_slave_t slave;

   215

   216

    for (configIter = configList.begin();

   217

            configIter != configList.end();

   218

            configIter++) {

   219

   220

        str << dec << configIter->alias;

   221

        info.alias = str.str();

   222

        str.clear();

   223

        str.str("");

   224

   225

        str << configIter->position;

   226

        info.pos = str.str();

   227

        str.clear();

   228

        str.str("");

   229

   230

        str << hex << setfill('0')

   231

            << "0x" << setw(8) << configIter->vendor_id

   232

            << "/0x" << setw(8) << configIter->product_code;

   233

        info.ident = str.str();

   234

        str.clear();

   235

        str.str("");

   236

   237

        if (configIter->slave_position != -1) {

   238

            m.getSlave(&slave, configIter->slave_position);

   239

   240

            str << dec << configIter->slave_position;

   241

            info.slavePos = str.str();

   242

            str.clear();

   243

            str.str("");

   244

   245

            str << alStateString(slave.al_state);

   246

            info.state = str.str();

   247

            str.clear();

   248

            str.str("");

   249

        } else {

   250

            str << "-";

   251

            info.slavePos = str.str();

   252

            str.clear();

   253

            str.str("");

   254

   255

            str << "-";

   256

            info.state = str.str();

   257

            str.clear();

   258

            str.str("");

   259

        }

   260

   261

        list.push_back(info);

   262

   263

        if (info.alias.length() > maxAliasWidth)

   264

            maxAliasWidth = info.alias.length();

   265

        if (info.pos.length() > maxPosWidth)

   266

            maxPosWidth = info.pos.length();

   267

        if (info.slavePos.length() > maxSlavePosWidth)

   268

            maxSlavePosWidth = info.slavePos.length();

   269

        if (info.state.length() > maxStateWidth)

   270

            maxStateWidth = info.state.length();

   271

    }

   272

   273

    for (iter = list.begin(); iter != list.end(); iter++) {

   274

        cout << setfill(' ') << right

   275

            << setw(maxAliasWidth) << iter->alias

   276

            << ":" << left

   277

            << setw(maxPosWidth) << iter->pos

   278

            << "  "

   279

            << iter->ident

   280

            << "  "

   281

            << setw(maxSlavePosWidth) << iter->slavePos << "  "

   282

            << setw(maxStateWidth) << iter->state << "  "

   283

            << endl;

   284

    }

   285

}

   286

   287

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