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

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

    47

    	<< "|          hexadecimal)." << endl

    48

    	<< "\\- Alias 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

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

    54

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

    55

    56

	return str.str();

    57

}

    58

    59

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

    60

    61

bool operator<(

    62

        const ec_ioctl_config_t &a,

    63

        const ec_ioctl_config_t &b

    64

        )

    65

{

    66

    return a.alias < b.alias

    67

        || (a.alias == b.alias && a.position < b.position);

    68

}

    69

    70

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

    71

    72

/** Lists the bus configuration.

    73

 */

    74

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

    75

{

    76

    ec_ioctl_master_t master;

    77

    unsigned int i;

    78

    ec_ioctl_config_t config;

    79

    ConfigList configList;

    80

    81

    m.open(MasterDevice::Read);

    82

    m.getMaster(&master);

    83

    84

    for (i = 0; i < master.config_count; i++) {

    85

        m.getConfig(&config, i);

    86

        configList.push_back(config);

    87

    }

    88

    89

    configList.sort();

    90

    91

    if (getVerbosity() == Verbose) {

    92

        showDetailedConfigs(m, configList);

    93

    } else {

    94

        listConfigs(m, configList);

    95

    }

    96

}

    97

    98

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

    99

   100

/** Lists the complete bus configuration.

   101

 */

   102

void CommandConfig::showDetailedConfigs(

   103

		MasterDevice &m,

   104

		const ConfigList &configList

   105

		)

   106

{

   107

    ConfigList::const_iterator configIter;

   108

    unsigned int j, k, l;

   109

    ec_ioctl_slave_t slave;

   110

    ec_ioctl_config_pdo_t pdo;

   111

    ec_ioctl_config_pdo_entry_t entry;

   112

    ec_ioctl_config_sdo_t sdo;

   113

   114

    for (configIter = configList.begin();

   115

            configIter != configList.end();

   116

            configIter++) {

   117

   118

        cout << "Alias: "

   119

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

   120

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

   121

            << "Vendor Id: 0x"

   122

            << hex << setfill('0')

   123

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

   124

            << "Product code: 0x"

   125

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

   126

            << "Attached slave: ";

   127

   128

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

   129

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

   130

            cout << configIter->slave_position

   131

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

   132

        } else {

   133

            cout << "none" << endl;

   134

        }

   135

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

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

   143

   144

                    cout << "  Pdo 0x" << hex

   145

                        << setw(4) << pdo.index

   146

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

   147

   148

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

   149

                        m.getConfigPdoEntry(&entry,

   150

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

   151

   152

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

   153

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

   154

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

   155

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

   156

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

   157

                    }

   158

                }

   159

            }

   160

        }

   161

   162

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

   163

        if (configIter->sdo_count) {

   164

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

   165

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

   166

   167

                cout << "  0x"

   168

                    << hex << setfill('0')

   169

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

   170

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

   171

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

   172

   173

                switch (sdo.size) {

   174

                    case 1:

   175

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

   176

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

   177

                        break;

   178

                    case 2:

   179

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

   180

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

   181

                        break;

   182

                    case 4:

   183

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

   184

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

   185

                        break;

   186

                    default:

   187

                        cout << "???";

   188

                }

   189

   190

                cout << endl;

   191

            }

   192

        } else {

   193

            cout << "  None." << endl;

   194

        }

   195

   196

        cout << endl;

   197

    }

   198

}

   199

   200

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

   201

   202

/** Lists the bus configuration.

   203

 */

   204

void CommandConfig::listConfigs(

   205

        MasterDevice &m,

   206

        const ConfigList &configList

   207

        )

   208

{

   209

    ConfigList::const_iterator configIter;

   210

    stringstream str;

   211

    Info info;

   212

    typedef list<Info> InfoList;

   213

    InfoList list;

   214

    InfoList::const_iterator iter;

   215

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   216

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   217

    ec_ioctl_slave_t slave;

   218

   219

    for (configIter = configList.begin();

   220

            configIter != configList.end();

   221

            configIter++) {

   222

   223

        str << dec << configIter->alias;

   224

        info.alias = str.str();

   225

        str.clear();

   226

        str.str("");

   227

   228

        str << configIter->position;

   229

        info.pos = str.str();

   230

        str.clear();

   231

        str.str("");

   232

   233

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

   234

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

   235

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

   236

        info.ident = str.str();

   237

        str.clear();

   238

        str.str("");

   239

   240

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

   241

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

   242

   243

            str << configIter->slave_position;

   244

            info.slavePos = str.str();

   245

            str.clear();

   246

            str.str("");

   247

   248

            str << alStateString(slave.al_state);

   249

            info.state = str.str();

   250

            str.clear();

   251

            str.str("");

   252

        } else {

   253

            str << "-";

   254

            info.slavePos = str.str();

   255

            str.clear();

   256

            str.str("");

   257

   258

            str << "-";

   259

            info.state = str.str();

   260

            str.clear();

   261

            str.str("");

   262

        }

   263

   264

        list.push_back(info);

   265

   266

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

   267

            maxAliasWidth = info.alias.length();

   268

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

   269

            maxPosWidth = info.pos.length();

   270

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

   271

            maxSlavePosWidth = info.slavePos.length();

   272

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

   273

            maxStateWidth = info.state.length();

   274

    }

   275

   276

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

   277

        cout << setfill(' ') << right

   278

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

   279

            << ":" << left

   280

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

   281

            << "  "

   282

            << iter->ident

   283

            << "  "

   284

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

   285

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

   286

            << endl;

   287

    }

   288

}

   289

   290

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