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

import os, shutil

    13

    14

#from xml.dom import minidom

    15

from lxml import etree

    16

    17

import wx

    18

import csv

    19

    20

from xmlclass import *

    21

    22

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    23

from PLCControler import UndoBuffer, LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    24

    25

from EthercatSlave import ExtractHexDecValue, ExtractName

    26

from EthercatMaster import _EthercatCTN

    27

from 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

EtherCATInfo_XPath = lambda xpath: etree.XPath(xpath)

    37

    38

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

    39

EtherCATBase_XPath = lambda xpath1: etree.XPath(xpath1)

    40

    41

def HexDecValue(context, *args):

    42

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

    43

    44

def EntryName(context, *args):

    45

    return ExtractName(args[0], 

    46

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

    47

    48

ENTRY_INFOS_KEYS = [

    49

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

    50

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

    51

    ("Name", str, ""),

    52

    ("Type", str, ""),

    53

    ("BitSize", int, 0),

    54

    ("Access", str, ""),

    55

    ("PDOMapping", str, ""),

    56

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

    57

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

    58

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

    59

    60

# Read DefaultValue from ESI file

    61

# Add by jblee 151229

    62

ENTRY_INFOS_KEYS_FOR_DV = [

    63

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

    64

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

    65

    ("Name", str, ""),

    66

    ("Type", str, ""),

    67

    ("BitSize", int, 0),

    68

    ("Access", str, ""),

    69

    ("PDOMapping", str, ""),

    70

    ("DefaultValue", str, ""),

    71

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

    72

    73

class EntryListFactory:

    74

    75

    def __init__(self, entries):

    76

        self.Entries = entries

    77

    78

    def AddEntry(self, context, *args):

    79

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

    80

        if len(args) > 9:

    81

		    new_entry_infos = {

    82

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

    83

            for (key, translate, default), arg

    84

            in zip(ENTRY_INFOS_KEYS, args)}

    85

        else:

    86

            new_entry_infos = {

    87

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

    88

            for (key, translate, default), arg

    89

            in zip(ENTRY_INFOS_KEYS_FOR_DV, args)}			

    90

    91

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

    92

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

    93

            if entry_infos is not None:

    94

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

    95

                    value = new_entry_infos.get(param)

    96

                    if value is not None:

    97

                        entry_infos[param] = value

    98

            else:

    99

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

   100

   101

entries_list_xslt = etree.parse(

   102

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

   103

   104

cls = EtherCATInfoParser.GetElementClass("DeviceType")

   105

if cls:

   106

    cls.DataTypes = None

   107

   108

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

   109

    def GetProfileNumbers(self):

   110

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

   111

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

   112

   113

    def getCoE(self):

   114

        mailbox = self.getMailbox()

   115

        if mailbox is not None:

   116

            return mailbox.getCoE()

   117

        return None

   118

    setattr(cls, "getCoE", getCoE)

   119

   120

    # Modify by jblee

   121

    def ExtractDataTypes(self):

   122

        #self.DataTypes = {}

   123

        #self.DT = {}

   124

        DT = {}

   125

        objects = []

   126

   127

        # get Profile Field

   128

        for profile in self.getProfile():

   129

            # get each (ProfileNo, Dictionary) Field as child

   130

            for child in profile.getchildren():

   131

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

   132

                if child.text is None:

   133

                    # get each (DataTypes, Objects) Field 

   134

                    dataTypes = child.getDataTypes()

   135

                    objects = child.getObjects()

   136

   137

                    for dataType in dataTypes.getDataType():

   138

                        #if dataType.getName() is not None:

   139

                        #    print dataType.getName(), dataType

   140

                        DT[dataType.getName()] = dataType

   141

   142

        return DT, objects

   143

    setattr(cls, "ExtractDataTypes", ExtractDataTypes)

   144

   145

    def GetEntriesList(self, limits=None):

   146

        DataTypes, objects = self.ExtractDataTypes()

   147

   148

        entries = {}

   149

   150

        # get each Object Field

   151

        for object in objects:

   152

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

   153

            # Frequently Use : Info, Flags

   154

            # Info Field -> DefaultData, SubItem

   155

            # Flags Field -> Access, Category, PdoMapping

   156

            object_index = object.getIndex().getcontent()

   157

            index = ExtractHexDecValue(object_index)

   158

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

   159

                object_type = object.getType()

   160

                object_name = ExtractName(object.getName())

   161

                object_size = object.getBitSize()

   162

                defaultData = ""

   163

                object_access = ""

   164

                object_PDOMapping_data = ""

   165

   166

                object_type_infos = DataTypes.get(object_type, None)

   167

                subItem_infos = object_type_infos.getchildren()

   168

                countSubIndex = 0

   169

                if len(subItem_infos) > 2:

   170

                    for subItem_info in subItem_infos:

   171

                        if subItem_info.tag == "SubItem" : 

   172

                            subItemName = subItem_info.getName()

   173

                            subIdx = subItem_info.getSubIdx()

   174

                            if subIdx is not None:

   175

                                object_subidx = ExtractHexDecValue(subIdx)

   176

                            else:

   177

                                object_subidx = ExtractHexDecValue(countSubIndex)

   178

                            subType = subItem_info.getType()

   179

                            subBitSize = subItem_info.getBitSize()

   180

                            subFlags = subItem_info.getFlags()

   181

                            subAccess = ""

   182

                            subPDOMapping_data = ""

   183

                            if subFlags is not None:

   184

                                subAccess = subFlags.getAccess().getcontent()

   185

                                subPDOMapping = subFlags.getPdoMapping()                                                        

   186

                                if subPDOMapping is not None:

   187

                                    subPDOMapping_data = subFlags.getPdoMapping().upper()

   188

   189

                            entries[(index, object_subidx)] = {

   190

                                "Index": object_index,

   191

                                "SubIndex": subIdx,

   192

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

   193

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

   194

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

   195

                                "Type": subType,

   196

                                "BitSize": subBitSize,

   197

                                "Access": subAccess, 

   198

                                "PDOMapping": subPDOMapping_data}

   199

   200

                            countSubIndex += 1

   201

   202

                    info = object.getInfo()

   203

                    # subItemTest : check subItem 

   204

                    countSubIndex = 0

   205

                    if info is not None:

   206

                        subItems = info.getchildren()

   207

                        if len(subItems) > 1:

   208

                            for subItem in subItems:

   209

                                defaultdata_subidx = ExtractHexDecValue(countSubIndex)

   210

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

   211

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

   212

                                if entry is not None:

   213

                                    entry["DefaultData"] = defaultData

   214

                                countSubIndex += 1

   215

   216

                else :

   217

                    info = object.getInfo()

   218

                    if info is not None:

   219

                        subItems = info.getchildren()

   220

                        if len(subItems) <= 1:

   221

                            defaultData = subItems[0].text

   222

   223

                    object_flag = object.getFlags()

   224

                    object_access = object_flag.getAccess().getcontent()

   225

                    object_PDOMapping = object_flag.getPdoMapping()

   226

                    if object_PDOMapping is not None:

   227

                        object_PDOMapping_data = object_flag.getPdoMapping().upper()

   228

                    entries[(index, 0)] = {

   229

                        "Index": object_index,

   230

                        "SubIndex": "0",

   231

                        "Name": object_name,                                                               

   232

                        "Type": object_type,

   233

                        "BitSize": object_size,

   234

                        "DefaultData" : defaultData,

   235

                        "Access": object_access, 

   236

                        "PDOMapping": object_PDOMapping_data}

   237

   238

        for TxPdo in self.getTxPdo():

   239

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

   240

        for RxPdo in self.getRxPdo():

   241

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

   242

   243

        return entries

   244

    setattr(cls, "GetEntriesList", GetEntriesList)

   245

   246

#    def GetEntriesList(self, limits=None):

   247

#        entries = {}

   248

   249

#        factory = EntryListFactory(entries)

   250

   251

#        entries_list_xslt_tree = etree.XSLT(

   252

#            entries_list_xslt, extensions = {

   253

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

   254

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

   255

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

   256

#        entries_list_xslt_tree(self, **dict(zip(

   257

#            ["min_index", "max_index"], 

   258

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

   259

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

   260

#            )))

   261

#        

   262

#        return entries

   263

#    setattr(cls, "GetEntriesList", GetEntriesList)

   264

   265

    def GetSyncManagers(self):

   266

        sync_managers = []

   267

        for sync_manager in self.getSm():

   268

            sync_manager_infos = {}

   269

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

   270

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

   271

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

   272

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

   273

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

   274

                if value is None:

   275

                    value =""

   276

                sync_manager_infos[name] = value

   277

            sync_managers.append(sync_manager_infos)

   278

        return sync_managers

   279

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   280

   281

cls2 = EtherCATInfoParser.GetElementClass("DeviceType")

   282

   283

def GroupItemCompare(x, y):

   284

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

   285

        if x["type"] == ETHERCAT_GROUP:

   286

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

   287

        else:

   288

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

   289

    elif x["type"] == ETHERCAT_GROUP:

   290

        return -1

   291

    return 1

   292

   293

def SortGroupItems(group):

   294

    for item in group["children"]:

   295

        if item["type"] == ETHERCAT_GROUP:

   296

            SortGroupItems(item)

   297

    group["children"].sort(GroupItemCompare)

   298

   299

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

   300

    pdo_index = pdo.getIndex().getcontent()

   301

    pdo_name = ExtractName(pdo.getName())

   302

    exclude = pdo.getExclude()

   303

    for pdo_entry in pdo.getEntry():

   304

        entry_index = pdo_entry.getIndex().getcontent()

   305

        entry_subindex = pdo_entry.getSubIndex()

   306

        index = ExtractHexDecValue(entry_index)

   307

        subindex = ExtractHexDecValue(entry_subindex)

   308

        object_size = pdo_entry.getBitLen()

   309

   310

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

   311

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

   312

            if entry is not None:

   313

                entry["PDO index"] = pdo_index

   314

                entry["PDO name"] = pdo_name

   315

                entry["PDO type"] = pdo_type

   316

            else:

   317

                entry_type = pdo_entry.getDataType()

   318

                if entry_type is not None:

   319

                    if pdo_type == "Transmit":

   320

                        access = "ro"

   321

                        pdomapping = "T"

   322

                    else:

   323

                        access = "wo"

   324

                        pdomapping = "R"

   325

                    entries[(index, subindex)] = {

   326

                        "Index": entry_index,

   327

                        "SubIndex": entry_subindex,

   328

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

   329

                        "Type": entry_type.getcontent(),

   330

                        "BitSize": object_size,

   331

                        "Access": access,

   332

                        "PDOMapping": pdomapping}

   333

   334

#cls3 = EtherCATBaseParser.GetElementClass("ModuleType")

   335

#if cls3:

   336

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

   337

#    def test(self):

   338

#        print module_xpath

   339

   340

#    setattr(cls, "test", test)

   341

   342

   343

class ModulesLibrary:

   344

   345

    MODULES_EXTRA_PARAMS = [

   346

        ("pdo_alignment", {

   347

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

   348

            "column_size": 150,

   349

            "default": 8,

   350

            "description": _(

   351

"Minimal size in bits between 2 pdo entries")}),

   352

        ("max_pdo_size", {

   353

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

   354

            "column_size": 150,

   355

            "default": 255,

   356

            "description": _(

   357

"""Maximal number of entries mapped in a PDO

   358

including empty entries used for PDO alignment""")}),

   359

        ("add_pdo", {

   360

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

   361

            "column_size": 150,

   362

            "default": 0,

   363

            "description": _(

   364

"""Adding a PDO not defined in default configuration

   365

for mapping needed location variables

   366

(1 if possible)""")})

   367

    ]

   368

   369

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

   370

        self.Path = path

   371

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

   372

            os.makedirs(self.Path)

   373

        self.ParentLibrary = parent_library

   374

   375

        if parent_library is not None:

   376

            self.LoadModules()

   377

        else:

   378

            self.Library = None

   379

        self.LoadModulesExtraParams()

   380

   381

    def GetPath(self):

   382

        return self.Path

   383

   384

    def GetModulesExtraParamsFilePath(self):

   385

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

   386

   387

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

   388

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

   389

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

   390

   391

    def LoadModules(self):

   392

        self.Library = {}

   393

        # add by jblee for Modular Device Profile

   394

        self.MDPList = []

   395

        self.ModuleList = []

   396

        self.MDPEntryList = {}

   397

        dtDic = {}

   398

        self.idxIncrement = 0

   399

        self.slotIncrement = 0

   400

        # add by jblee for PDO Mapping

   401

        self.DataTypes = {}

   402

        self.ObjectDictionary = {}

   403

   404

        files = os.listdir(self.Path)

   405

        for file in files:

   406

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

   407

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

   408

                self.modules_infos = None

   409

   410

                xmlfile = open(filepath, 'r')

   411

                try:

   412

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

   413

                    #if error is not None:

   414

                    #    self.GetCTRoot().logger.write_warning(

   415

                    #        XSDSchemaErrorMessage % (filepath + error))

   416

                except Exception, exc:

   417

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

   418

                xmlfile.close()

   419

   420

                if self.modules_infos is not None:

   421

                    vendor = self.modules_infos.getVendor()

   422

   423

                    vendor_category = self.Library.setdefault(

   424

                        ExtractHexDecValue(vendor.getId()), 

   425

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

   426

                         "groups": {}})

   427

   428

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

   429

                        group_type = group.getType()

   430

                        # add for XmlToEeprom Func by jblee.

   431

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

   432

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

   433

   434

                        vendor_category["groups"].setdefault(group_type, 

   435

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

   436

                             "parent": group.getParentGroup(),

   437

                             "order": group.getSortOrder(), 

   438

                             "devices": [],

   439

                            # add jblee for support Moduler Device Profile (MDP)

   440

                             "modules": []})

   441

   442

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

   443

                        device_group = device.getGroupType()

   444

                        if not vendor_category["groups"].has_key(device_group):

   445

                            raise ValueError, "Not such group \"%\"" % device_group

   446

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

   447

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

   448

   449

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

   450

                        slots = device.getSlots()

   451

                        if slots is not None:

   452

                            for slot in slots.getSlot():

   453

                                self.idxIncrement = slot.getSlotIndexIncrement()

   454

                                self.slotIncrement = slot.getSlotPdoIncrement()

   455

                                for child in slot.getchildren():

   456

                                    if child.tag == "ModuleClass":

   457

                                        child_class = child.getClass()

   458

                                        child_name = child.getName()

   459

   460

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

   461

                        LocalMDPList = []

   462

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

   463

                            module_type = module.getType().getModuleClass()

   464

                            module_name = module.getName()

   465

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

   466

   467

                            self.ModuleList.append(module)

   468

                            try :

   469

                                module_pdos = module.getTxPdo()

   470

                                module_pdos += module.getRxPdo()

   471

                                for module_pdo in module_pdos:

   472

                                    device_name = ExtractName(module_name)

   473

                                    pdo_index = module_pdo.getIndex().getcontent()

   474

                                    pdo_name = ExtractName(module_pdo.getName())

   475

                                    pdo_entry = module_pdo.getEntry()

   476

                                    if module_pdo.tag == "TxPdo":

   477

                                        mapping_type = "T"

   478

                                    else :

   479

                                        mapping_type = "R"

   480

   481

                                    LocalMDPEntry = []

   482

                                    for entry in pdo_entry:

   483

                                        entry_index = entry.getIndex().getcontent()

   484

                                        entry_subidx = entry.getSubIndex()

   485

                                        entry_name = ExtractName(entry.getName())

   486

                                        entry_bitsize = entry.getBitLen()

   487

                                        try :

   488

                                           entry_type = entry.getDataType().getcontent()

   489

                                        except :

   490

                                           entry_type = ""

   491

   492

                                        LocalMDPEntry.append({