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:

   236

   237

    MODULES_EXTRA_PARAMS = [

   238

        ("pdo_alignment", {

   239

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

   240

            "column_size": 150,

   241

            "default": 8,

   242

            "description": _(

   243

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

   244

        ("max_pdo_size", {

   245

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

   246

            "column_size": 150,

   247

            "default": 255,

   248

            "description": _(

   249

"""Maximal number of entries mapped in a PDO

   250

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

   251

        ("add_pdo", {

   252

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

   253

            "column_size": 150,

   254

            "default": 0,

   255

            "description": _(

   256

"""Adding a PDO not defined in default configuration

   257

for mapping needed location variables

   258

(1 if possible)""")})

   259

    ]

   260

   261

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

   262

        self.Path = path

   263

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

   264

            os.makedirs(self.Path)

   265

        self.ParentLibrary = parent_library

   266

   267

        if parent_library is not None:

   268

            self.LoadModules()

   269

        else:

   270

            self.Library = None

   271

        self.LoadModulesExtraParams()

   272

   273

    def GetPath(self):

   274

        return self.Path

   275

   276

    def GetModulesExtraParamsFilePath(self):

   277

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

   278

   279

    def LoadModules(self):

   280

        self.Library = {}

   281

   282

        files = os.listdir(self.Path)

   283

        for file in files:

   284

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

   285

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

   286

                xmlfile = open(filepath, 'r')

   287

                xml_tree = minidom.parse(xmlfile)

   288

                xmlfile.close()

   289

   290

                self.modules_infos = None

   291

                for child in xml_tree.childNodes:

   292

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

   293

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

   294

                        self.modules_infos.loadXMLTree(child)

   295

   296

                if self.modules_infos is not None:

   297

                    vendor = self.modules_infos.getVendor()

   298

   299

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

   300

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

   301

                                                               "groups": {}})

   302

   303

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

   304

                        group_type = group.getType()

   305

   306

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

   307

                                                                          "parent": group.getParentGroup(),

   308

                                                                          "order": group.getSortOrder(), 

   309

                                                                          "value": group.getcontent()["value"],

   310

                                                                          "devices": []})

   311

   312

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

   313

                        device_group = device.getGroupType()

   314

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

   315

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

   316

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

   317

   318

        return self.Library 

   319

   320

    def GetModulesLibrary(self, profile_filter=None):

   321

        if self.Library is None:

   322

            self.LoadModules()

   323

        library = []

   324

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

   325

            groups = []

   326

            children_dict = {}

   327

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

   328

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

   329

                               "order": group["order"],

   330

                               "type": ETHERCAT_GROUP,

   331

                               "infos": None,

   332

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

   333

                device_dict = {}

   334

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

   335

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

   336

                        product_code = device.getType().getProductCode()

   337

                        revision_number = device.getType().getRevisionNo()

   338

                        module_infos = {"device_type": device_type,

   339

                                        "vendor": vendor_id,

   340

                                        "product_code": product_code,

   341

                                        "revision_number": revision_number}

   342

                        module_infos.update(self.GetModuleExtraParams(vendor_id, product_code, revision_number))

   343

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

   344

                                        "type": ETHERCAT_DEVICE,

   345

                                        "infos": module_infos,

   346

                                        "children": []}

   347

                        group_infos["children"].append(device_infos)

   348

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   349

                        device_type_occurrences.append(device_infos)

   350

                for device_type_occurrences in device_dict.itervalues():

   351

                    if len(device_type_occurrences) > 1:

   352

                        for occurrence in device_type_occurrences:

   353

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

   354

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

   355

                    if group["parent"] is not None:

   356

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

   357

                        parent_children.append(group_infos)

   358

                    else:

   359

                        groups.append(group_infos)

   360

            if len(groups) > 0:

   361

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

   362

                                "type": ETHERCAT_VENDOR,

   363

                                "infos": None,

   364

                                "children": groups})

   365

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

   366

        return library

   367

   368

    def GetVendors(self):

   369

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

   370

   371

    def GetModuleInfos(self, module_infos):

   372

        vendor = ExtractHexDecValue(module_infos["vendor"])

   373

        vendor_infos = self.Library.get(vendor)

   374

        if vendor_infos is not None:

   375

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

   376

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

   377

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

   378

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

   379

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

   380

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

   381

                        self.cntdevice = device_infos 

   382

                        self.cntdeviceType = device_type  

   383

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

   384

        return None, None

   385

   386

    def ImportModuleLibrary(self, filepath):

   387

        if os.path.isfile(filepath):

   388

            shutil.copy(filepath, self.Path)

   389

            self.LoadModules()

   390

            return True

   391

        return False

   392

   393

    def LoadModulesExtraParams(self):

   394

        self.ModulesExtraParams = {}

   395

   396

        csvfile_path = self.GetModulesExtraParamsFilePath()

   397

        if os.path.exists(csvfile_path):

   398

            csvfile = open(csvfile_path, "rb")

   399

            sample = csvfile.read(1024)

   400

            csvfile.seek(0)

   401

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

   402

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

   403

            reader = csv.reader(csvfile, dialect)

   404

            for row in reader:

   405

                if has_header:

   406

                    has_header = False

   407

                else:

   408

                    params_values = {}

   409

                    for (param, param_infos), value in zip(

   410

                        self.MODULES_EXTRA_PARAMS, row[3:]):

   411

                        if value != "":

   412

                            params_values[param] = int(value)

   413

                    self.ModulesExtraParams[

   414

                        tuple(map(int, row[:3]))] = params_values

   415

            csvfile.close()

   416

   417

    def SaveModulesExtraParams(self):

   418

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

   419

        extra_params = [param for param, params_infos in self.MODULES_EXTRA_PARAMS]

   420

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

   421

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

   422

        for (vendor, product_code, revision_number), module_extra_params in self.ModulesExtraParams.iteritems():

   423

            writer.writerow([vendor, product_code, revision_number] + 

   424

                            [module_extra_params.get(param, '') 

   425

                             for param in extra_params])

   426

        csvfile.close()

   427

   428

    def SetModuleExtraParam(self, vendor, product_code, revision_number, param, value):

   429

        vendor = ExtractHexDecValue(vendor)

   430

        product_code = ExtractHexDecValue(product_code)

   431

        revision_number = ExtractHexDecValue(revision_number)

   432

   433

        module_infos = (vendor, product_code, revision_number)

   434

        self.ModulesExtraParams.setdefault(module_infos, {})

   435

        self.ModulesExtraParams[module_infos][param] = value

   436

   437

        self.SaveModulesExtraParams()

   438

   439

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

   440

        vendor = ExtractHexDecValue(vendor)

   441

        product_code = ExtractHexDecValue(product_code)

   442

        revision_number = ExtractHexDecValue(revision_number)

   443

   444

        if self.ParentLibrary is not None:

   445

            extra_params = self.ParentLibrary.GetModuleExtraParams(vendor, product_code, revision_number)

   446

        else:

   447

            extra_params = {}

   448

   449

        extra_params.update(self.ModulesExtraParams.get((vendor, product_code, revision_number), {}))

   450

   451

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   452

            extra_params.setdefault(param, param_infos["default"])

   453

   454

        return extra_params

   455

   456

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

   457

if wx.Platform != '__WXMSW__':

   458

    USERDATA_DIR += '_files'

   459

   460

ModulesDatabase = ModulesLibrary(

   461

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

   462

   463

class RootClass:

   464

   465

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

   466

    EditorType = LibraryEditor

   467

   468

   469

    def __init__(self):

   470

        self.ModulesLibrary = None

   471

        self.LoadModulesLibrary()

   472

   473

    def GetIconName(self):

   474

        return "Ethercat"

   475

   476

    def GetModulesLibraryPath(self, project_path=None):

   477

        if project_path is None:

   478

            project_path = self.CTNPath()

   479

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

   480

   481

    def OnCTNSave(self, from_project_path=None):

   482

        if from_project_path is not None:

   483

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   484

                            self.GetModulesLibraryPath())

   485

        return True

   486

   487

    def CTNGenerate_C(self, buildpath, locations):

   488

        return [],"",False

   489

   490

    def LoadModulesLibrary(self):

   491

        if self.ModulesLibrary is None:

   492

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