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

/** Lists the bus configuration.

    62

 */

    63

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

    64

{

    66

    67

    m.open(MasterDevice::Read);

    69

    70

    if (getVerbosity() == Verbose) {

    72

    } else {

    74

    }

    75

}

    76

    77

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

    78

    79

/** Lists the complete bus configuration.

    80

 */

    81

void CommandConfig::showDetailedConfigs(

    82

		MasterDevice &m,

    83

		const ConfigList &configList

    84

		)

    85

{

    86

    ConfigList::const_iterator configIter;

    87

    unsigned int j, k, l;

    88

    ec_ioctl_slave_t slave;

    89

    ec_ioctl_config_pdo_t pdo;

    90

    ec_ioctl_config_pdo_entry_t entry;

    91

    ec_ioctl_config_sdo_t sdo;

    92

    93

    for (configIter = configList.begin();

    94

            configIter != configList.end();

    95

            configIter++) {

    96

    97

        cout << "Alias: "

    98

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

    99

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

   100

            << "Vendor Id: 0x"

   101

            << hex << setfill('0')

   102

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

   103

            << "Product code: 0x"

   104

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

   105

            << "Attached slave: ";

   106

   107

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

   108

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

   109

            cout << configIter->slave_position

   110

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

   111

        } else {

   112

            cout << "none" << endl;

   113

        }

   114

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

   123

                    cout << "  Pdo 0x" << hex

   124

                        << setw(4) << pdo.index

   125

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

   126

   127

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

   128

                        m.getConfigPdoEntry(&entry,

   129

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

   130

   131

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

   132

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

   133

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

   134

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

   135

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

   136

                    }

   137

                }

   138

            }

   139

        }

   140

   141

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

   142

        if (configIter->sdo_count) {

   143

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

   144

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

   145

   146

                cout << "  0x"

   147

                    << hex << setfill('0')

   148

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

   149

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

   150

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

   151

   152

                switch (sdo.size) {

   153

                    case 1:

   154

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

   155

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

   156

                        break;

   157

                    case 2:

   158

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

   159

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

   160

                        break;

   161

                    case 4:

   162

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

   163

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

   164

                        break;

   165

                    default:

   166

                        cout << "???";

   167

                }

   168

   169

                cout << endl;

   170

            }

   171

        } else {

   172

            cout << "  None." << endl;

   173

        }

   174

   175

        cout << endl;

   176

    }

   177

}

   178

   179

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

   180

   181

/** Lists the bus configuration.

   182

 */

   183

void CommandConfig::listConfigs(

   184

        MasterDevice &m,

   185

        const ConfigList &configList

   186

        )

   187

{

   188

    ConfigList::const_iterator configIter;

   189

    stringstream str;

   190

    Info info;

   191

    typedef list<Info> InfoList;

   192

    InfoList list;

   193

    InfoList::const_iterator iter;

   194

    unsigned int maxAliasWidth = 0, maxPosWidth = 0,

   195

                 maxSlavePosWidth = 0, maxStateWidth = 0;

   196

    ec_ioctl_slave_t slave;

   197

   198

    for (configIter = configList.begin();

   199

            configIter != configList.end();

   200

            configIter++) {

   201

   202

        str << dec << configIter->alias;

   203

        info.alias = str.str();

   204

        str.clear();

   205

        str.str("");

   206

   207

        str << configIter->position;

   208

        info.pos = str.str();

   209

        str.clear();

   210

        str.str("");

   211

   212

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

   213

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

   214

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

   215

        info.ident = str.str();

   216

        str.clear();

   217

        str.str("");

   218

   219

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

   220

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

   221

   222

            str << configIter->slave_position;

   223

            info.slavePos = str.str();

   224

            str.clear();

   225

            str.str("");

   226

   227

            str << alStateString(slave.al_state);

   228

            info.state = str.str();

   229

            str.clear();

   230

            str.str("");

   231

        } else {

   232

            str << "-";

   233

            info.slavePos = str.str();

   234

            str.clear();

   235

            str.str("");

   236

   237

            str << "-";

   238

            info.state = str.str();

   239

            str.clear();

   240

            str.str("");

   241

        }

   242

   243

        list.push_back(info);

   244

   245

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

   246

            maxAliasWidth = info.alias.length();

   247

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

   248

            maxPosWidth = info.pos.length();

   249

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

   250

            maxSlavePosWidth = info.slavePos.length();

   251

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

   252

            maxStateWidth = info.state.length();

   253

    }

   254

   255

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

   256

        cout << setfill(' ') << right

   257

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

   258

            << ":" << left

   259

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

   260

            << "  "

   261

            << iter->ident

   262

            << "  "

   263

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

   264

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

   265

            << endl;

   266

    }

   267

}

   268

   269

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