1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

#include <iostream>

    31

#include <iomanip>

    32

#include <cstring>

    33

using namespace std;

    34

    35

#include "CommandPdos.h"

    36

#include "MasterDevice.h"

    37

    38

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

    39

    40

CommandPdos::CommandPdos():

    41

    Command("pdos", "List Sync managers, PDO assignment and mapping.")

    42

{

    43

}

    44

    45

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

    46

    47

string CommandPdos::helpString(const string &binaryBaseName) const

    48

{

    49

    stringstream str;

    50

    51

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

    52

        << endl

    53

        << getBriefDescription() << endl

    54

        << endl

    55

        << "For the default skin (see --skin option) the information" << endl

    56

        << "is displayed in three layers, which are" << endl

    57

        << "indented accordingly:" << endl

    58

        << endl

    59

        << "1) Sync managers - Contains the sync manager information" << endl

    60

        << "   from the SII: Index, physical start address, default" << endl

    61

        << "   size, control register and enable word. Example:" << endl

    62

        << endl

    63

        << "   SM3: PhysAddr 0x1100, DefaultSize 0, ControlRegister 0x20, "

    64

        << "Enable 1" << endl

    65

        << endl

    66

        << "2) Assigned PDOs - PDO direction, hexadecimal index and" << endl

    67

        << "   the PDO name, if avaliable. Note that a 'Tx' and 'Rx'" << endl

    68

        << "   are seen from the slave's point of view. Example:" << endl

    69

        << endl

    70

        << "   TxPDO 0x1a00 \"Channel1\"" << endl

    71

        << endl

    72

        << "3) Mapped PDO entries - PDO entry index and subindex (both" << endl

    73

        << "   hexadecimal), the length in bit and the description, if" << endl

    74

        << "   available. Example:" << endl

    75

        << endl

    76

        << "   PDO entry 0x3101:01, 8 bit, \"Status\"" << endl

    77

        << endl

    78

        << "Note, that the displayed PDO assignment and PDO mapping" << endl

    79

        << "information can either originate from the SII or from the" << endl

    80

        << "CoE communication area." << endl

    81

        << endl

    82

        << "The \"etherlab\" skin outputs a template configuration" << endl

    83

        << "for EtherLab's generic EtherCAT slave block." << endl

    84

        << endl

    85

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

    86

        << "  --alias    -a <alias>" << endl

    87

        << "  --position -p <pos>    Slave selection. See the help of" << endl

    88

        << "                         the 'slaves' command." << endl

    89

        << "  --skin     -s <skin>   Choose output skin. Possible values are"

    90

        << endl

    91

        << "                         \"default\" and \"etherlab\"." << endl

    92

        << endl

    93

        << numericInfo();

    94

    95

    return str.str();

    96

}

    97

    98

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

    99

   100

void CommandPdos::execute(const StringVector &args)

   101

{

   102

	MasterIndexList masterIndices;

   103

    SlaveList slaves;

   104

    SlaveList::const_iterator si;

   105

    bool showHeader, multiMaster;

   106

   107

    if (args.size()) {

   108

        stringstream err;

   109

        err << "'" << getName() << "' takes no arguments!";

   110

        throwInvalidUsageException(err);

   111

    }

   112

   113

    if (getSkin().empty() || getSkin() == "default") {

   114

        masterIndices = getMasterIndices();

   115

        multiMaster = masterIndices.size() > 1;

   116

        MasterIndexList::const_iterator mi;

   117

        for (mi = masterIndices.begin();

   118

                mi != masterIndices.end(); mi++) {

   119

            MasterDevice m(*mi);

   120

            m.open(MasterDevice::Read);

   121

            slaves = selectedSlaves(m);

   122

            showHeader = multiMaster || slaves.size() > 1;

   123

   124

            for (si = slaves.begin(); si != slaves.end(); si++) {

   125

                listSlavePdos(m, *si, showHeader);

   126

            }

   127

        }

   128

    }

   129

    else if (getSkin() == "etherlab") {

   130

        masterIndices = getMasterIndices();

   131

        MasterIndexList::const_iterator mi;

   132

        for (mi = masterIndices.begin();

   133

                mi != masterIndices.end(); mi++) {

   134

            MasterDevice m(*mi);

   135

            m.open(MasterDevice::Read);

   136

            slaves = selectedSlaves(m);

   137

   138

            for (si = slaves.begin(); si != slaves.end(); si++) {

   139

                etherlabConfig(m, *si);

   140

            }

   141

        }

   142

    }

   143

    else {

   144

        stringstream err;

   145

        err << "Invalid skin '" << getSkin() << "'!";

   146

        throwInvalidUsageException(err);

   147

    }

   148

}

   149

   150

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

   151

   152

void CommandPdos::listSlavePdos(

   153

        MasterDevice &m,

   154

        const ec_ioctl_slave_t &slave,

   155

        bool showHeader

   156

        )

   157

{

   158

    ec_ioctl_slave_sync_t sync;

   159

    ec_ioctl_slave_sync_pdo_t pdo;

   160

    ec_ioctl_slave_sync_pdo_entry_t entry;

   161

    unsigned int i, j, k;

   162

   163

    if (showHeader && slave.sync_count)

   164

        cout << "=== Master " << m.getIndex()

   165

            << ", Slave " << slave.position << " ===" << endl;

   166

   167

    for (i = 0; i < slave.sync_count; i++) {

   168

        m.getSync(&sync, slave.position, i);

   169

   170

        cout << "SM" << i << ":"

   171

            << " PhysAddr 0x"

   172

            << hex << setfill('0')

   173

            << setw(4) << sync.physical_start_address

   174

            << ", DefaultSize "

   175

            << dec << setfill(' ') << setw(4) << sync.default_size

   176

            << ", ControlRegister 0x"

   177

            << hex << setfill('0') << setw(2)

   178

            << (unsigned int) sync.control_register

   179

            << ", Enable " << dec << (unsigned int) sync.enable

   180

            << endl;

   181

   182

        for (j = 0; j < sync.pdo_count; j++) {

   183

            m.getPdo(&pdo, slave.position, i, j);

   184

   185

            cout << "  " << (sync.control_register & 0x04 ? "R" : "T")

   186

                << "xPDO 0x"

   187

                << hex << setfill('0')

   188

                << setw(4) << pdo.index

   189

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

   190

   191

            if (getVerbosity() == Quiet)

   192

                continue;

   193

   194

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

   195

                m.getPdoEntry(&entry, slave.position, i, j, k);

   196

   197

                cout << "    PDO entry 0x"

   198

                    << hex << setfill('0')

   199

                    << setw(4) << entry.index

   200

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

   201

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

   202

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

   203

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

   204

            }

   205

        }

   206

    }

   207

}

   208

   209

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

   210

   211

void CommandPdos::etherlabConfig(

   212

        MasterDevice &m,

   213

        const ec_ioctl_slave_t &slave

   214

        )

   215

{

   216

    ec_ioctl_slave_sync_t sync;

   217

    ec_ioctl_slave_sync_pdo_t pdo;

   218

    ec_ioctl_slave_sync_pdo_entry_t entry;

   219

    unsigned int i, j, k;

   220

   221

    cout << "%" << endl

   222

        << "% Master " << m.getIndex() << ", Slave " << slave.position;

   223

    if (strlen(slave.order)) {

   224

        cout << ", \"" << slave.order << "\"";

   225

    }

   226

    cout << endl

   227

        << "%" << endl

   228

        << "function rv = slave" << slave.position << "()" << endl << endl;

   229

   230

    cout << "% Slave configuration" << endl << endl;

   231

   232

    cout << "rv.SlaveConfig.vendor = " << slave.vendor_id << ";" << endl

   233

        << "rv.SlaveConfig.product = hex2dec('"

   234

        << hex << setfill('0') << setw(8) << slave.product_code << "');"

   235

        << endl

   236

        << "rv.SlaveConfig.description = '" << slave.order << "';" << endl

   237

        << "rv.SlaveConfig.sm = { ..." << endl;

   238

   239

    /* slave configuration */

   240

    for (i = 0; i < slave.sync_count; i++) {

   241

        m.getSync(&sync, slave.position, i);

   242

   243

        cout << "    {" << dec << i << ", "

   244

            << (sync.control_register & 0x04 ? 0 : 1) << ", {" << endl;

   245

   246

        for (j = 0; j < sync.pdo_count; j++) {

   247

            m.getPdo(&pdo, slave.position, i, j);

   248

   249

            cout << "        {hex2dec('" <<

   250

                hex << setfill('0') << setw(4) << pdo.index << "'), ["

   251

                << endl;

   252

   253

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

   254

                m.getPdoEntry(&entry, slave.position, i, j, k);

   255

   256

                cout << "            hex2dec('"

   257

                    << hex << setfill('0') << setw(4) << entry.index

   258

                    << "'), hex2dec('"

   259

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

   260

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

   261

                    << (unsigned int) entry.bit_length

   262

                    << "; ..." << endl;

   263

            }

   264

   265

            cout << "            ]}, ..." << endl;

   266

        }

   267

        cout << "        }}, ..." << endl;

   268

    }

   269

   270

    cout << "    };" << endl << endl;

   271

   272

    cout << "% Port configuration" << endl << endl;

   273

   274

    unsigned int input = 1, output = 1;

   275

    for (i = 0; i < slave.sync_count; i++) {

   276

        m.getSync(&sync, slave.position, i);

   277

   278

        for (j = 0; j < sync.pdo_count; j++) {

   279

            m.getPdo(&pdo, slave.position, i, j);

   280

   281

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

   282

                m.getPdoEntry(&entry, slave.position, i, j, k);

   283

   284

                if (!entry.index) {

   285

                    continue;

   286

                }

   287

   288

                string dir;

   289

                unsigned int port;

   290

   291

                if (sync.control_register & 0x04) {

   292

                    dir = "input";

   293

                    port = input++;

   294

                }

   295

                else {

   296

                    dir = "output";

   297

                    port = output++;

   298

                }

   299

   300

                stringstream var;

   301

                var << "rv.PortConfig." << dir << "(" << dec << port

   302

                    << ")";

   303

   304

                cout << var.str() << ".pdo = ["

   305

                    << i << ", " << j << ", " << k << ", 0];" << endl;

   306

                cout << var.str() << ".pdo_data_type = "

   307

                    << 1000 + (unsigned int) entry.bit_length

   308

                    << ";" << endl << endl;

   309

            }

   310

        }

   311

    }

   312

   313

    cout << "end" << endl;

   314

}

   315

   316

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