1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <iostream>

     8

#include <iomanip>

     9

using namespace std;

    10

    11

#include "globals.h"

    12

    13

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

    14

    15

const char *help_domains =

    16

    "[OPTIONS]\n"

    17

    "\n"

    18

    "Show information about the application's configured domains.\n"

    19

    "\n"

    20

    "Without the --verbose option, one domain is displayed per line.\n"

    21

    "Example:\n"

    22

    "\n"

    23

    "Domain0: LogBaseAddr 0x00000000, Size   6, WorkingCounter 0/1\n"

    24

    "\n"

    25

    "The domain's base address for the logical datagram (LRD/LWR/LRW)\n"

    26

    "is displayed followed by the domain's process data size in byte.\n"

    27

    "The last values are the current datagram working counter sum and\n"

    28

    "the expected working counter sum. If the values are equal, all\n"

    29

    "Pdos are exchanged.\n"

    30

    "\n"

    31

    "If the --verbose option is given, the participating slave\n"

    32

    "configurations/FMMUs and the current process data are additionally\n"

    33

    "displayed:\n"

    34

    "\n"

    35

    "Domain1: LogBaseAddr 0x00000006, Size   6, WorkingCounter 0/1\n"

    36

    "  SlaveConfig 1001:0, SM3 ( Input), LogAddr 0x00000006, Size 6\n"

    37

    "    00 00 00 00 00 00\n"

    38

    "\n"

    39

    "The process data are displayed as raw hexadecimal bytes.\n"

    40

    "\n"

    41

    "Command-specific options:\n"

    42

    "  --domain   -d <index> Positive numerical domain index, or 'all'\n"

    43

    "                        for all domains (default).\n"

    44

    "  --verbose  -v         Show FMMUs and process data additionally.\n";

    45

    46

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

    47

    48

void showDomain(unsigned int);

    49

    50

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

    51

    52

void command_domains(void)

    53

{

    54

    masterDev.open(MasterDevice::Read);

    55

    56

    if (domainIndex == -1) {

    57

        unsigned int i;

    58

        ec_ioctl_master_t master;

    59

    60

        masterDev.getMaster(&master);

    61

    62

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

    63

            showDomain(i);

    64

        }

    65

    } else {

    66

        showDomain(domainIndex);

    67

    }

    68

}

    69

    70

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

    71

    72

void showDomain(unsigned int domainIndex)

    73

{

    74

    ec_ioctl_domain_t domain;

    75

    unsigned char *processData;

    76

    ec_ioctl_domain_data_t data;

    77

    unsigned int i, j;

    78

    ec_ioctl_domain_fmmu_t fmmu;

    79

    unsigned int dataOffset;

    80

    81

    masterDev.getDomain(&domain, domainIndex);

    82

    83

	cout << "Domain" << dec << domainIndex << ":"

    84

		<< " LogBaseAddr 0x"

    85

		<< hex << setfill('0')

    86

        << setw(8) << domain.logical_base_address

    87

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

    88

        << setw(3) << domain.data_size

    89

		<< ", WorkingCounter "

    90

		<< domain.working_counter << "/"

    91

        << domain.expected_working_counter << endl;

    92

    93

    if (!domain.data_size || verbosity != Verbose)

    94

        return;

    95

    96

    processData = new unsigned char[domain.data_size];

    97

    98

    try {

    99

        masterDev.getData(&data, domainIndex, domain.data_size, processData);

   100

    } catch (MasterDeviceException &e) {

   101

        delete [] processData;

   102

        throw e;

   103

    }

   104

   105

    for (i = 0; i < domain.fmmu_count; i++) {

   106

        masterDev.getFmmu(&fmmu, domainIndex, i);

   107

   108

        cout << "  SlaveConfig "

   109

            << dec << fmmu.slave_config_alias

   110

            << ":" << fmmu.slave_config_position

   111

            << ", SM" << (unsigned int) fmmu.sync_index << " ("

   112

            << setfill(' ') << setw(6)

   113

            << (fmmu.dir == EC_DIR_INPUT ? "Input" : "Output")

   114

            << "), LogAddr 0x"

   115

            << hex << setfill('0')

   116

            << setw(8) << fmmu.logical_address

   117

            << ", Size " << dec << fmmu.data_size << endl;

   118

   119

        dataOffset = fmmu.logical_address - domain.logical_base_address;

   120

        if (dataOffset + fmmu.data_size > domain.data_size) {

   121

            stringstream err;

   123

            err << "Fmmu information corrupted!";

   125

        }

   126

   127

        cout << "    " << hex << setfill('0');

   128

        for (j = 0; j < fmmu.data_size; j++) {

   129

            if (j && !(j % BreakAfterBytes))

   130

                cout << endl << "    ";

   131

            cout << setw(2)

   132

                << (unsigned int) *(processData + dataOffset + j) << " ";

   133

        }

   134

        cout << endl;

   135

    }

   136

   137

    delete [] processData;

   138

}

   139

   140

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