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

class ModulesLibrary:

   248

   249

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

   250

        self.Path = path

   251

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

   252

            os.makedirs(self.Path)

   253

        self.ParentLibrary = parent_library

   254

   255

        if parent_library is not None:

   256

            self.LoadModules()

   257

        else:

   258

            self.Library = None

   260

   261

    def GetPath(self):

   262

        return self.Path

   263

   266

   267

    def LoadModules(self):

   268

        self.Library = {}

   269

   270

        files = os.listdir(self.Path)

   271

        for file in files:

   272

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

   273

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

   274

                xmlfile = open(filepath, 'r')

   275

                xml_tree = minidom.parse(xmlfile)

   276

                xmlfile.close()

   277

   278

                modules_infos = None

   279

                for child in xml_tree.childNodes:

   280

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

   281

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

   282

                        modules_infos.loadXMLTree(child)

   283

   284

                if modules_infos is not None:

   285

                    vendor = modules_infos.getVendor()

   286

   287

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

   288

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

   289

                                                               "groups": {}})

   290

   291

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

   292

                        group_type = group.getType()

   293

   294

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

   295

                                                                          "parent": group.getParentGroup(),

   296

                                                                          "order": group.getSortOrder(), 

   297

                                                                          "devices": []})

   298

   299

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

   300

                        device_group = device.getGroupType()

   301

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

   302

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

   303

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

   304

   305

    def GetModulesLibrary(self, profile_filter=None):

   306

        if self.Library is None:

   307

            self.LoadModules()

   308

        library = []

   309

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

   310

            groups = []

   311

            children_dict = {}

   312

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

   313

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

   314

                               "order": group["order"],

   315

                               "type": ETHERCAT_GROUP,

   316

                               "infos": None,

   317

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

   318

                device_dict = {}

   319

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

   320

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

   321

                        product_code = device.getType().getProductCode()

   322

                        revision_number = device.getType().getRevisionNo()

   328

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

   329

                                        "type": ETHERCAT_DEVICE,

   331

                                        "children": []}

   332

                        group_infos["children"].append(device_infos)

   333

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   334

                        device_type_occurrences.append(device_infos)

   335

                for device_type_occurrences in device_dict.itervalues():

   336

                    if len(device_type_occurrences) > 1:

   337

                        for occurrence in device_type_occurrences:

   338

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

   339

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

   340

                    if group["parent"] is not None:

   341

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

   342

                        parent_children.append(group_infos)

   343

                    else:

   344

                        groups.append(group_infos)

   345

            if len(groups) > 0:

   346

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

   347

                                "type": ETHERCAT_VENDOR,

   348

                                "infos": None,

   349

                                "children": groups})

   350

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

   351

        return library

   352

   353

    def GetVendors(self):

   354

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

   355

   356

    def GetModuleInfos(self, module_infos):

   357

        vendor = ExtractHexDecValue(module_infos["vendor"])

   358

        vendor_infos = self.Library.get(vendor)

   359

        if vendor_infos is not None:

   360

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

   361

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

   362

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

   363

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

   364

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

   365

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

   367

        return None, None

   368

   369

    def ImportModuleLibrary(self, filepath):

   370

        if os.path.isfile(filepath):

   371

            shutil.copy(filepath, self.Path)

   372

            self.LoadModules()

   373

            return True

   374

        return False

   375

   380

        if os.path.exists(csvfile_path):

   381

            csvfile = open(csvfile_path, "rb")

   382

            sample = csvfile.read(1024)

   383

            csvfile.seek(0)

   384

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

   385

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

   386

            reader = csv.reader(csvfile, dialect)

   387

            for row in reader:

   388

                if has_header:

   389

                    has_header = False

   390

                else:

   391

                    try:

   395

                    except:

   396

                        pass

   397

            csvfile.close()

   402

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

   408

        csvfile.close()

   409

   411

        vendor = ExtractHexDecValue(vendor)

   412

        product_code = ExtractHexDecValue(product_code)

   413

        revision_number = ExtractHexDecValue(revision_number)

   414

   419

        vendor = ExtractHexDecValue(vendor)

   420

        product_code = ExtractHexDecValue(product_code)

   421

        revision_number = ExtractHexDecValue(revision_number)

   422

   423

        if self.ParentLibrary is not None:

   434

   435

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

   436

if wx.Platform != '__WXMSW__':

   437

    USERDATA_DIR += '_files'

   438

   439

ModulesDatabase = ModulesLibrary(

   440

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

   441

   442

class RootClass:

   443

   444

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

   445

    EditorType = LibraryEditor

   446

   447

    def __init__(self):

   448

        self.ModulesLibrary = None

   449

        self.LoadModulesLibrary()

   450

   451

    def GetModulesLibraryPath(self, project_path=None):

   452

        if project_path is None:

   453

            project_path = self.CTNPath()

   454

        return os.path.join(project_path, "modules") 

   455

   456

    def OnCTNSave(self, from_project_path=None):

   457

        if from_project_path is not None:

   458

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   459

                            self.GetModulesLibraryPath())

   460

        return True

   461

   462

    def CTNGenerate_C(self, buildpath, locations):

   463

        return [],"",False

   464

   465

    def LoadModulesLibrary(self):

   466

        if self.ModulesLibrary is None:

   467

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

   468

        else:

   469

            self.ModulesLibrary.LoadModulesLibrary()

   470

   471

    def GetModulesDatabaseInstance(self):

   472

        return ModulesDatabase

   473

   474

    def GetModulesLibraryInstance(self):

   475

        return self.ModulesLibrary

   476

   477

    def GetModulesLibrary(self, profile_filter=None):

   478

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   479

   480

    def GetVendors(self):

   481

        return self.ModulesLibrary.GetVendors()

   482

   483

    def GetModuleInfos(self, module_infos):

   484

        return self.ModulesLibrary.GetModuleInfos(module_infos)

   485

   486