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

    12

from __future__ import division

    13

from builtins import str as text

    14

import codecs

    15

import wx

    16

    17

    18

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

    19

    20

    21

def ExtractHexDecValue(value):

    22

    """

    23

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

    24

     @param value : hex or decimal data

    25

     @return integer data

    26

    """

    27

    try:

    28

        return int(value)

    29

    except Exception:

    30

        pass

    31

    try:

    32

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

    33

    34

    except Exception:

    35

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

    36

    37

    38

def ExtractName(names, default=None):

    39

    """

    40

     Extract "name" field from XML entries.

    41

     @param names : XML entry

    42

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

    43

     @return default or the name extracted

    44

    """

    45

    if len(names) == 1:

    46

        return names[0].getcontent()

    47

    else:

    48

        for name in names:

    49

            if name.getLcId() == 1033:

    50

                return name.getcontent()

    51

    return default

    52

    53

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

    54

#         Remote Exec Etherlab Commands

    55

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

    56

    57

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

    58

MASTER_STATE = """

    59

import commands

    60

result = commands.getoutput("ethercat master")

    61

returnVal =result

    62

"""

    63

    64

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

    65

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

    66

SLAVE_STATE = """

    67

import commands

    68

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

    69

returnVal = result

    70

"""

    71

    72

# ethercat slave

    73

GET_SLAVE = """

    74

import commands

    75

result = commands.getoutput("ethercat slaves")

    76

returnVal =result

    77

"""

    78

    79

# ethercat xml -p (slave position)

    80

SLAVE_XML = """

    81

import commands

    82

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

    83

returnVal = result

    84

"""

    85

    86

# ethercat upload -p (slave position) -t (type) (index) (sub index)

    87

SDO_UPLOAD = """

    88

import commands

    89

sdo_data = []

    90

input_data = "%s"

    91

slave_pos = %d

    92

command_string = ""

    93

for sdo_token in input_data.split(","):  

    94

    if len(sdo_token) > 1:

    95

        sdo_token = sdo_token.strip()

    96

        type, idx, subidx = sdo_token.split(" ")

    97

        command_string = "ethercat upload -p " + str(slave_pos) + " -t " + type + " " + idx + " " + subidx

    98

        result = commands.getoutput(command_string)

    99

        sdo_data.append(result)

   100

returnVal =sdo_data

   101

"""

   102

   103

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

   104

SDO_DOWNLOAD = """

   105

import commands

   106

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

   107

returnVal =result

   108

"""

   109

   110

# ethercat sii_read -p (slave position)

   111

SII_READ = """

   112

import commands

   113

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

   114

returnVal =result

   115

"""

   116

   117

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

   118

REG_READ = """

   119

import commands

   120

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

   121

returnVal =result

   122

"""

   123

   124

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

   125

MULTI_REG_READ = """ 

   126

import commands

   127

output = []

   128

addr, size = range(2)

   129

slave_num = %d 

   130

reg_info_str = "%s"

   131

reg_info_list = reg_info_str.split("|")

   132

for slave_idx in range(slave_num):

   133

    for reg_info in reg_info_list:

   134

        param = reg_info.split(",")

   135

        result = commands.getoutput("ethercat reg_read -p "

   136

                                    + str(slave_idx) + " "

   137

                                    + param[addr] + " "

   138

                                    + param[size])

   139

        output.append(str(slave_idx) + "," + param[addr] + "," + result)

   140

returnVal = output

   141

"""

   142

   143

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

   144

SII_WRITE = """

   145

import subprocess

   146

process = subprocess.Popen(

   147

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

   148

    stdin=subprocess.PIPE)

   149

process.communicate(sii_data)

   150

returnVal = process.returncode

   151

"""

   152

   153

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

   154

REG_WRITE = """

   155

import commands

   156

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

   157

returnVal =result

   158

"""

   159

   160

# ethercat rescan -p (slave position)

   161

RESCAN = """

   162

import commands

   163

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

   164

returnVal =result

   165

"""

   166

   167

# ethercat pdos

   168

PDOS = """

   169

import commands

   170

result = commands.getoutput("ethercat pdos -p 0")

   171

returnVal =result  

   172

"""

   173

   174

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

   175

#    Common Method For EtherCAT Management

   176

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

   177

class _CommonSlave(object):

   178

   179

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

   180

    SlaveState = ""

   181

   182

    # SDO base data type for Ethercatmaster

   183

    BaseDataTypes = {

   184

            "bool": ["BOOLEAN", "BOOL", "BIT"],

   185

            "uint8": ["BYTE", "USINT", "BIT1", "BIT2", "BIT3", "BIT4", "BIT5", "BIT6",

   186

                      "BIT7", "BIT8", "BITARR8", "UNSIGNED8"],

   187

            "uint16": ["BITARR16", "UNSIGNED16", "UINT"],

   188

            "uint32": ["BITARR32", "UNSIGNED24", "UINT24", "UNSIGNED32", "UDINT"],

   189

            "uint64": ["UNSINED40", "UINT40", "UNSIGNED48", "UINT48", "UNSIGNED56", 

   190

                       "UINT56", "UNSIGNED64", "ULINT"],

   191

            "int8": ["INTEGER8", "SINT"],

   192

            "int16": ["INTEGER16", "INT"],

   193

            "int32": ["INTEGER24", "INT24", "INTEGER32", "DINT"],

   194

            "int64": ["INTEGER40", "INT40", "INTEGER48", "INT48", "INTEGER56", "INT56",

   195

                      "INTEGER64", "LINT"],

   196

            "float": ["REAL", "REAL32"],

   197

            "double": ["LREAL", "REAL64"],

   198

            "string": ["VISUBLE_STRING", "STRING(n)"],

   199

            "octet_string": ["OCTET_STRING"],

   200

            "unicode_string": ["UNICODE_STRING"]

   201

            }

   202

   203

    # category of SDO data

   204

    DatatypeDescription, CommunicationObject, ManufacturerSpecific, \

   205

        ProfileSpecific, Reserved, AllSDOData = range(6)

   206

   207

    # SDO data informations: index, sub-index, type, bit size, category-name 

   208

    SDOVariables = []

   209

    SDOSubEntryData = []

   210

   211

    # defalut value of SDO data in XML

   212

    # Not Used

   213

    DefaultValueDic = {}

   214

   215

    # Flags for checking "write" permission of OD entries 

   216

    CheckPREOP = False

   217

    CheckSAFEOP = False

   218

    CheckOP = False

   219

   220

    # Save PDO Data

   221

    TxPDOInfo = []

   222

    TxPDOCategory = []

   223

    RxPDOInfo = []

   224

    RxPDOCategory = []

   225

   226

    # Save EEPROM Data

   227

    SiiData = ""

   228

   229

    # Save Register Data

   230

    RegData = ""

   231

    CrtRegSpec = {"ESCType": "",

   232

                  "FMMUNumber": "",

   233

                  "SMNumber": "",

   234

                  "PDIType": ""}

   235

   236

    def __init__(self, controler):

   237

        """

   238

        Constructor

   239

        @param controler: _EthercatSlaveCTN class in EthercatSlave.py

   240

        """

   241

        self.Controler = controler

   242

        self.HexDecode = codecs.getdecoder("hex_codec")

   243

        self.ClearSDODataSet()

   244

   245

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

   246

    #                        Used Master State

   247

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

   248

    def GetMasterState(self):

   249

        """

   250

        Execute "ethercat master" command and parse the execution result

   251

        @return MasterState

   252

        """

   253

   254

        # exectute "ethercat master" command

   255

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

   256

        master_state = {}

   257

        # parse the reslut

   258

        for each_line in return_val.splitlines():

   259

            if len(each_line) > 0:

   260

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

   261

                key = chunks[0]

   262

                value = []

   263

                if len(chunks) > 1:

   264

                    value = chunks[1].split()

   265

                if '(attached)' in value:

   266

                    value.remove('(attached)')

   267

                master_state[key] = value

   268

   269

        return master_state

   270

   271

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

   272

    #                        Used Slave State

   273

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

   274

    def RequestSlaveState(self, command):

   275

        """

   276

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

   277

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

   278

        @param command : target slave state

   279

        """

   280

        _error, _return_val = self.Controler.RemoteExec(

   281

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

   282

            return_val=None)

   283

   284

    def GetSlaveStateFromSlave(self):

   285

        """

   286

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

   287

        (self.SlaveState) for "Slave State"

   288

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

   289

        """

   290

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

   291

        self.SlaveState = return_val

   292

        return return_val

   293

   294

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

   295

    #                        Used SDO Management

   296

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

   297

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

   298

        """

   299

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

   300

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

   301

        @param data_type : data type of SDO entry

   302

        @param idx : index of the SDO entry

   303

        @param sub_idx : subindex of the SDO entry

   304

        @param value : value of SDO entry

   305

        """ 

   306

        valid_type = self.GetValidDataType(data_type)

   307

        _error, return_val = self.Controler.RemoteExec(

   308

            SDO_DOWNLOAD%(valid_type, self.Controler.GetSlavePos(),

   309

                idx, sub_idx, value), return_val = None)

   310

   311

        return return_val

   312

   313

    def BackupSDODataSet(self):

   314

        """

   315

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

   316

        in case that the user cancels SDO update operation.

   317

        """

   318

        self.BackupDatatypeDescription = self.SaveDatatypeDescription

   319

        self.BackupCommunicationObject = self.SaveCommunicationObject

   320

        self.BackupManufacturerSpecific = self.SaveManufacturerSpecific

   321

        self.BackupProfileSpecific = self.SaveProfileSpecific

   322

        self.BackupReserved = self.SaveReserved

   323

        self.BackupAllSDOData = self.SaveAllSDOData

   324

   325

    def ClearSDODataSet(self):

   326

        """

   327

        Clear the specified SDO entry information.

   328

        """

   329

        for dummy in range(6):

   330

            self.SaveSDOData.append([])

   331

   332

    def GetAllSDOValuesFromSlave(self):

   333

        """

   334

        Get SDO values of All SDO entries.

   335

        @return return_val: list of result of "SDO_UPLOAD"

   336

        """

   337

        entry_infos = ""

   338

        alldata_idx = len(self.SDOVariables)

   339

        counter = 0

   340

        for category in self.SDOVariables:

   341

            counter +=1

   342

            # for avoid redundant repetition 

   343

            if counter == alldata_idx:

   344

                continue

   345

   346

            for entry in category:

   347

                valid_type = self.GetValidDataType(entry["type"])

   348

                for_command_string = "%s %s %s ," % \

   349

                        (valid_type, entry["idx"], entry["subIdx"])

   350

                entry_infos += for_command_string

   351

   352

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

   353

   354

        return return_val

   355

   356

    def GetSDOValuesFromSlave(self, entries_info):

   357

        """

   358

        Get SDO values of some SDO entries.

   359

        @param entries_info: dictionary of SDO entries that is wanted to know the value. 

   360

        @return return_val: list of result of "SDO_UPLOAD"

   361

        """

   362

        entry_infos = ""

   363

   364

        entries_info_list = entries_info.items()

   365

        entries_info_list.sort()

   366

   367

        for (idx, subIdx), entry in entries_info_list:

   368

            valid_type = self.GetValidDataType(entry["type"])

   369

            for_command_string = "%s %s %s ," % \

   370

                        (valid_type, str(idx), str(subIdx))

   371

            entry_infos += for_command_string

   372

   373

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

   374

   375

        return return_val

   376

   377

    def ExtractObjects(self):

   378

        """

   379

        Extract object type items from imported ESI xml.

   380

        And they are stuctured as dictionary.

   381

        @return objects: dictionary of objects

   382

        """

   383

        objects = {}

   384

   385

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

   386

        type_infos = slave.getType()

   387

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

   388

   389

        if device is not None :

   390

            for dictionary in device.GetProfileDictionaries():

   391

                dictionary.load()

   392

                for object in dictionary.getObjects().getObject():

   393

                    object_index = ExtractHexDecValue(object.getIndex().getcontent())

   394

                    objects[(object_index)] = object

   395

   396

        return objects

   397

   398

    def ExtractAllDataTypes(self):

   399

        """

   400

        Extract all data types from imported ESI xml.

   401

        @return dataTypes: dictionary of datatypes 

   402

        """

   403

        dataTypes = {}

   404

   405

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

   406

        type_infos = slave.getType()

   407

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

   408

   409

        for dictionary in device.GetProfileDictionaries():

   410

            dictionary.load()

   411

   412

            datatypes = dictionary.getDataTypes()

   413

            if datatypes is not None:

   414

   415

                for datatype in datatypes.getDataType():

   416

                    dataTypes[datatype.getName()] = datatype

   417

        return dataTypes

   418

   419

    def IsBaseDataType(self, datatype):

   420

        """

   421

        Check if the datatype is a base data type.

   422

        @return baseTypeFlag: true if datatype is a base data type, unless false

   423

        """

   424

        baseTypeFlag = False

   425

        for baseDataTypeList in self.BaseDataTypes.values():

   426

            if datatype in baseDataTypeList:

   427

                baseTypeFlag = True

   428

                break

   429

        return baseTypeFlag

   430

   431

    def GetBaseDataType(self, datatype):

   432

        """

   433

        Get a base data type corresponding the datatype.

   434

        @param datatype: Some data type (string format)

   435

        @return base data type

   436

        """

   437

        if self.IsBaseDataType(datatype):

   438

            return datatype

   439

        elif not datatype.find("STRING") == -1:

   440

            return datatype

   441

        else:

   442

            datatypes = self.ExtractAllDataTypes()

   443

            base_datatype = datatypes[datatype].getBaseType()

   444

            return self.GetBaseDataType(base_datatype)

   445

   446

    def GetValidDataType(self, datatype):

   447

        """

   448

        Convert the datatype into a data type that is possible to download/upload 

   449

        in etherlab master stack.

   450

        @param datatype: Some data type (string format)

   451

        @return base_type: vaild data type

   452

        """

   453

        base_type = self.GetBaseDataType(datatype)

   454

   455

        if re.match("STRING\([0-9]*\)", datatype) is not None:

   456

            return "string"

   457

        else:

   458

            for key, value in self.BaseDataTypes.items():

   459

                if base_type in value:

   460

                    return key

   461

        return base_type 

   462

   463

    # Not Used 

   464

    def GetAllEntriesList(self):

   465

        """

   466

        Get All entries information that includes index, sub-index, name,

   467

        type, bit size, PDO mapping, and default value.

   468

        @return self.entries: dictionary of entry

   469

        """

   470

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

   471

        type_infos = slave.getType()

   472

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

   473

        self.entries = device.GetEntriesList()

   474

        datatypes = self.ExtractAllDataTypes()

   475

        objects = self.ExtractObjects()