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

import wx

    12

    13

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

    14

    15

    16

def ExtractHexDecValue(value):

    17

    """

    18

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

    19

     @param value : hex or decimal data

    20

     @return integer data

    21

    """

    22

    try:

    23

        return int(value)

    24

    except Exception:

    25

        pass

    26

    try:

    27

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

    28

    29

    except Exception:

    30

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

    31

    32

    33

def ExtractName(names, default=None):

    34

    """

    35

     Extract "name" field from XML entries.

    36

     @param names : XML entry

    37

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

    38

     @return default or the name extracted

    39

    """

    40

    if len(names) == 1:

    41

        return names[0].getcontent()

    42

    else:

    43

        for name in names:

    44

            if name.getLcId() == 1033:

    45

                return name.getcontent()

    46

    return default

    47

    48

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

    49

#         Remote Exec Etherlab Commands

    50

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

    51

    52

    53

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

    54

MASTER_STATE = """

    55

import commands

    56

result = commands.getoutput("ethercat master")

    57

returnVal =result

    58

"""

    59

    60

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

    61

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

    62

SLAVE_STATE = """

    63

import commands

    64

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

    65

returnVal = result

    66

"""

    67

    68

# ethercat slave

    69

GET_SLAVE = """

    70

import commands

    71

result = commands.getoutput("ethercat slaves")

    72

returnVal =result

    73

"""

    74

    75

# ethercat xml -p (slave position)

    76

SLAVE_XML = """

    77

import commands

    78

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

    79

returnVal = result

    80

"""

    81

    82

# ethercat sdos -p (slave position)

    83

SLAVE_SDO = """

    84

import commands

    85

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

    86

returnVal =result

    87

"""

    88

    89

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

    90

GET_SLOW_SDO = """

    91

import commands

    92

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

    93

returnVal =result

    94

"""

    95

    96

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

    97

SDO_DOWNLOAD = """

    98

import commands

    99

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

   100

returnVal =result

   101

"""

   102

   103

# ethercat sii_read -p (slave position)

   104

SII_READ = """

   105

import commands

   106

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

   107

returnVal =result

   108

"""

   109

   110

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

   111

REG_READ = """

   112

import commands

   113

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

   114

returnVal =result

   115

"""

   116

   117

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

   118

SII_WRITE = """

   119

import subprocess

   120

process = subprocess.Popen(

   121

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

   122

    stdin=subprocess.PIPE)

   123

process.communicate(sii_data)

   124

returnVal = process.returncode

   125

"""

   126

   127

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

   128

REG_WRITE = """

   129

import commands

   130

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

   131

returnVal =result

   132

"""

   133

   134

# ethercat rescan -p (slave position)

   135

RESCAN = """

   136

import commands

   137

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

   138

returnVal =result

   139

"""

   140

   141

   142

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

   143

#    Common Method For EtherCAT Management

   144

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

   145

class _CommonSlave(object):

   146

   147

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

   148

    SlaveState = ""

   149

   150

    # category of SDO data

   151

    DatatypeDescription, CommunicationObject, ManufacturerSpecific, \

   152

        ProfileSpecific, Reserved, AllSDOData = range(6)

   153

   154

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

   155

    SaveSDOData = []

   156

   157

    # Flags for checking "write" permission of OD entries

   158

    CheckPREOP = False

   159

    CheckSAFEOP = False

   160

    CheckOP = False

   161

   162

    # Save PDO Data

   163

    TxPDOInfo = []

   164

    TxPDOCategory = []

   165

    RxPDOInfo = []

   166

    RxPDOCategory = []

   167

   168

    # Save EEPROM Data

   169

    SiiData = ""

   170

   171

    # Save Register Data

   172

    RegData = ""

   173

    CrtRegSpec = {"ESCType": "",

   174

                  "FMMUNumber": "",

   175

                  "SMNumber": "",

   176

                  "PDIType": ""}

   177

   178

    def __init__(self, controler):

   179

        """

   180

        Constructor

   181

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   182

        """

   183

        self.Controler = controler

   184

   185

        self.ClearSDODataSet()

   186

   187

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

   188

    #                        Used Master State

   189

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

   190

    def GetMasterState(self):

   191

        """

   192

        Execute "ethercat master" command and parse the execution result

   193

        @return MasterState

   194

        """

   195

   196

        # exectute "ethercat master" command

   197

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

   198

        master_state = {}

   199

        # parse the reslut

   200

        for each_line in return_val.splitlines():

   201

            if len(each_line) > 0:

   202

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

   203

                key = chunks[0]

   204

                value = []

   205

                if len(chunks) > 1:

   206

                    value = chunks[1].split()

   207

                if '(attached)' in value:

   208

                    value.remove('(attached)')

   209

                master_state[key] = value

   210

   211

        return master_state

   212

   213

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

   214

    #                        Used Slave State

   215

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

   216

    def RequestSlaveState(self, command):

   217

        """

   218

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

   219

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

   220

        @param command : target slave state

   221

        """

   222

        error, return_val = self.Controler.RemoteExec(SLAVE_STATE % (self.Controler.GetSlavePos(), command), return_val=None)

   223

   224

    def GetSlaveStateFromSlave(self):

   225

        """

   226

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

   227

        (self.SlaveState) for "Slave State"

   228

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

   229

        """

   230

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

   231

        self.SlaveState = return_val

   232

        return return_val

   233

   234

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

   235

    #                        Used SDO Management

   236

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

   237

    def GetSlaveSDOFromSlave(self):

   238

        """

   239

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

   240

        Command example : "ethercat sdos -p 0"

   241

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

   242

        """

   243

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

   244

        return return_val

   245

   246

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

   247

        """

   248

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

   249

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

   250

        @param data_type : data type of SDO entry

   251

        @param idx : index of the SDO entry

   252

        @param sub_idx : subindex of the SDO entry

   253

        @param value : value of SDO entry

   254

        """

   255

        error, return_val = self.Controler.RemoteExec(SDO_DOWNLOAD % (data_type, self.Controler.GetSlavePos(), idx, sub_idx, value), return_val=None)

   256

   257

    def BackupSDODataSet(self):

   258

        """

   259

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

   260

        in case that the user cancels SDO update operation.

   261

        """

   262

        self.BackupDatatypeDescription = self.SaveDatatypeDescription

   263

        self.BackupCommunicationObject = self.SaveCommunicationObject

   264

        self.BackupManufacturerSpecific = self.SaveManufacturerSpecific

   265

        self.BackupProfileSpecific = self.SaveProfileSpecific

   266

        self.BackupReserved = self.SaveReserved

   267

        self.BackupAllSDOData = self.SaveAllSDOData

   268

   269

    def ClearSDODataSet(self):

   270

        """

   271

        Clear the specified SDO entry information.

   272

        """

   273

        for count in range(6):

   274

            self.SaveSDOData.append([])

   275

   276

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

   277

    #                        Used PDO Monitoring

   278

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

   279

    def RequestPDOInfo(self):

   280

        """

   281

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

   282

        """

   283

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

   284

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

   285

   286

        type_infos = slave.getType()

   287

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

   288

        # Initialize PDO data set

   289

        self.ClearDataSet()

   290

   291

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

   292

        if device is not None:

   293

            self.SavePDOData(device)

   294

   295

    def SavePDOData(self, device):

   296

        """

   297

        Parse PDO data and store the results in TXPDOCategory and RXPDOCategory

   298

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

   299

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

   300

        @param device : Slave information extracted from ESI XML file

   301

        """

   302

        # Parsing TXPDO entries

   303

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

   304

            # Save pdo_index, entry, and name of each entry

   305

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

   306

            entries = pdo.getEntry()

   307

            pdo_name = ExtractName(pdo.getName())

   308

   309

            # Initialize entry number count

   310

            count = 0

   311

   312

            # Parse entries

   313

            for entry in entries:

   314

                # Save index and subindex

   315

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

   316

                subindex = ExtractHexDecValue(entry.getSubIndex())

   317

                # if entry name exists, save entry data

   318

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

   319

                    entry_infos = {

   320

                                "entry_index": index,

   321

                                "subindex": subindex,

   322

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

   323

                                "bitlen": entry.getBitLen(),

   324

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

   325

                                    }

   326

                    self.TxPDOInfo.append(entry_infos)

   327

                    count += 1

   328

   329

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

   330

            self.TxPDOCategory.append(categorys)

   331

   332

        # Parsing RxPDO entries

   333

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

   334

            # Save pdo_index, entry, and name of each entry

   335

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

   336

            entries = pdo.getEntry()

   337

            pdo_name = ExtractName(pdo.getName())

   338

   339

            # Initialize entry number count

   340

            count = 0

   341

   342

            # Parse entries

   343

            for entry in entries:

   344

                # Save index and subindex

   345

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

   346

                subindex = ExtractHexDecValue(entry.getSubIndex())

   347

                # if entry name exists, save entry data

   348

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

   349

                    entry_infos = {

   350

                                "entry_index": index,

   351

                                "subindex": subindex,

   352

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

   353

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

   354

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

   355

                                    }

   356

                    self.RxPDOInfo.append(entry_infos)

   357

                    count += 1

   358

   359

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

   360

            self.RxPDOCategory.append(categorys)

   361

   362

    def GetTxPDOCategory(self):

   363

        """

   364

        Get TxPDOCategory data structure (Meta informaton of TxPDO).

   365

        TxPDOCategorys : index, name, number of entries

   366

        @return TxPDOCategorys

   367

        """

   368

        return self.TxPDOCategory

   369

   370

    def GetRxPDOCategory(self):

   371

        """

   372

        Get RxPDOCategory data structure (Meta information of RxPDO).

   373

        RxPDOCategorys : index, name, number of entries

   374

        @return RxPDOCategorys

   375

        """

   376

        return self.RxPDOCategory

   377

   378

    def GetTxPDOInfo(self):

   379

        """

   380

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

   381

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

   382

        @return TxPDOInfos

   383

        """

   384

        return self.TxPDOInfo

   385

   386

    def GetRxPDOInfo(self):

   387

        """

   388

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

   389

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

   390

        @return RxPDOInfos

   391

        """

   392

        return self.RxPDOInfo

   393

   394

    def ClearDataSet(self):

   395

        """

   396

        Initialize PDO management data structure.

   397

        """

   398

        self.TxPDOInfos = []

   399

        self.TxPDOCategorys = []

   400

        self.RxPDOInfos = []

   401

        self.RxPDOCategorys = []

   402

   403

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

   404

    #                        Used EEPROM Management

   405

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

   406

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

   407

    BaseDataTypeDict = {"BOOL": "01",

   408

                        "SINT": "02",

   409

                        "INT": "03",

   410

                        "DINT": "04",

   411

                        "USINT": "05",

   412

                        "UINT": "06",

   413

                        "UDINT": "07",

   414

                        "REAL": "08",

   415

                        "INT24": "10",

   416

                        "LREAL": "11",

   417

                        "INT40": "12",

   418

                        "INT48": "13",

   419

                        "INT56": "14",

   420

                        "LINT": "15",

   421

                        "UINT24": "16",

   422

                        "UINT40": "18",

   423

                        "UINT48": "19",

   424

                        "UINT56": "1a",

   425

                        "ULINT": "1b",

   426

                        "USINT": "1e",

   427

                        "BITARR8": "2d",

   428

                        "BITARR16": "2e",

   429

                        "BITARR32": "2f",

   430

                        "BIT1": "30",

   431

                        "BIT2": "31",

   432

                        "BIT3": "32",

   433

                        "BIT4": "33",

   434

                        "BIT5": "34",

   435

                        "BIT6": "35",

   436

                        "BIT7": "36",

   437

                        "BIT8": "37"}

   438

   439

    def GetSmartViewInfos(self):

   440

        """

   441

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

   442

        @return smartview_infos : EEPROM contents dictionary

   443

        """

   444

   445

        smartview_infos = {"eeprom_size": 128,

   446

                           "pdi_type": 0,

   447

                           "device_emulation": "False",

   448

                           "vendor_id": '0x00000000',

   449

                           "product_code": '0x00000000',

   450

                           "revision_no": '0x00000000',

   451

                           "serial_no": '0x00000000',

   452

                           "supported_mailbox": "",

   453

                           "mailbox_bootstrapconf_outstart": '0',

   454

                           "mailbox_bootstrapconf_outlength": '0',

   455

                           "mailbox_bootstrapconf_instart": '0',

   456

                           "mailbox_bootstrapconf_inlength": '0',

   457

                           "mailbox_standardconf_outstart": '0',

   458

                           "mailbox_standardconf_outlength": '0',

   459

                           "mailbox_standardconf_instart": '0',

   460

                           "mailbox_standardconf_inlength": '0'}

   461

   462

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

   463

        type_infos = slave.getType()

   464

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

   465

   466

        # 'device' represents current slave device selected by user

   467

        if device is not None:

   468

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

   469

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

   470

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

   471

                    smartview_infos["eeprom_size"] = eeprom_element

   472

   473

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

   474

                    configData_data = self.DecimalToHex(eeprom_element)

   475

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

   476

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

   477

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

   478

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

   479

                        smartview_infos["device_emulation"] = "True"

   480

   481

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

   482

                    bootstrap_data = "{:0>16x}".format(eeprom_element)

   483

                    # get bootstrap configuration; <Device>-<Eeprom>-<BootStrap>

   484

                    for cfg, iter in [("mailbox_bootstrapconf_outstart", 0),

   485

                                      ("mailbox_bootstrapconf_outlength", 1),