1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

     5

# This file is part of Beremiz

     6

#

     7

# Copyright (C) 2013: Real-Time & Embedded Systems (RTES) Lab. University of Seoul, Korea

     8

#

     9

# See COPYING file for copyrights details.

    10

    11

from __future__ import absolute_import

    13

import wx

    14

    16

mailbox_protocols = ["AoE", "EoE", "CoE", "FoE", "SoE", "VoE"]

    17

    18

    19

def ExtractHexDecValue(value):

    20

    """

    21

     convert numerical value in string format into decimal or hex format.

    22

     @param value : hex or decimal data

    23

     @return integer data

    24

    """

    25

    try:

    26

        return int(value)

    27

    except Exception:

    28

        pass

    29

    try:

    30

        return int(value.replace("#", "0"), 16)

    31

    32

    except Exception:

    33

        raise ValueError(_("Invalid value for HexDecValue \"%s\"") % value)

    34

    35

    36

def ExtractName(names, default=None):

    37

    """

    38

     Extract "name" field from XML entries.

    39

     @param names : XML entry

    40

     @default : if it fails to extract from the designated XML entry, return the default value ("None").

    41

     @return default or the name extracted

    42

    """

    43

    if len(names) == 1:

    44

        return names[0].getcontent()

    45

    else:

    46

        for name in names:

    47

            if name.getLcId() == 1033:

    48

                return name.getcontent()

    49

    return default

    50

    51

# --------------------------------------------------

    52

#         Remote Exec Etherlab Commands

    53

# --------------------------------------------------

    54

    55

    56

# --------------------- for master ---------------------------

    57

MASTER_STATE = """

    58

import commands

    59

result = commands.getoutput("ethercat master")

    60

returnVal =result

    61

"""

    62

    63

# --------------------- for slave ----------------------------

    64

# ethercat state -p (slave position) (state (INIT, PREOP, SAFEOP, OP))

    65

SLAVE_STATE = """

    66

import commands

    67

result = commands.getoutput("ethercat state -p %d %s")

    68

returnVal = result

    69

"""

    70

    71

# ethercat slave

    72

GET_SLAVE = """

    73

import commands

    74

result = commands.getoutput("ethercat slaves")

    75

returnVal =result

    76

"""

    77

    78

# ethercat xml -p (slave position)

    79

SLAVE_XML = """

    80

import commands

    81

result = commands.getoutput("ethercat xml -p %d")

    82

returnVal = result

    83

"""

    84

    85

# ethercat sdos -p (slave position)

    86

SLAVE_SDO = """

    87

import commands

    88

result = commands.getoutput("ethercat sdos -p %d")

    89

returnVal =result

    90

"""

    91

    92

# ethercat upload -p (slave position) (main index) (sub index)

    93

GET_SLOW_SDO = """

    94

import commands

    95

result = commands.getoutput("ethercat upload -p %d %s %s")

    96

returnVal =result

    97

"""

    98

    99

# ethercat download -p (slave position) (main index) (sub index) (value)

   100

SDO_DOWNLOAD = """

   101

import commands

   102

result = commands.getoutput("ethercat download --type %s -p %d %s %s %s")

   103

returnVal =result

   104

"""

   105

   106

# ethercat sii_read -p (slave position)

   107

SII_READ = """

   108

import commands

   109

result = commands.getoutput("ethercat sii_read -p %d")

   110

returnVal =result

   111

"""

   112

   113

# ethercat reg_read -p (slave position) (address) (size)

   114

REG_READ = """

   115

import commands

   116

result = commands.getoutput("ethercat reg_read -p %d %s %s")

   117

returnVal =result

   118

"""

   119

   120

# ethercat sii_write -p (slave position) - (contents)

   121

SII_WRITE = """

   122

import subprocess

   123

process = subprocess.Popen(

   124

    ["ethercat", "-f", "sii_write", "-p", "%d", "-"],

   125

    stdin=subprocess.PIPE)

   126

process.communicate(sii_data)

   127

returnVal = process.returncode

   128

"""

   129

   130

# ethercat reg_write -p (slave position) -t (uinit16) (address) (data)

   131

REG_WRITE = """

   132

import commands

   133

result = commands.getoutput("ethercat reg_write -p %d -t uint16 %s %s")

   134

returnVal =result

   135

"""

   136

   137

# ethercat rescan -p (slave position)

   138

RESCAN = """

   139

import commands

   140

result = commands.getoutput("ethercat rescan -p %d")

   141

returnVal =result

   142

"""

   143

   144

   145

# --------------------------------------------------

   146

#    Common Method For EtherCAT Management

   147

# --------------------------------------------------

   148

class _CommonSlave(object):

   149

   150

    # ----- Data Structure for ethercat management ----

   151

    SlaveState = ""

   152

   153

    # category of SDO data

   154

    DatatypeDescription, CommunicationObject, ManufacturerSpecific, \

   155

        ProfileSpecific, Reserved, AllSDOData = range(6)

   156

   157

    # store the execution result of "ethercat sdos" command into SaveSDOData.

   158

    SaveSDOData = []

   159

   160

    # Flags for checking "write" permission of OD entries

   161

    CheckPREOP = False

   162

    CheckSAFEOP = False

   163

    CheckOP = False

   164

   165

    # Save PDO Data

   166

    TxPDOInfo = []

   167

    TxPDOCategory = []

   168

    RxPDOInfo = []

   169

    RxPDOCategory = []

   170

   171

    # Save EEPROM Data

   172

    SiiData = ""

   173

   174

    # Save Register Data

   175

    RegData = ""

   176

    CrtRegSpec = {"ESCType": "",

   177

                  "FMMUNumber": "",

   178

                  "SMNumber": "",

   179

                  "PDIType": ""}

   180

   181

    def __init__(self, controler):

   182

        """

   183

        Constructor

   184

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   185

        """

   186

        self.Controler = controler

   187

   188

        self.ClearSDODataSet()

   189

   190

    # -------------------------------------------------------------------------------

   191

    #                        Used Master State

   192

    # -------------------------------------------------------------------------------

   193

    def GetMasterState(self):

   194

        """

   195

        Execute "ethercat master" command and parse the execution result

   196

        @return MasterState

   197

        """

   198

   199

        # exectute "ethercat master" command

   200

        _error, return_val = self.Controler.RemoteExec(MASTER_STATE, return_val=None)

   201

        master_state = {}

   202

        # parse the reslut

   203

        for each_line in return_val.splitlines():

   204

            if len(each_line) > 0:

   205

                chunks = each_line.strip().split(':', 1)

   206

                key = chunks[0]

   207

                value = []

   208

                if len(chunks) > 1:

   209

                    value = chunks[1].split()

   210

                if '(attached)' in value:

   211

                    value.remove('(attached)')

   212

                master_state[key] = value

   213

   214

        return master_state

   215

   216

    # -------------------------------------------------------------------------------

   217

    #                        Used Slave State

   218

    # -------------------------------------------------------------------------------

   219

    def RequestSlaveState(self, command):

   220

        """

   221

        Set slave state to the specified one using "ethercat states -p %d %s" command.

   222

        Command example : "ethercat states -p 0 PREOP" (target slave position and target state are given.)

   223

        @param command : target slave state

   224

        """

   225

        _error, _return_val = self.Controler.RemoteExec(

   226

            SLAVE_STATE % (self.Controler.GetSlavePos(), command),

   227

            return_val=None)

   228

   229

    def GetSlaveStateFromSlave(self):

   230

        """

   231

        Get slave information using "ethercat slaves" command and store the information into internal data structure

   232

        (self.SlaveState) for "Slave State"

   233

        return_val example : 0  0:0  PREOP  +  EL9800 (V4.30) (PIC24, SPI, ET1100)

   234

        """

   235

        _error, return_val = self.Controler.RemoteExec(GET_SLAVE, return_val=None)

   236

        self.SlaveState = return_val

   237

        return return_val

   238

   239

    # -------------------------------------------------------------------------------

   240

    #                        Used SDO Management

   241

    # -------------------------------------------------------------------------------

   242

    def GetSlaveSDOFromSlave(self):

   243

        """

   244

        Get SDO objects information of current slave using "ethercat sdos -p %d" command.

   245

        Command example : "ethercat sdos -p 0"

   246

        @return return_val : execution results of "ethercat sdos" command (need to be parsed later)

   247

        """

   248

        _error, return_val = self.Controler.RemoteExec(SLAVE_SDO % (self.Controler.GetSlavePos()), return_val=None)

   249

        return return_val

   250

   251

    def SDODownload(self, data_type, idx, sub_idx, value):

   252

        """

   253

        Set an SDO object value to user-specified value using "ethercat download" command.

   254

        Command example : "ethercat download --type int32 -p 0 0x8020 0x12 0x00000000"

   255

        @param data_type : data type of SDO entry

   256

        @param idx : index of the SDO entry

   257

        @param sub_idx : subindex of the SDO entry

   258

        @param value : value of SDO entry

   259

        """

   260

        _error, _return_val = self.Controler.RemoteExec(

   261

            SDO_DOWNLOAD % (data_type, self.Controler.GetSlavePos(), idx, sub_idx, value),

   262

            return_val=None)

   263

   264

    def BackupSDODataSet(self):

   265

        """

   266

        Back-up current SDO entry information to restore the SDO data

   267

        in case that the user cancels SDO update operation.

   268

        """

   269

        self.BackupDatatypeDescription = self.SaveDatatypeDescription

   270

        self.BackupCommunicationObject = self.SaveCommunicationObject

   271

        self.BackupManufacturerSpecific = self.SaveManufacturerSpecific

   272

        self.BackupProfileSpecific = self.SaveProfileSpecific

   273

        self.BackupReserved = self.SaveReserved

   274

        self.BackupAllSDOData = self.SaveAllSDOData

   275

   276

    def ClearSDODataSet(self):

   277

        """

   278

        Clear the specified SDO entry information.

   279

        """

   280

        for dummy in range(6):

   281

            self.SaveSDOData.append([])

   282

   283

    # -------------------------------------------------------------------------------

   284

    #                        Used PDO Monitoring

   285

    # -------------------------------------------------------------------------------

   286

    def RequestPDOInfo(self):

   287

        """

   288

        Load slave information from RootClass (XML data) and parse the information (calling SlavePDOData() method).

   289

        """

   290

        # Load slave information from ESI XML file (def EthercatMaster.py)

   291

        slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())

   292

   293

        type_infos = slave.getType()

   294

        device, _alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)

   295

        # Initialize PDO data set

   296

        self.ClearDataSet()

   297

   298

        # if 'device' object is valid, call SavePDOData() to parse PDO data

   299

        if device is not None:

   300

            self.SavePDOData(device)

   301

   302

    def SavePDOData(self, device):

   303

        """

   304

        Parse PDO data and store the results in TXPDOCategory and RXPDOCategory

   305

        Tx(Rx)PDOCategory : index, name, entry number

   306

        Tx(Rx)Info : entry index, sub index, name, length, type

   307

        @param device : Slave information extracted from ESI XML file

   308

        """

   309

        # Parsing TXPDO entries

   310

        for pdo, _pdo_info in ([(pdo, "Inputs") for pdo in device.getTxPdo()]):

   311

            # Save pdo_index, entry, and name of each entry

   312

            pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

   313

            entries = pdo.getEntry()

   314

            pdo_name = ExtractName(pdo.getName())

   315

   316

            # Initialize entry number count

   317

            count = 0

   318

   319

            # Parse entries

   320

            for entry in entries:

   321

                # Save index and subindex

   322

                index = ExtractHexDecValue(entry.getIndex().getcontent())

   323

                subindex = ExtractHexDecValue(entry.getSubIndex())

   324

                # if entry name exists, save entry data

   325

                if ExtractName(entry.getName()) is not None:

   326

                    entry_infos = {

   327

                        "entry_index": index,

   328

                        "subindex": subindex,

   329

                        "name": ExtractName(entry.getName()),

   330

                        "bitlen": entry.getBitLen(),

   331

                        "type": entry.getDataType().getcontent()

   332

                    }

   333

                    self.TxPDOInfo.append(entry_infos)

   334

                    count += 1

   335

   336

            categorys = {"pdo_index": pdo_index, "name": pdo_name, "number_of_entry": count}

   337

            self.TxPDOCategory.append(categorys)

   338

   339

        # Parsing RxPDO entries

   340

        for pdo, _pdo_info in ([(rxpdo, "Outputs") for rxpdo in device.getRxPdo()]):

   341

            # Save pdo_index, entry, and name of each entry

   342

            pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())

   343

            entries = pdo.getEntry()

   344

            pdo_name = ExtractName(pdo.getName())

   345

   346

            # Initialize entry number count

   347

            count = 0

   348

   349

            # Parse entries

   350

            for entry in entries:

   351

                # Save index and subindex

   352

                index = ExtractHexDecValue(entry.getIndex().getcontent())

   353

                subindex = ExtractHexDecValue(entry.getSubIndex())

   354

                # if entry name exists, save entry data

   355

                if ExtractName(entry.getName()) is not None:

   356

                    entry_infos = {

   357

                        "entry_index": index,

   358

                        "subindex": subindex,

   359

                        "name": ExtractName(entry.getName()),

   360

                        "bitlen": str(entry.getBitLen()),

   361

                        "type": entry.getDataType().getcontent()

   362

                    }

   363

                    self.RxPDOInfo.append(entry_infos)

   364

                    count += 1

   365

   366

            categorys = {"pdo_index": pdo_index, "name": pdo_name, "number_of_entry": count}

   367

            self.RxPDOCategory.append(categorys)

   368

   369

    def GetTxPDOCategory(self):

   370

        """

   371

        Get TxPDOCategory data structure (Meta informaton of TxPDO).

   372

        TxPDOCategorys : index, name, number of entries

   373

        @return TxPDOCategorys

   374

        """

   375

        return self.TxPDOCategory

   376

   377

    def GetRxPDOCategory(self):

   378

        """

   379

        Get RxPDOCategory data structure (Meta information of RxPDO).

   380

        RxPDOCategorys : index, name, number of entries

   381

        @return RxPDOCategorys

   382

        """

   383

        return self.RxPDOCategory

   384

   385

    def GetTxPDOInfo(self):

   386

        """

   387

        Get TxPDOInfo data structure (Detailed information on TxPDO entries).

   388

        TxPDOInfos : entry index, sub index, name, length, type

   389

        @return TxPDOInfos

   390

        """

   391

        return self.TxPDOInfo

   392

   393

    def GetRxPDOInfo(self):

   394

        """

   395

        Get RxPDOInfo data structure (Detailed information on RxPDO entries).

   396

        RxPDOInfos : entry index, sub index, name, length, type

   397

        @return RxPDOInfos

   398

        """

   399

        return self.RxPDOInfo

   400

   401

    def ClearDataSet(self):

   402

        """

   403

        Initialize PDO management data structure.

   404

        """

   405

        self.TxPDOInfos = []

   406

        self.TxPDOCategorys = []

   407

        self.RxPDOInfos = []

   408

        self.RxPDOCategorys = []

   409

   410

    # -------------------------------------------------------------------------------

   411

    #                        Used EEPROM Management

   412

    # -------------------------------------------------------------------------------

   413

    # Base data types in ETG2000; format = {"Name": "BitSize"}

   414

    BaseDataTypeDict = {"BOOL": "01",

   415

                        "SINT": "02",

   416

                        "INT": "03",

   417

                        "DINT": "04",

   418

                        "USINT": "05",

   419

                        "UINT": "06",

   420

                        "UDINT": "07",

   421

                        "REAL": "08",

   422

                        "INT24": "10",

   423

                        "LREAL": "11",

   424

                        "INT40": "12",

   425

                        "INT48": "13",

   426

                        "INT56": "14",

   427

                        "LINT": "15",

   428

                        "UINT24": "16",

   429

                        "UINT40": "18",

   430

                        "UINT48": "19",

   431

                        "UINT56": "1a",

   432

                        "ULINT": "1b",

   433

                        "BITARR8": "2d",

   434

                        "BITARR16": "2e",

   435

                        "BITARR32": "2f",

   436

                        "BIT1": "30",

   437

                        "BIT2": "31",

   438

                        "BIT3": "32",

   439

                        "BIT4": "33",

   440

                        "BIT5": "34",

   441

                        "BIT6": "35",

   442

                        "BIT7": "36",

   443

                        "BIT8": "37"}

   444

   445

    def GetSmartViewInfos(self):

   446

        """

   447

        Parse XML data for "Smart View" of EEPROM contents.

   448

        @return smartview_infos : EEPROM contents dictionary

   449

        """

   450

   451

        smartview_infos = {"eeprom_size": 128,

   452

                           "pdi_type": 0,

   453

                           "device_emulation": "False",

   454

                           "vendor_id": '0x00000000',

   455

                           "product_code": '0x00000000',

   456

                           "revision_no": '0x00000000',

   457

                           "serial_no": '0x00000000',

   458

                           "supported_mailbox": "",

   459

                           "mailbox_bootstrapconf_outstart": '0',

   460

                           "mailbox_bootstrapconf_outlength": '0',

   461

                           "mailbox_bootstrapconf_instart": '0',

   462

                           "mailbox_bootstrapconf_inlength": '0',

   463

                           "mailbox_standardconf_outstart": '0',

   464

                           "mailbox_standardconf_outlength": '0',

   465

                           "mailbox_standardconf_instart": '0',

   466

                           "mailbox_standardconf_inlength": '0'}

   467

   468

        slave = self.Controler.CTNParent.GetSlave(self.Controler.GetSlavePos())

   469

        type_infos = slave.getType()

   470

        device, _alignment = self.Controler.CTNParent.GetModuleInfos(type_infos)

   471

   472

        # 'device' represents current slave device selected by user

   473

        if device is not None:

   474

            for eeprom_element in device.getEeprom().getcontent():

   475

                # get EEPROM size; <Device>-<Eeprom>-<ByteSize>

   476

                if eeprom_element["name"] == "ByteSize":

   477

                    smartview_infos["eeprom_size"] = eeprom_element

   478

   479

                elif eeprom_element["name"] == "ConfigData":

   480

                    configData_data = self.DecimalToHex(eeprom_element)

   481

                    # get PDI type; <Device>-<Eeprom>-<ConfigData> address 0x00

   482

                    smartview_infos["pdi_type"] = int(configData_data[0:2], 16)

   483

                    # get state of device emulation; <Device>-<Eeprom>-<ConfigData> address 0x01

   484

                    if "{:0>8b}".format(int(configData_data[2:4], 16))[7] == '1':