1

import os, shutil

     2

from xml.dom import minidom

     3

     4

import wx

     5

import csv

     6

     7

from xmlclass import *

     8

     9

from ConfigTreeNode import ConfigTreeNode

    10

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

    11

    12

from EthercatSlave import ExtractHexDecValue, ExtractName

    13

from EthercatMaster import _EthercatCTN

    14

from ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    15

    16

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

    17

#                 Ethercat ConfNode

    18

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

    19

    20

EtherCATInfoClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd")) 

    21

    22

cls = EtherCATInfoClasses["EtherCATBase.xsd"].get("DictionaryType", None)

    23

if cls:

    24

    cls.loadXMLTreeArgs = None

    25

    26

    setattr(cls, "_loadXMLTree", getattr(cls, "loadXMLTree"))

    27

    28

    def loadXMLTree(self, *args):

    29

        self.loadXMLTreeArgs = args

    30

    setattr(cls, "loadXMLTree", loadXMLTree)

    31

    32

    def load(self):

    33

        if self.loadXMLTreeArgs is not None:

    34

            self._loadXMLTree(*self.loadXMLTreeArgs)

    35

            self.loadXMLTreeArgs = None

    36

    setattr(cls, "load", load)

    37

    38

cls = EtherCATInfoClasses["EtherCATInfo.xsd"].get("DeviceType", None)

    39

if cls:

    40

    cls.DataTypes = None

    41

    42

    def GetProfileNumbers(self):

    43

        profiles = []

    44

    45

        for profile in self.getProfile():

    46

            profile_content = profile.getcontent()

    47

            if profile_content is None:

    48

                continue

    49

    50

            for content_element in profile_content["value"]:

    51

                if content_element["name"] == "ProfileNo":

    52

                    profiles.append(content_element["value"])

    53

    54

        return profiles

    55

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    56

    57

    def GetProfileDictionaries(self):

    58

        dictionaries = []

    59

    60

        for profile in self.getProfile():

    61

    62

            profile_content = profile.getcontent()

    63

            if profile_content is None:

    64

                continue

    65

    66

            for content_element in profile_content["value"]:

    67

                if content_element["name"] == "Dictionary":

    68

                    dictionaries.append(content_element["value"])

    69

                elif content_element["name"] == "DictionaryFile":

    70

                    raise ValueError, "DictionaryFile for defining Device Profile is not yet supported!"

    71

    72

        return dictionaries

    73

    setattr(cls, "GetProfileDictionaries", GetProfileDictionaries)

    74

    75

    def ExtractDataTypes(self):

    76

        self.DataTypes = {}

    77

    78

        for dictionary in self.GetProfileDictionaries():

    79

            dictionary.load()

    80

    81

            datatypes = dictionary.getDataTypes()

    82

            if datatypes is not None:

    83

    84

                for datatype in datatypes.getDataType():

    85

                    content = datatype.getcontent()

    86

                    if content is not None and content["name"] == "SubItem":

    87

                        self.DataTypes[datatype.getName()] = datatype

    88

    89

    setattr(cls, "ExtractDataTypes", ExtractDataTypes)

    90

    91

    def getCoE(self):

    92

        mailbox = self.getMailbox()

    93

        if mailbox is not None:

    94

            return mailbox.getCoE()

    95

        return None

    96

    setattr(cls, "getCoE", getCoE)

    97

    98

    def GetEntriesList(self, limits=None):

    99

        if self.DataTypes is None:

   100

            self.ExtractDataTypes()

   101

   102

        entries = {}

   103

   104

        for dictionary in self.GetProfileDictionaries():

   105

            dictionary.load()

   106

   107

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

   108

                entry_index = object.getIndex().getcontent()

   109

                index = ExtractHexDecValue(entry_index)

   110

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

   111

                    entry_type = object.getType()

   112

                    entry_name = ExtractName(object.getName())

   113

   114

                    entry_type_infos = self.DataTypes.get(entry_type, None)

   115

                    if entry_type_infos is not None:

   116

                        content = entry_type_infos.getcontent()

   117

                        for subitem in content["value"]:

   118

                            entry_subidx = subitem.getSubIdx()

   119

                            if entry_subidx is None:

   120

                                entry_subidx = "0"

   121

                            subidx = ExtractHexDecValue(entry_subidx)

   122

                            subitem_access = ""

   123

                            subitem_pdomapping = ""

   124

                            subitem_flags = subitem.getFlags()

   125

                            if subitem_flags is not None:

   126

                                access = subitem_flags.getAccess()

   127

                                if access is not None:

   128

                                    subitem_access = access.getcontent()

   129

                                pdomapping = subitem_flags.getPdoMapping()

   130

                                if pdomapping is not None:

   131

                                    subitem_pdomapping = pdomapping.upper()

   132

                            entries[(index, subidx)] = {

   133

                                "Index": entry_index,

   134

                                "SubIndex": entry_subidx,

   135

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

   136

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

   137

                                         ExtractName(subitem.getDisplayName(), 

   138

                                                     subitem.getName()).decode("utf-8")),

   139

                                "Type": subitem.getType(),

   140

                                "BitSize": subitem.getBitSize(),

   141

                                "Access": subitem_access, 

   142

                                "PDOMapping": subitem_pdomapping}

   143

                    else:

   144

                        entry_access = ""

   145

                        entry_pdomapping = ""

   146

                        entry_flags = object.getFlags()

   147

                        if entry_flags is not None:

   148

                            access = entry_flags.getAccess()

   149

                            if access is not None:

   150

                                entry_access = access.getcontent()

   151

                            pdomapping = entry_flags.getPdoMapping()

   152

                            if pdomapping is not None:

   153

                                entry_pdomapping = pdomapping.upper()

   154

                        entries[(index, 0)] = {

   155

                             "Index": entry_index,

   156

                             "SubIndex": "0",

   157

                             "Name": entry_name,

   158

                             "Type": entry_type,

   159

                             "BitSize": object.getBitSize(),

   160

                             "Access": entry_access,

   161

                             "PDOMapping": entry_pdomapping}

   162

   163

        for TxPdo in self.getTxPdo():

   164

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

   165

        for RxPdo in self.getRxPdo():

   166

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

   167

   168

        return entries

   169

    setattr(cls, "GetEntriesList", GetEntriesList)

   170

   171

    def GetSyncManagers(self):

   172

        sync_managers = []

   173

        for sync_manager in self.getSm():

   174

            sync_manager_infos = {}

   175

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

   176

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

   177

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

   178

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

   179

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

   180

                if value is None:

   181

                    value =""

   182

                sync_manager_infos[name] = value

   183

            sync_managers.append(sync_manager_infos)

   184

        return sync_managers

   185

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   186

   187

def GroupItemCompare(x, y):

   188

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

   189

        if x["type"] == ETHERCAT_GROUP:

   190

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

   191

        else:

   192

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

   193

    elif x["type"] == ETHERCAT_GROUP:

   194

        return -1

   195

    return 1

   196

   197

def SortGroupItems(group):

   198

    for item in group["children"]:

   199

        if item["type"] == ETHERCAT_GROUP:

   200

            SortGroupItems(item)

   201

    group["children"].sort(GroupItemCompare)

   202

   203

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

   204

    pdo_index = pdo.getIndex().getcontent()

   205

    pdo_name = ExtractName(pdo.getName())

   206

    for pdo_entry in pdo.getEntry():

   207

        entry_index = pdo_entry.getIndex().getcontent()

   208

        entry_subindex = pdo_entry.getSubIndex()

   209

        index = ExtractHexDecValue(entry_index)

   210

        subindex = ExtractHexDecValue(entry_subindex)

   211

   212

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

   213

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

   214

            if entry is not None:

   215

                entry["PDO index"] = pdo_index

   216

                entry["PDO name"] = pdo_name

   217

                entry["PDO type"] = pdo_type

   218

            else:

   219

                entry_type = pdo_entry.getDataType()

   220

                if entry_type is not None:

   221

                    if pdo_type == "Transmit":

   222

                        access = "ro"

   223

                        pdomapping = "T"

   224

                    else:

   225

                        access = "wo"

   226

                        pdomapping = "R"

   227

                    entries[(index, subindex)] = {

   228

                        "Index": entry_index,

   229

                        "SubIndex": entry_subindex,

   230

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

   231

                        "Type": entry_type.getcontent(),

   232

                        "Access": access,

   233

                        "PDOMapping": pdomapping}

   234

   235

DEFAULT_ALIGNMENT = 8

   236

   237

class ModulesLibrary:

   238

   239

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

   240

        self.Path = path

   241

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

   242

            os.makedirs(self.Path)

   243

        self.ParentLibrary = parent_library

   244

   245

        if parent_library is not None:

   246

            self.LoadModules()

   247

        else:

   248

            self.Library = None

   249

        self.LoadAlignments()

   250

   251

    def GetPath(self):

   252

        return self.Path

   253

   254

    def GetAlignmentFilePath(self):

   255

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

   256

   257

    def LoadModules(self):

   258

        self.Library = {}

   259

   260

        files = os.listdir(self.Path)

   261

        for file in files:

   262

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

   263

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

   264

                xmlfile = open(filepath, 'r')

   265

                xml_tree = minidom.parse(xmlfile)

   266

                xmlfile.close()

   267

   268

                modules_infos = None

   269

                for child in xml_tree.childNodes:

   270

                    if child.nodeType == xml_tree.ELEMENT_NODE and child.nodeName == "EtherCATInfo":

   271

                        modules_infos = EtherCATInfoClasses["EtherCATInfo.xsd"]["EtherCATInfo"]()

   272

                        modules_infos.loadXMLTree(child)

   273

   274

                if modules_infos is not None:

   275

                    vendor = modules_infos.getVendor()

   276

   277

                    vendor_category = self.Library.setdefault(ExtractHexDecValue(vendor.getId()), 

   278

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

   279

                                                               "groups": {}})

   280

   281

                    for group in modules_infos.getDescriptions().getGroups().getGroup():

   282

                        group_type = group.getType()

   283

   284

                        vendor_category["groups"].setdefault(group_type, {"name": ExtractName(group.getName(), group_type), 

   285

                                                                          "parent": group.getParentGroup(),

   286

                                                                          "order": group.getSortOrder(), 

   287

                                                                          "devices": []})

   288

   289

                    for device in modules_infos.getDescriptions().getDevices().getDevice():

   290

                        device_group = device.getGroupType()

   291

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

   292

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

   293

                        vendor_category["groups"][device_group]["devices"].append((device.getType().getcontent(), device))

   294

   295

    def GetModulesLibrary(self, profile_filter=None):

   296

        if self.Library is None:

   297

            self.LoadModules()

   298

        library = []

   299

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

   300

            groups = []

   301

            children_dict = {}

   302

            for group_type, group in vendor["groups"].iteritems():

   303

                group_infos = {"name": group["name"],

   304

                               "order": group["order"],

   305

                               "type": ETHERCAT_GROUP,

   306

                               "infos": None,

   307

                               "children": children_dict.setdefault(group_type, [])}

   308

                device_dict = {}

   309

                for device_type, device in group["devices"]:

   310

                    if profile_filter is None or profile_filter in device.GetProfileNumbers():

   311

                        product_code = device.getType().getProductCode()

   312

                        revision_number = device.getType().getRevisionNo()

   313

                        alignment = self.GetAlignment(vendor_id, product_code, revision_number)

   314

                        device_infos = {"name": ExtractName(device.getName()),

   315

                                        "type": ETHERCAT_DEVICE,

   316

                                        "infos": {"device_type": device_type,

   317

                                                  "vendor": vendor_id,

   318

                                                  "product_code": product_code,

   319

                                                  "revision_number": revision_number,

   320

                                                  "alignment": alignment},

   321

                                        "children": []}

   322

                        group_infos["children"].append(device_infos)

   323

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   324

                        device_type_occurrences.append(device_infos)

   325

                for device_type_occurrences in device_dict.itervalues():

   326

                    if len(device_type_occurrences) > 1:

   327

                        for occurrence in device_type_occurrences:

   328

                            occurrence["name"] += _(" (rev. %s)") % occurrence["infos"]["revision_number"]

   329

                if len(group_infos["children"]) > 0:

   330

                    if group["parent"] is not None:

   331

                        parent_children = children_dict.setdefault(group["parent"], [])

   332

                        parent_children.append(group_infos)

   333

                    else:

   334

                        groups.append(group_infos)

   335

            if len(groups) > 0:

   336

                library.append({"name": vendor["name"],

   337

                                "type": ETHERCAT_VENDOR,

   338

                                "infos": None,

   339

                                "children": groups})

   340

        library.sort(lambda x, y: cmp(x["name"], y["name"]))

   341

        return library

   342

   343

    def GetVendors(self):

   344

        return [(vendor_id, vendor["name"]) for vendor_id, vendor in self.Library.items()]

   345

   346

    def GetModuleInfos(self, module_infos):

   347

        vendor = ExtractHexDecValue(module_infos["vendor"])

   348

        vendor_infos = self.Library.get(vendor)

   349

        if vendor_infos is not None:

   350

            for group_name, group_infos in vendor_infos["groups"].iteritems():

   351

                for device_type, device_infos in group_infos["devices"]:

   352

                    product_code = ExtractHexDecValue(device_infos.getType().getProductCode())

   353

                    revision_number = ExtractHexDecValue(device_infos.getType().getRevisionNo())

   354

                    if (product_code == ExtractHexDecValue(module_infos["product_code"]) and

   355

                        revision_number == ExtractHexDecValue(module_infos["revision_number"])):

   356

                        return device_infos, self.GetAlignment(vendor, product_code, revision_number)

   357

        return None, None

   358

   359

    def ImportModuleLibrary(self, filepath):

   360

        if os.path.isfile(filepath):

   361

            shutil.copy(filepath, self.Path)

   362

            self.LoadModules()

   363

            return True

   364

        return False

   365

   366

    def LoadAlignments(self):

   367

        self.Alignments = {}

   368

   369

        csvfile_path = self.GetAlignmentFilePath()

   370

        if os.path.exists(csvfile_path):

   371

            csvfile = open(csvfile_path, "rb")

   372

            sample = csvfile.read(1024)

   373

            csvfile.seek(0)

   374

            dialect = csv.Sniffer().sniff(sample)

   375

            has_header = csv.Sniffer().has_header(sample)

   376

            reader = csv.reader(csvfile, dialect)

   377

            for row in reader:

   378

                if has_header:

   379

                    has_header = False

   380

                else:

   381

                    try:

   382

                        self.Alignments[tuple(map(int, row[:3]))] = int(row[3])

   383

                    except:

   384

                        pass

   385

            csvfile.close()

   386

   387

    def SaveAlignments(self):

   388

        csvfile = open(self.GetAlignmentFilePath(), "wb")

   389

        writer = csv.writer(csvfile, delimiter=';')

   390

        writer.writerow(['Vendor', 'product_code', 'revision_number', 'alignment'])

   391

        for (vendor, product_code, revision_number), alignment in self.Alignments.iteritems():

   392

            writer.writerow([vendor, product_code, revision_number, alignment])

   393

        csvfile.close()

   394

   395

    def SetAlignment(self, vendor, product_code, revision_number, alignment):

   396

        vendor = ExtractHexDecValue(vendor)

   397

        product_code = ExtractHexDecValue(product_code)

   398

        revision_number = ExtractHexDecValue(revision_number)

   399

   400

        self.Alignments[tuple([vendor, product_code, revision_number])] = alignment

   401

        self.SaveAlignments()

   402

   403

    def GetAlignment(self, vendor, product_code, revision_number):

   404

        vendor = ExtractHexDecValue(vendor)

   405

        product_code = ExtractHexDecValue(product_code)

   406

        revision_number = ExtractHexDecValue(revision_number)

   407

   408

        alignment = self.Alignments.get(tuple([vendor, product_code, revision_number]))

   409

        if alignment is not None:

   410

            return alignment

   411

   412

        if self.ParentLibrary is not None:

   413

            return self.ParentLibrary.GetAlignment(vendor, product_code, revision_number)

   414

        return DEFAULT_ALIGNMENT

   415

   416

USERDATA_DIR = wx.StandardPaths.Get().GetUserDataDir()

   417

if wx.Platform != '__WXMSW__':

   418

    USERDATA_DIR += '_files'

   419

   420

ModulesDatabase = ModulesLibrary(

   421

    os.path.join(USERDATA_DIR, "ethercat_modules"))

   422

   423

class RootClass:

   424

   425

    CTNChildrenTypes = [("EthercatNode",_EthercatCTN,"Ethercat Master")]

   426

    EditorType = LibraryEditor

   427

   428

    def __init__(self):

   429

        self.ModulesLibrary = None

   430

        self.LoadModulesLibrary()

   431

   432

    def GetModulesLibraryPath(self):

   433

        return os.path.join(self.CTNPath(), "modules") 

   434

   435

    def CTNGenerate_C(self, buildpath, locations):

   436

        return [],"",False

   437

   438

    def LoadModulesLibrary(self):

   439

        if self.ModulesLibrary is None:

   440

            self.ModulesLibrary = ModulesLibrary(self.GetModulesLibraryPath(), ModulesDatabase)

   441

        else:

   442

            self.ModulesLibrary.LoadModulesLibrary()

   443

   444

    def GetModulesDatabaseInstance(self):

   445

        return ModulesDatabase

   446

   447

    def GetModulesLibraryInstance(self):

   448

        return self.ModulesLibrary

   449

   450

    def GetModulesLibrary(self, profile_filter=None):

   451

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   452

   453

    def GetVendors(self):

   454

        return self.ModulesLibrary.GetVendors()

   455

   456

    def GetModuleInfos(self, module_infos):

   457

        return self.ModulesLibrary.GetModuleInfos(module_infos)

   458

   459