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

    50

    	<< "With the --verbose option given, the configured Pdos and" << endl

    51

    	<< "Sdos are output in addition." << 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

   142

                    cout << "  Pdo 0x" << hex

   143

                        << setw(4) << pdo.index

   144

                        << " \"" << pdo.name << "\"" << endl;

   145

   146

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

   147

                        m.getConfigPdoEntry(&entry,

   148

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

   149

   150

                        cout << "    Pdo entry 0x" << hex

   151

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

   152

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

   153

                            << ", " << dec << (unsigned int) entry.bit_length

   154

                            << " bit, \"" << entry.name << "\"" << endl;

   155

                    }

   156

                }

   157

            }

   158

        }

   159

   160

        cout << "Sdo configuration:" << endl;

   161

        if (configIter->sdo_count) {

   162

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

   163

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

   164

   165

                cout << "  0x"

   166

                    << hex << setfill('0')

   167

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

   168

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

   169

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

   170

   171

                switch (sdo.size) {

   172

                    case 1:

   173

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

   174

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

   175

                        break;

   176

                    case 2:

   177

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

   178

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

   179

                        break;

   180

                    case 4:

   181

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

   182

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

   183

                        break;

   184

                    default:

   185

                        cout << "???";

   186

                }

   187

   188

                cout << endl;

   189

            }

   190

        } else {

   191

            cout << "  None." << endl;

   192

        }

   193

   194

        cout << endl;

   195

    }

   196

}

   197

   198

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

   199

   200

/** Lists the bus configuration.

   201

 */

   202

void CommandConfig::listConfigs(

   203

        MasterDevice &m,

   204

        const ConfigList &configList

   205

        )

   206

{

   207

    ConfigList::const_iterator configIter;

   208

    stringstream str;

   209

    Info info;

   210

    typedef list<Info> InfoList;

   211

    InfoList list;

   212

    InfoList::const_iterator iter;

   213

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   214

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   215

    ec_ioctl_slave_t slave;

   216

   217

    for (configIter = configList.begin();

   218

            configIter != configList.end();

   219

            configIter++) {

   220

   221

        str << dec << configIter->alias;

   222

        info.alias = str.str();

   223

        str.clear();

   224

        str.str("");

   225

   226

        str << configIter->position;

   227

        info.pos = str.str();

   228

        str.clear();

   229

        str.str("");

   230

   231

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

   232

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

   233

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

   234

        info.ident = str.str();

   235

        str.clear();

   236

        str.str("");

   237

   238

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

   239

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

   240

   241

            str << dec << configIter->slave_position;

   242

            info.slavePos = str.str();

   243

            str.clear();

   244

            str.str("");

   245

   246

            str << alStateString(slave.al_state);

   247

            info.state = str.str();

   248

            str.clear();

   249

            str.str("");

   250

        } else {

   251

            str << "-";

   252

            info.slavePos = str.str();

   253

            str.clear();

   254

            str.str("");

   255

   256

            str << "-";

   257

            info.state = str.str();

   258

            str.clear();

   259

            str.str("");

   260

        }

   261

   262

        list.push_back(info);

   263

   264

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

   265

            maxAliasWidth = info.alias.length();

   266

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

   267

            maxPosWidth = info.pos.length();

   268

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

   269

            maxSlavePosWidth = info.slavePos.length();

   270

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

   271

            maxStateWidth = info.state.length();

   272

    }

   273

   274

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

   275

        cout << setfill(' ') << right

   276

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

   277

            << ":" << left

   278

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

   279

            << "  "

   280

            << iter->ident

   281

            << "  "

   282

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

   283

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

   284

            << endl;

   285

    }

   286

}

   287

   288

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