1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

#

     6

# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT

     7

#                          RTES Lab : CRKim, JBLee, youcu

     8

#                          Higen Motor : Donggu Kang

     9

#

    10

# See COPYING file for copyrights details.

    11

    12

from __future__ import absolute_import

    13

import os

    14

import shutil

    15

import csv

    16

from builtins import str as text

    17

    18

from lxml import etree

    19

import wx

    20

    21

from xmlclass import *

    22

    23

from ConfigTreeNode import XSDSchemaErrorMessage

    24

    25

from etherlab.EthercatSlave import ExtractHexDecValue, ExtractName

    26

from etherlab.EthercatMaster import _EthercatCTN

    27

from etherlab.ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    28

    29

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    30

    31

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

    32

#                 Ethercat ConfNode

    33

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

    34

    35

EtherCATInfoParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd"))

    36

    37

    38

def EtherCATInfo_XPath(xpath):

    39

    return etree.XPath(xpath)

    40

    41

    42

EtherCATBaseParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATBase.xsd"))

    43

    44

    45

def EtherCATBase_XPath(xpath):

    46

    return etree.XPath(xpath)

    47

    48

    49

def HexDecValue(context, *args):

    50

    return str(ExtractHexDecValue(args[0][0]))

    51

    52

    53

def EntryName(context, *args):

    54

    return ExtractName(args[0], args[1][0] if len(args) > 1 else None)

    55

    56

    57

ENTRY_INFOS_KEYS = [

    58

    ("Index", lambda x: "#x%4.4X" % int(x), "#x0000"),

    59

    ("SubIndex", str, "0"),

    60

    ("Name", str, ""),

    61

    ("Type", str, ""),

    62

    ("BitSize", int, 0),

    63

    ("Access", str, ""),

    64

    ("PDOMapping", str, ""),

    65

    ("PDO index", str, ""),

    66

    ("PDO name", str, ""),

    67

    ("PDO type", str, "")]

    68

    69

# Read DefaultValue from ESI file

    70

# Add by jblee 151229

    71

ENTRY_INFOS_KEYS_FOR_DV = [

    72

    ("Index", lambda x: "#x%4.4X" % int(x), "#x0000"),

    73

    ("SubIndex", str, "0"),

    74

    ("Name", str, ""),

    75

    ("Type", str, ""),

    76

    ("BitSize", int, 0),

    77

    ("Access", str, ""),

    78

    ("PDOMapping", str, ""),

    79

    ("DefaultValue", str, ""),

    80

    ("Sub_entry_flag", str, "0")]

    81

    82

class EntryListFactory(object):

    83

    84

    def __init__(self, entries):

    85

        self.Entries = entries

    86

    87

    def AddEntry(self, context, *args):

    88

        index, subindex = map(lambda x: int(x[0]), args[:2])

    89

        if len(args) > 9:

    90

		    new_entry_infos = {

    91

            key: translate(arg[0]) if len(arg) > 0 else default

    92

            for (key, translate, default), arg

    93

            in zip(ENTRY_INFOS_KEYS, args)}

    94

        else:

    95

            new_entry_infos = {

    96

            key: translate(arg[0]) if len(arg) > 0 else default

    97

            for (key, translate, default), arg

    98

            in zip(ENTRY_INFOS_KEYS_FOR_DV, args)}			

    99

   100

        if (index, subindex) != (0, 0):

   101

            entry_infos = self.Entries.get((index, subindex))

   102

            if entry_infos is not None:

   103

                for param in ["PDO index", "PDO name", "PDO type"]:

   104

                    value = new_entry_infos.get(param)

   105

                    if value is not None:

   106

                        entry_infos[param] = value

   107

            else:

   108

                self.Entries[(index, subindex)] = new_entry_infos

   109

   110

   111

entries_list_xslt = etree.parse(

   112

    os.path.join(ScriptDirectory, "entries_list.xslt"))

   113

   114

cls = EtherCATInfoParser.GetElementClass("DeviceType")

   115

if cls:

   116

    cls.DataTypes = None

   117

   118

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

   119

   120

    def GetProfileNumbers(self):

   121

        return [number.text for number in profile_numbers_xpath(self)]

   122

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

   123

   124

    def getCoE(self):

   125

        mailbox = self.getMailbox()

   126

        if mailbox is not None:

   127

            return mailbox.getCoE()

   128

        return None

   129

    setattr(cls, "getCoE", getCoE)

   130

   131

    # Modify by jblee

   132

    def ExtractDataTypes(self):

   133

        #self.DataTypes = {}

   134

        #self.DT = {}

   135

        DT = {}

   136

        objects = []

   137

   138

        # get Profile Field

   139

        for profile in self.getProfile():

   140

            # get each (ProfileNo, Dictionary) Field as child

   141

            for child in profile.getchildren():

   142

                # child.text is not None -> ProfileNo, is None -> Dictionary

   143

                if child.text is None:

   144

                    # get each (DataTypes, Objects) Field 

   145

                    dataTypes = child.getDataTypes()

   146

                    objects = child.getObjects()

   147

   148

                    for dataType in dataTypes.getDataType():

   149

                        #if dataType.getName() is not None:

   150

                        #    print dataType.getName(), dataType

   151

                        DT[dataType.getName()] = dataType

   152

   153

        return DT, objects

   154

    setattr(cls, "ExtractDataTypes", ExtractDataTypes)

   155

   156

    def GetEntriesList(self, limits=None):

   157

        DataTypes, objects = self.ExtractDataTypes()

   158

   159

        entries = {}

   160

   161

        # get each Object Field

   162

        for object in objects:

   163

            # Object Field mendatory : Index, Name, Type, BitSize

   164

            # Frequently Use : Info, Flags

   165

            # Info Field -> DefaultData, SubItem

   166

            # Flags Field -> Access, Category, PdoMapping

   167

            object_index = object.getIndex().getcontent()

   168

            index = ExtractHexDecValue(object_index)

   169

            if limits is None or limits[0] <= index <= limits[1]:

   170

                object_type = object.getType()

   171

                object_name = ExtractName(object.getName())

   172

                object_size = object.getBitSize()

   173

                defaultData = ""

   174

                object_access = ""

   175

                object_PDOMapping_data = ""

   176

   177

                object_type_infos = DataTypes.get(object_type, None)

   178

                subItem_infos = object_type_infos.getchildren()

   179

                countSubIndex = 0

   180

                if len(subItem_infos) > 2:

   181

                    for subItem_info in subItem_infos:

   182

                        if subItem_info.tag == "SubItem" : 

   183

                            subItemName = subItem_info.getName()

   184

                            subIdx = subItem_info.getSubIdx()

   185

                            if subIdx is not None:

   186

                                object_subidx = ExtractHexDecValue(subIdx)

   187

                            else:

   188

                                object_subidx = ExtractHexDecValue(countSubIndex)

   189

                            subType = subItem_info.getType()

   190

                            subBitSize = subItem_info.getBitSize()

   191

                            subFlags = subItem_info.getFlags()

   192

                            subAccess = ""

   193

                            subPDOMapping_data = ""

   194

                            if subFlags is not None:

   195

                                subAccess = subFlags.getAccess().getcontent()

   196

                                subPDOMapping = subFlags.getPdoMapping()                                                        

   197

                                if subPDOMapping is not None:

   198

                                    subPDOMapping_data = subFlags.getPdoMapping().upper()

   199

   200

                            entries[(index, object_subidx)] = {

   201

                                "Index": object_index,

   202

                                "SubIndex": subIdx,

   203

                                "Name": "%s - %s" % 

   204

                                    (object_name.decode("utf-8"),

   205

                                     subItemName.decode("utf-8")),

   206

                                "Type": subType,

   207

                                "BitSize": subBitSize,

   208

                                "Access": subAccess, 

   209

                                "PDOMapping": subPDOMapping_data}

   210

   211

                            countSubIndex += 1

   212

   213

                    info = object.getInfo()

   214

                    # subItemTest : check subItem 

   215

                    countSubIndex = 0

   216

                    if info is not None:

   217

                        subItems = info.getchildren()

   218

                        if len(subItems) > 1:

   219

                            for subItem in subItems:

   220

                                defaultdata_subidx = ExtractHexDecValue(countSubIndex)

   221

                                defaultData = subItem.getchildren()[1].findtext("DefaultData")

   222

                                entry = entries.get((index, defaultdata_subidx), None)

   223

                                if entry is not None:

   224

                                    entry["DefaultData"] = defaultData

   225

                                countSubIndex += 1

   226

   227

                else :

   228

                    info = object.getInfo()

   229

                    if info is not None:

   230

                        subItems = info.getchildren()

   231

                        if len(subItems) <= 1:

   232

                            defaultData = subItems[0].text

   233

   234

                    object_flag = object.getFlags()

   235

                    object_access = object_flag.getAccess().getcontent()

   236

                    object_PDOMapping = object_flag.getPdoMapping()

   237

                    if object_PDOMapping is not None:

   238

                        object_PDOMapping_data = object_flag.getPdoMapping().upper()

   239

                    entries[(index, 0)] = {

   240

                        "Index": object_index,

   241

                        "SubIndex": "0",

   242

                        "Name": object_name,                                                               

   243

                        "Type": object_type,

   244

                        "BitSize": object_size,

   245

                        "DefaultData" : defaultData,

   246

                        "Access": object_access, 

   247

                        "PDOMapping": object_PDOMapping_data}

   248

   249

        for TxPdo in self.getTxPdo():

   250

            ExtractPdoInfos(TxPdo, "Transmit", entries, limits)

   251

        for RxPdo in self.getRxPdo():

   252

            ExtractPdoInfos(RxPdo, "Receive", entries, limits)

   253

   254

        return entries

   255

    setattr(cls, "GetEntriesList", GetEntriesList)

   256

   257

#    def GetEntriesList(self, limits=None):

   258

#        entries = {}

   259

   260

#        factory = EntryListFactory(entries)

   261

   262

#        entries_list_xslt_tree = etree.XSLT(

   263

#            entries_list_xslt, extensions = {

   264

#                ("entries_list_ns", "AddEntry"): factory.AddEntry,

   265

#                ("entries_list_ns", "HexDecValue"): HexDecValue,

   266

#                ("entries_list_ns", "EntryName"): EntryName})

   267

#        entries_list_xslt_tree(self, **dict(zip(

   268

#            ["min_index", "max_index"], 

   269

#            map(lambda x: etree.XSLT.strparam(str(x)),

   270

#                limits if limits is not None else [0x0000, 0xFFFF])

   271

#            )))

   272

#        

   273

#        return entries

   274

#    setattr(cls, "GetEntriesList", GetEntriesList)

   275

   276

    def GetSyncManagers(self):

   277

        sync_managers = []

   278

        for sync_manager in self.getSm():

   279

            sync_manager_infos = {}

   280

            for name, value in [("Name", sync_manager.getcontent()),

   281

                                ("Start Address", sync_manager.getStartAddress()),

   282

                                ("Default Size", sync_manager.getDefaultSize()),

   283

                                ("Control Byte", sync_manager.getControlByte()),

   284

                                ("Enable", sync_manager.getEnable())]:

   285

                if value is None:

   286

                    value = ""

   287

                sync_manager_infos[name] = value

   288

            sync_managers.append(sync_manager_infos)

   289

        return sync_managers

   290

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   291

   292

   293

def GroupItemCompare(x, y):

   294

    if x["type"] == y["type"]:

   295

        if x["type"] == ETHERCAT_GROUP:

   296

            return cmp(x["order"], y["order"])

   297

        else:

   298

            return cmp(x["name"], y["name"])

   299

    elif x["type"] == ETHERCAT_GROUP:

   300

        return -1

   301

    return 1

   302

   303

   304

def SortGroupItems(group):

   305

    for item in group["children"]:

   306

        if item["type"] == ETHERCAT_GROUP:

   307

            SortGroupItems(item)

   308

    group["children"].sort(GroupItemCompare)

   309

   310

def ExtractPdoInfos(pdo, pdo_type, entries, limits=None):

   311

    pdo_index = pdo.getIndex().getcontent()

   312

    pdo_name = ExtractName(pdo.getName())

   313

    exclude = pdo.getExclude()

   314

    for pdo_entry in pdo.getEntry():

   315

        entry_index = pdo_entry.getIndex().getcontent()

   316

        entry_subindex = pdo_entry.getSubIndex()

   317

        index = ExtractHexDecValue(entry_index)

   318

        subindex = ExtractHexDecValue(entry_subindex)

   319

        object_size = pdo_entry.getBitLen()

   320

   321

        if limits is None or limits[0] <= index <= limits[1]:

   322

            entry = entries.get((index, subindex), None)

   323

            if entry is not None:

   324

                entry["PDO index"] = pdo_index

   325

                entry["PDO name"] = pdo_name

   326

                entry["PDO type"] = pdo_type

   327

            else:

   328

                entry_type = pdo_entry.getDataType()

   329

                if entry_type is not None:

   330

                    if pdo_type == "Transmit":

   331

                        access = "ro"

   332

                        pdomapping = "T"

   333

                    else:

   334

                        access = "wo"

   335

                        pdomapping = "R"

   336

                    entries[(index, subindex)] = {

   337

                        "Index": entry_index,

   338

                        "SubIndex": entry_subindex,

   339

                        "Name": ExtractName(pdo_entry.getName()),

   340

                        "Type": entry_type.getcontent(),

   341

                        "BitSize": object_size,

   342

                        "Access": access,

   343

                        "PDOMapping": pdomapping}

   344

   345

class ModulesLibrary(object):

   346

   347

    MODULES_EXTRA_PARAMS = [

   348

        (

   349

            "pdo_alignment",

   350

            {

   351

                "column_label": _("PDO alignment"),

   352

                "column_size": 150,

   353

                "default": 8,

   354

                "description": _("Minimal size in bits between 2 pdo entries")

   355

            }

   356

        ),

   357

        (

   358

            "max_pdo_size",

   359

            {

   360

                "column_label": _("Max entries by PDO"),

   361

                "column_size": 150,

   362

                "default": 255,

   363

                "description": _("""Maximal number of entries mapped in a PDO

   364

including empty entries used for PDO alignment""")

   365

            }

   366

        ),

   367

        (

   368

            "add_pdo",

   369

            {

   370

                "column_label": _("Creating new PDO"),

   371

                "column_size": 150,

   372

                "default": 0,

   373

                "description": _("""Adding a PDO not defined in default configuration

   374

for mapping needed location variables

   375

(1 if possible)""")

   376

            }

   377

        )

   378

    ]

   379

   380

    def __init__(self, path, parent_library=None):

   381

        self.Path = path

   382

        if not os.path.exists(self.Path):

   383

            os.makedirs(self.Path)

   384

        self.ParentLibrary = parent_library

   385

   386

        if parent_library is not None:

   387

            self.LoadModules()

   388

        else:

   389

            self.Library = None

   390

        self.LoadModulesExtraParams()

   391

   392

    def GetPath(self):

   393

        return self.Path

   394

   395

    def GetModulesExtraParamsFilePath(self):

   396

        return os.path.join(self.Path, "modules_extra_params.cfg")

   397

   398

    groups_xpath = EtherCATInfo_XPath("Descriptions/Groups/Group")

   399

    devices_xpath = EtherCATInfo_XPath("Descriptions/Devices/Device")

   400

    module_xpath = EtherCATBase_XPath("Descriptions/Modules/Module")

   401

   402

    def LoadModules(self):

   403

        self.Library = {}

   404

        # add by jblee for Modular Device Profile

   405

        self.MDPList = []

   406

        self.ModuleList = []

   407

        self.MDPEntryList = {}

   408

        dtDic = {}

   409

        self.idxIncrement = 0

   410

        self.slotIncrement = 0

   411

        # add by jblee for PDO Mapping

   412

        self.DataTypes = {}

   413

        self.ObjectDictionary = {}

   414

   415

        files = os.listdir(self.Path)

   416

        for file in files:

   417

            filepath = os.path.join(self.Path, file)

   418

            if os.path.isfile(filepath) and os.path.splitext(filepath)[-1] == ".xml":

   419

                self.modules_infos = None

   420

   421

                xmlfile = open(filepath, 'r')

   422

                try:

   423

                    self.modules_infos, error = EtherCATInfoParser.LoadXMLString(xmlfile.read())

   424

                    # if error is not None:

   425

                    #     self.GetCTRoot().logger.write_warning(

   426

                    #         XSDSchemaErrorMessage % (filepath + error))

   427

                except Exception as exc:

   428

                    self.modules_infos, error = None, text(exc)

   429

                xmlfile.close()

   430

   431

                if self.modules_infos is not None:

   432

                    vendor = self.modules_infos.getVendor()

   433

   434

                    vendor_category = self.Library.setdefault(

   435

                        ExtractHexDecValue(vendor.getId()),

   436

                        {"name": ExtractName(vendor.getName(), _("Miscellaneous")),

   437

                         "groups": {}})

   438

   439

                    for group in self.groups_xpath(self.modules_infos):

   440

                        group_type = group.getType()

   441

                        # add for XmlToEeprom Func by jblee.

   442

                        self.LcId_data = group.getchildren()[1]

   443

                        self.Image16x14_data = group.getchildren()[2]

   444

   445

                        vendor_category["groups"].setdefault(

   446

                            group_type,

   447

                            {

   448

                                "name": ExtractName(group.getName(), group_type),

   449

                                "parent": group.getParentGroup(),

   450

                                "order": group.getSortOrder(),

   451

                                "devices": [],

   452

                                # add jblee for support Moduler Device Profile (MDP)

   453

                                "modules": []})

   454

                            })

   455

   456

                    for device in self.devices_xpath(self.modules_infos):

   457

                        device_group = device.getGroupType()

   458

                        if device_group not in vendor_category["groups"]:

   459

                            raise ValueError("Not such group \"%s\"" % device_group)

   460

                        vendor_category["groups"][device_group]["devices"].append(

   461

                            (device.getType().getcontent(), device))

   462

   463

                        # ------------------ Test Section --------------------#

   464

                        slots = device.getSlots()

   465

                        if slots is not None:

   466

                            for slot in slots.getSlot():

   467

                                self.idxIncrement = slot.getSlotIndexIncrement()

   468

                                self.slotIncrement = slot.getSlotPdoIncrement()

   469

                                for child in slot.getchildren():

   470

                                    if child.tag == "ModuleClass":

   471

                                        child_class = child.getClass()

   472

                                        child_name = child.getName()

   473

   474

                    # -------------------- Test Section ----------------------------------# 

   475

                        LocalMDPList = []

   476

                        for module in self.module_xpath(self.modules_infos):

   477

                            module_type = module.getType().getModuleClass()

   478

                            module_name = module.getName()

   479

                            LocalMDPData = ExtractName(module_name) + " (" + module_type + ")"

   480

   481

                            self.ModuleList.append(module)

   482

                            try :

   483

                                module_pdos = module.getTxPdo()

   484

                                module_pdos += module.getRxPdo()

   485

                                for module_pdo in module_pdos:

   486

                                    device_name = ExtractName(module_name)

   487

                                    pdo_index = module_pdo.getIndex().getcontent()

   488

                                    pdo_name = ExtractName(module_pdo.getName())

   489

                                    pdo_entry = module_pdo.getEntry()