1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of Beremiz, an Integrated Development Environment for

     5

#programming IEC 61131-3 automates supporting EtherCAT. 

     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

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

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

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

    26

import os

    27

import wx

    28

    29

def ExtractHexDecValue(value):

    30

    """

    31

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

    32

     @param value : hex or decimal data

    33

     @return integer data

    34

    """

    35

    try:

    36

        return int(value)

    37

    except:

    38

        pass

    39

    try:

    40

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

    41

    42

    except:

    43

        raise ValueError, "Invalid value for HexDecValue \"%s\"" % value

    44

    45

def ExtractName(names, default=None):

    46

    """

    47

     Extract "name" field from XML entries.

    48

     @param names : XML entry

    49

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

    50

     @return default or the name extracted

    51

    """

    52

    if len(names) == 1:

    53

        return names[0].getcontent()

    54

    else:

    55

        for name in names:

    56

            if name.getLcId() == 1033:

    57

                return name.getcontent()

    58

    return default

    59

    60

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

    61

#         Remote Exec Etherlab Commands

    62

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

    63

    64

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

    65

MASTER_STATE = """

    66

import commands

    67

result = commands.getoutput("ethercat master")

    68

returnVal =result 

    69

"""

    70

    71

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

    72

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

    73

SLAVE_STATE = """

    74

import commands

    75

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

    76

returnVal = result 

    77

"""

    78

    79

# ethercat slave

    80

GET_SLAVE = """

    81

import commands

    82

result = commands.getoutput("ethercat slaves")

    83

returnVal =result 

    84

"""

    85

    86

# ethercat xml -p (slave position)

    87

SLAVE_XML = """

    88

import commands

    89

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

    90

returnVal = result 

    91

"""

    92

    93

# ethercat sdos -p (slave position)

    94

SLAVE_SDO = """

    95

import commands

    96

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

    97

returnVal =result 

    98

"""

    99

   100

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

   101

GET_SLOW_SDO = """

   102

import commands

   103

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

   104

returnVal =result 

   105

"""

   106

   107

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

   108

SDO_DOWNLOAD = """

   109

import commands

   110

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

   111

returnVal =result 

   112

"""

   113

   114

# ethercat sii_read -p (slave position)

   115

SII_READ = """

   116

import commands

   117

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

   118

returnVal =result 

   119

"""

   120

   121

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

   122

REG_READ = """

   123

import commands

   124

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

   125

returnVal =result 

   126

"""

   127

   128

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

   129

SII_WRITE = """ 

   130

import subprocess 

   131

process = subprocess.Popen(

   132

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

   133

    stdin=subprocess.PIPE)

   134

process.communicate(sii_data)

   135

returnVal = process.returncode 

   136

"""

   137

   138

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

   139

REG_WRITE = """ 

   140

import commands

   141

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

   142

returnVal =result 

   143

""" 

   144

   145

# ethercat rescan -p (slave position)

   146

RESCAN = """ 

   147

import commands

   148

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

   149

returnVal =result 

   150

"""

   151

   152

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

   153

#    Common Method For EtherCAT Management 

   154

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

   155

class _CommonSlave:

   156

   157

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

   158

    SlaveState = ""

   159

   160

    # category of SDO data

   161

    DatatypeDescription, CommunicationObject, ManufacturerSpecific, \

   162

    ProfileSpecific, Reserved, AllSDOData = range(6)

   163

   164

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

   165

    SaveSDOData = []

   166

   167

    # Flags for checking "write" permission of OD entries 

   168

    CheckPREOP = False

   169

    CheckSAFEOP = False

   170

    CheckOP = False

   171

   172

    # Save PDO Data

   173

    TxPDOInfo = []

   174

    TxPDOCategory = []

   175

    RxPDOInfo = []

   176

    RxPDOCategory = []

   177

   178

    # Save EEPROM Data

   179

    SiiData = ""

   180

   181

    # Save Register Data

   182

    RegData = ""

   183

    CrtRegSpec = {"ESCType": "",

   184

                  "FMMUNumber": "",

   185

                  "SMNumber": "",

   186

                  "PDIType": ""}

   187

   188

    def __init__(self, controler):

   189

        """

   190

        Constructor

   191

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   192

        """

   193

        self.Controler = controler

   194

   195

        self.ClearSDODataSet()

   196

   197

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

   198

    #                        Used Master State

   199

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

   200

    def GetMasterState(self):

   201

        """

   202

        Execute "ethercat master" command and parse the execution result

   203

        @return MasterState 

   204

        """

   205

   206

        # exectute "ethercat master" command 

   207

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

   208

        master_state = {}

   209

        # parse the reslut

   210

        for each_line in return_val.splitlines():

   211

            if len(each_line) > 0 :

   212

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

   213

                key = chunks[0]

   214

                value = []

   215

                if len(chunks) > 1 :

   216

                    value = chunks[1].split()

   217

                if '(attached)' in value:

   218

                    value.remove('(attached)')

   219

                master_state[key] = value

   220

   221

        return master_state     

   222

   223

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

   224

    #                        Used Slave State

   225

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

   226

    def RequestSlaveState(self, command):

   227

        """

   228

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

   229

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

   230

        @param command : target slave state 

   231

        """

   232

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

   233

   234

    def GetSlaveStateFromSlave(self):  

   235

        """

   236

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

   237

        (self.SlaveState) for "Slave State" 

   238

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

   239

        """ 

   240

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

   241

        self.SlaveState = return_val

   242

        return return_val 

   243

   244

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

   245

    #                        Used SDO Management

   246

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

   247

    def GetSlaveSDOFromSlave(self):

   248

        """

   249

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

   250

        Command example : "ethercat sdos -p 0"

   251

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

   252

        """  

   253

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

   254

        return return_val   

   255

   256

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

   257

        """

   258

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

   259

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

   260

        @param data_type : data type of SDO entry

   261

        @param idx : index of the SDO entry

   262

        @param sub_idx : subindex of the SDO entry

   263

        @param value : value of SDO entry

   264

        """  

   265

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

   266

   267

    def BackupSDODataSet(self):

   268

        """

   269

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

   270

         in case that the user cancels SDO update operation.

   271

    	"""  

   272

        self.BackupDatatypeDescription = self.SaveDatatypeDescription

   273

        self.BackupCommunicationObject = self.SaveCommunicationObject

   274

        self.BackupManufacturerSpecific = self.SaveManufacturerSpecific

   275

        self.BackupProfileSpecific = self.SaveProfileSpecific

   276

        self.BackupReserved = self.SaveReserved

   277

        self.BackupAllSDOData = self.SaveAllSDOData

   278

   279

    def ClearSDODataSet(self):

   280

        """

   281

        Clear the specified SDO entry information.

   282

        """ 

   283

        for count in range(6):

   284

            self.SaveSDOData.append([])

   285

   286

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

   287

    #                        Used PDO Monitoring

   288

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

   289

    def RequestPDOInfo(self):

   290

        """

   291

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

   292

        """ 

   293

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

   294

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

   295

   296

        type_infos = slave.getType()

   297

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

   298

        # Initialize PDO data set

   299

        self.ClearDataSet()

   300

   301

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

   302

        if device is not None :

   303

            self.SavePDOData(device)

   304

   305

    def SavePDOData(self, device):

   306

        """

   307

        Parse PDO data and store the results in TXPDOCategory and RXPDOCategory

   308

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

   309

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

   310

        @param device : Slave information extracted from ESI XML file

   311

        """ 

   312

        # Parsing TXPDO entries

   313

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

   314

            # Save pdo_index, entry, and name of each entry

   315

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

   316

            entries = pdo.getEntry()

   317

            pdo_name = ExtractName(pdo.getName())

   318

   319

            # Initialize entry number count

   320

            count = 0

   321

   322

            # Parse entries

   323

            for entry in entries:

   324

                # Save index and subindex

   325

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

   326

                subindex = ExtractHexDecValue(entry.getSubIndex())

   327

                # if entry name exists, save entry data

   328

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

   329

                    entry_infos = {

   330

                                "entry_index" : index,

   331

                                "subindex" : subindex,

   332

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

   333

                                "bitlen" : entry.getBitLen(),

   334

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

   335

                                    }

   336

                    self.TxPDOInfo.append(entry_infos)

   337

                    count += 1

   338

   339

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

   340

            self.TxPDOCategory.append(categorys)

   341

   342

        # Parsing RxPDO entries

   343

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

   344

            # Save pdo_index, entry, and name of each entry

   345

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

   346

            entries = pdo.getEntry()

   347

            pdo_name = ExtractName(pdo.getName())

   348

   349

            # Initialize entry number count

   350

            count = 0          

   351

   352

            # Parse entries          

   353

            for entry in entries:

   354

                # Save index and subindex

   355

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

   356

                subindex = ExtractHexDecValue(entry.getSubIndex())

   357

                # if entry name exists, save entry data

   358

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

   359

                    entry_infos = {

   360

                                "entry_index" : index,

   361

                                "subindex" : subindex,

   362

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

   363

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

   364

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

   365

                                    }

   366

                    self.RxPDOInfo.append(entry_infos)

   367

                    count += 1

   368

   369

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

   370

            self.RxPDOCategory.append(categorys) 

   371

   372

    def GetTxPDOCategory(self):

   373

        """

   374

        Get TxPDOCategory data structure (Meta informaton of TxPDO).

   375

        TxPDOCategorys : index, name, number of entries

   376

        @return TxPDOCategorys

   377

        """ 

   378

        return self.TxPDOCategory

   379

   380

    def GetRxPDOCategory(self):

   381

        """

   382

        Get RxPDOCategory data structure (Meta information of RxPDO).

   383

        RxPDOCategorys : index, name, number of entries

   384

        @return RxPDOCategorys

   385

        """ 

   386

        return self.RxPDOCategory

   387

   388

    def GetTxPDOInfo(self):

   389

        """

   390

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

   391

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

   392

        @return TxPDOInfos

   393

        """ 

   394

        return self.TxPDOInfo

   395

   396

    def GetRxPDOInfo(self):

   397

        """

   398

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

   399

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

   400

        @return RxPDOInfos

   401

        """ 

   402

        return self.RxPDOInfo

   403

   404

    def ClearDataSet(self):

   405

        """

   406

        Initialize PDO management data structure.

   407

        """ 

   408

        self.TxPDOInfos = []

   409

        self.TxPDOCategorys = []

   410

        self.RxPDOInfos = []

   411

        self.RxPDOCategorys = []

   412

   413

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

   414

    #                        Used EEPROM Management

   415

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

   416

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

   417

    BaseDataTypeDict = {"BOOL": "01",

   418

                        "SINT": "02",

   419

                        "INT": "03",

   420

                        "DINT": "04",

   421

                        "USINT": "05",

   422

                        "UINT": "06",

   423

                        "UDINT": "07",

   424

                        "REAL": "08",

   425

                        "INT24": "10",

   426

                        "LREAL": "11",

   427

                        "INT40": "12",

   428

                        "INT48": "13",

   429

                        "INT56": "14",

   430

                        "LINT": "15",

   431

                        "UINT24": "16",

   432

                        "UINT40": "18",

   433

                        "UINT48": "19",

   434

                        "UINT56": "1a",

   435

                        "ULINT": "1b",

   436

                        "USINT": "1e",

   437

                        "BITARR8": "2d",

   438

                        "BITARR16": "2e",

   439

                        "BITARR32": "2f",

   440

                        "BIT1": "30",

   441

                        "BIT2": "31",

   442

                        "BIT3": "32",

   443

                        "BIT4": "33",

   444

                        "BIT5": "34",

   445

                        "BIT6": "35",

   446

                        "BIT7": "36",

   447

                        "BIT8": "37"}        

   448

   449

    def GetSmartViewInfos(self):

   450

        """

   451

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

   452

        @return smartview_infos : EEPROM contents dictionary

   453

        """ 

   454

   455

        smartview_infos = {"eeprom_size": 128,

   456

                           "pdi_type": 0,

   457

                           "device_emulation": "False",

   458

                           "vendor_id": '0x00000000',

   459

                           "product_code": '0x00000000',

   460

                           "revision_no": '0x00000000',

   461

                           "serial_no": '0x00000000',

   462

                           "supported_mailbox": "",

   463

                           "mailbox_bootstrapconf_outstart": '0',

   464

                           "mailbox_bootstrapconf_outlength": '0',

   465

                           "mailbox_bootstrapconf_instart": '0',

   466

                           "mailbox_bootstrapconf_inlength": '0',

   467

                           "mailbox_standardconf_outstart": '0',

   468

                           "mailbox_standardconf_outlength": '0',

   469

                           "mailbox_standardconf_instart": '0',

   470

                           "mailbox_standardconf_inlength": '0'}

   471

   472

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

   473

        type_infos = slave.getType()

   474

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

   475

   476

        # 'device' represents current slave device selected by user

   477

        if device is not None:

   478

            for eeprom_element in device.getEeprom().getcontent()["value"]:

   479

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

   480

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

   481

                    smartview_infos["eeprom_size"] = eeprom_element["value"]

   482

   483

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

   484

                    configData_data = self.DecimalToHex(eeprom_element["value"])

   485

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

   486

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

   487

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

   488

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

   489

                        smartview_infos["device_emulation"] = "True"

   490

   491

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

   492

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

   493

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

   494

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

   495

                                      ("mailbox_bootstrapconf_outlength", 1),

   496

                                      ("mailbox_bootstrapconf_instart", 2),

   497

                                      ("mailbox_bootstrapconf_inlength", 3)]:

   498

                        smartview_infos[cfg] = str(int(bootstrap_data[4*iter+2:4*(iter+1)]+bootstrap_data[4*iter:4*iter+2], 16))

   499

   500

            # get protocol (profile) types supported by mailbox; <Device>-<Mailbox>

   501

            for mailbox_protocol in ["VoE", "SoE", "FoE", "CoE", "EoE", "AoE"]:

   502

                if eval("device.getMailbox().get%s()"%mailbox_protocol) is not None:

   503

                    smartview_infos["supported_mailbox"] += "%s,  "%mailbox_protocol

   504

            smartview_infos["supported_mailbox"] = smartview_infos["supported_mailbox"].strip(",  ")

   505

   506

            # get standard configuration of mailbox; <Device>-<Sm>

   507

            for sm_element in device.getSm():

   508

                if sm_element.getcontent() == "MBoxOut":

   509

                    smartview_infos["mailbox_standardconf_outstart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))

   510

                    smartview_infos["mailbox_standardconf_outlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))

   511

                elif sm_element.getcontent() == "MBoxIn":

   512

                    smartview_infos["mailbox_standardconf_instart"] = str(ExtractHexDecValue(sm_element.getStartAddress()))

   513

                    smartview_infos["mailbox_standardconf_inlength"] = str(ExtractHexDecValue(sm_element.getDefaultSize()))

   514

                else:

   515

                    pass

   516

   517

            # get device identity from <Device>-<Type>

   518

            #  vendor ID; by default, pre-defined value in self.ModulesLibrary

   519

            #             if device type in 'vendor' item equals to actual slave device type, set 'vendor_id' to vendor ID.

   520

            for vendor_id, vendor in self.Controler.CTNParent.CTNParent.ModulesLibrary.Library.iteritems():

   521

                for available_device in vendor["groups"][vendor["groups"].keys()[0]]["devices"]:

   522

                    if available_device[0] == type_infos["device_type"]:

   523

                        smartview_infos["vendor_id"] = "0x" + "{:0>8x}".format(vendor_id)

   524

   525

            #  product code; 

   526

            if device.getType().getProductCode() is not None:

   527

                product_code = device.getType().getProductCode()

   528

                smartview_infos["product_code"] = "0x"+"{:0>8x}".format(ExtractHexDecValue(product_code))

   529

   530