1

import os, shutil

     2

from lxml import etree

     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

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

    17

    18

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

    19

#                 Ethercat ConfNode

    20

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

    21

    22

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

    23

EtherCATInfo_XPath = lambda xpath: etree.XPath(xpath)

    24

    25

def extract_param(el):

    26

    if el.tag == "Index":

    27

        return "#x%4.4X" % int(el.text)

    33

        if el.text is None:

    34

            return ""

    35

        return el.text.upper()

    36

    if el.text is None:

    37

        return ""

    38

    return el.text

    39

    40

def extract_pdo_infos(pdo_infos):

    41

    return {

    42

        pdo_infos.tag + " " + el.tag: extract_param(el)

    43

        for el in pdo_infos}

    44

    45

def HexDecValue(ctxt, values):

    46

    return str(ExtractHexDecValue(values[0]))

    47

    48

def EntryName(ctxt, values):

    49

    default=None

    50

    names = []

    51

    for element in values:

    52

        if element.tag == "Default":

    53

            default = element.text

    54

        else:

    55

            names.append(element)

    56

    return ExtractName(names, default)

    57

    58

class AddEntry(etree.XSLTExtension):

    59

    60

    def __init__(self, entries):

    61

        etree.XSLTExtension.__init__(self)

    62

        self.Entries = entries

    63

    64

    def execute(self, context, self_node, input_node, output_parent):

    65

        infos = etree.Element('entry_infos')

    66

        self.process_children(context, infos)

    67

        index, subindex = map(

    68

            lambda x: int(infos.find(x).text),

    69

            ["Index", "SubIndex"])

    70

        new_entry_infos = {

    71

            el.tag: extract_param(el)

    72

            for el in infos if el.tag != "PDO"}

    73

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

    74

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

    75

            if entry_infos is not None:

    76

                PDO_infos = infos.find("PDO")

    77

                if PDO_infos is not None:

    78

                    entry_infos.update(extract_pdo_infos(PDO_infos))

    79

            else:

    80

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

    81

    82

entries_list_xslt = etree.parse(

    83

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

    84

    85

cls = EtherCATInfoParser.GetElementClass("DeviceType")

    86

if cls:

    87

    88

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

    89

    def GetProfileNumbers(self):

    90

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

    91

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    92

    93

    def getCoE(self):

    94

        mailbox = self.getMailbox()

    95

        if mailbox is not None:

    96

            return mailbox.getCoE()

    97

        return None

    98

    setattr(cls, "getCoE", getCoE)

    99

   100

    def GetEntriesList(self, limits=None):

   101

        entries = {}

   102

   103

        entries_list_xslt_tree = etree.XSLT(

   104

            entries_list_xslt, extensions = {

   105

                ("entries_list_ns", "add_entry"): AddEntry(entries),

   106

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

   107

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

   108

        entries_list_xslt_tree(self, **dict(zip(

   109

            ["min_index", "max_index"], 

   110

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

   111

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

   112

            )))

   113

   114

        return entries

   115

    setattr(cls, "GetEntriesList", GetEntriesList)

   116

   117

    def GetSyncManagers(self):

   118

        sync_managers = []

   119

        for sync_manager in self.getSm():

   120

            sync_manager_infos = {}

   121

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

   122

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

   123

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

   124

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

   125

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

   126

                if value is None:

   127

                    value =""

   128

                sync_manager_infos[name] = value

   129

            sync_managers.append(sync_manager_infos)

   130

        return sync_managers

   131

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   132

   133

def GroupItemCompare(x, y):

   134

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

   135

        if x["type"] == ETHERCAT_GROUP:

   136

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

   137

        else:

   138

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

   139

    elif x["type"] == ETHERCAT_GROUP:

   140

        return -1

   141

    return 1

   142

   143

def SortGroupItems(group):

   144

    for item in group["children"]:

   145

        if item["type"] == ETHERCAT_GROUP:

   146

            SortGroupItems(item)

   147

    group["children"].sort(GroupItemCompare)

   148

   149

class ModulesLibrary:

   150

   151

    MODULES_EXTRA_PARAMS = [

   152

        ("pdo_alignment", {

   153

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

   154

            "column_size": 150,

   155

            "default": 8,

   156

            "description": _(

   157

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

   158

        ("max_pdo_size", {

   159

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

   160

            "column_size": 150,

   161

            "default": 255,

   162

            "description": _(

   163

"""Maximal number of entries mapped in a PDO

   164

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

   165

        ("add_pdo", {

   166

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

   167

            "column_size": 150,

   168

            "default": 0,

   169

            "description": _(

   170

"""Adding a PDO not defined in default configuration

   171

for mapping needed location variables

   172

(1 if possible)""")})

   173

    ]

   174

   175

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

   176

        self.Path = path

   177

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

   178

            os.makedirs(self.Path)

   179

        self.ParentLibrary = parent_library

   180

   181

        if parent_library is not None:

   182

            self.LoadModules()

   183

        else:

   184

            self.Library = None

   185

        self.LoadModulesExtraParams()

   186

   187

    def GetPath(self):

   188

        return self.Path

   189

   190

    def GetModulesExtraParamsFilePath(self):

   191

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

   192

   193

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

   194

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

   195

    def LoadModules(self):

   196

        self.Library = {}

   197

   198

        files = os.listdir(self.Path)

   199

        for file in files:

   200

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

   201

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

   202

                self.modules_infos = None

   203

   204

                xmlfile = open(filepath, 'r')

   205

                try:

   206

                    self.modules_infos = etree.fromstring(

   207

                        xmlfile.read(), EtherCATInfoParser)

   208

                except:

   209

                    pass

   210

                xmlfile.close()

   211

   212

                if self.modules_infos is not None:

   213

                    vendor = self.modules_infos.getVendor()

   214

   215

                    vendor_category = self.Library.setdefault(

   216

                        ExtractHexDecValue(vendor.getId()), 

   217

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

   218

                         "groups": {}})

   219

   220

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

   221

                        group_type = group.getType()

   222

   223

                        vendor_category["groups"].setdefault(group_type, 

   224

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

   225

                             "parent": group.getParentGroup(),

   226

                             "order": group.getSortOrder(), 

   227

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

   228

                             "devices": []})

   229

   230

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

   231

                        device_group = device.getGroupType()

   232

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

   233

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

   234

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

   235

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

   236

   237

        return self.Library 

   238

   239

    def GetModulesLibrary(self, profile_filter=None):

   240

        if self.Library is None:

   241

            self.LoadModules()

   242

        library = []

   243

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

   244

            groups = []

   245

            children_dict = {}

   246

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

   247

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

   248

                               "order": group["order"],

   249

                               "type": ETHERCAT_GROUP,

   250

                               "infos": None,

   251

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

   252

                device_dict = {}

   253

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

   254

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

   255

                        product_code = device.getType().getProductCode()

   256

                        revision_number = device.getType().getRevisionNo()

   257

                        module_infos = {"device_type": device_type,

   258

                                        "vendor": vendor_id,

   259

                                        "product_code": product_code,

   260

                                        "revision_number": revision_number}

   261

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

   262

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

   263

                                        "type": ETHERCAT_DEVICE,

   264

                                        "infos": module_infos,

   265

                                        "children": []}

   266

                        group_infos["children"].append(device_infos)

   267

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   268

                        device_type_occurrences.append(device_infos)

   269

                for device_type_occurrences in device_dict.itervalues():

   270

                    if len(device_type_occurrences) > 1:

   271

                        for occurrence in device_type_occurrences:

   272

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

   273

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

   274

                    if group["parent"] is not None:

   275

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

   276

                        parent_children.append(group_infos)

   277

                    else:

   278

                        groups.append(group_infos)

   279

            if len(groups) > 0:

   280

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

   281

                                "type": ETHERCAT_VENDOR,

   282

                                "infos": None,

   283

                                "children": groups})

   284

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

   285

        return library

   286

   287

    def GetVendors(self):

   288

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

   289

   290

    def GetModuleInfos(self, module_infos):

   291

        vendor = ExtractHexDecValue(module_infos["vendor"])

   292

        vendor_infos = self.Library.get(vendor)

   293

        if vendor_infos is not None:

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

                        self.cntdevice = device_infos 

   301

                        self.cntdeviceType = device_type  

   302

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

   303

        return None, None

   304

   305

    def ImportModuleLibrary(self, filepath):

   306

        if os.path.isfile(filepath):

   307

            shutil.copy(filepath, self.Path)

   308

            self.LoadModules()

   309

            return True

   310

        return False

   311

   312

    def LoadModulesExtraParams(self):

   313

        self.ModulesExtraParams = {}

   314

   315

        csvfile_path = self.GetModulesExtraParamsFilePath()

   316

        if os.path.exists(csvfile_path):

   317

            csvfile = open(csvfile_path, "rb")

   318

            sample = csvfile.read(1024)

   319

            csvfile.seek(0)

   320

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

   321

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

   322

            reader = csv.reader(csvfile, dialect)

   323

            for row in reader:

   324

                if has_header:

   325

                    has_header = False

   326

                else:

   327

                    params_values = {}

   328

                    for (param, param_infos), value in zip(

   329

                        self.MODULES_EXTRA_PARAMS, row[3:]):

   330

                        if value != "":

   331

                            params_values[param] = int(value)

   332

                    self.ModulesExtraParams[

   333

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

   334

            csvfile.close()

   335

   336

    def SaveModulesExtraParams(self):

   337

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

   338

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

   339

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

   340

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

   341

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

   342

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

   343

                            [module_extra_params.get(param, '') 

   344

                             for param in extra_params])

   345

        csvfile.close()

   346

   347

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

   348

        vendor = ExtractHexDecValue(vendor)

   349

        product_code = ExtractHexDecValue(product_code)

   350

        revision_number = ExtractHexDecValue(revision_number)

   351

   352

        module_infos = (vendor, product_code, revision_number)

   353

        self.ModulesExtraParams.setdefault(module_infos, {})

   354

        self.ModulesExtraParams[module_infos][param] = value

   355

   356

        self.SaveModulesExtraParams()

   357

   358

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

   359

        vendor = ExtractHexDecValue(vendor)

   360

        product_code = ExtractHexDecValue(product_code)

   361

        revision_number = ExtractHexDecValue(revision_number)

   362

   363

        if self.ParentLibrary is not None:

   364

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

   365

        else:

   366

            extra_params = {}

   367

   368

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

   369

   370

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   371

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

   372

   373

        return extra_params

   374

   375

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

   376

if wx.Platform != '__WXMSW__':

   377

    USERDATA_DIR += '_files'

   378

   379

ModulesDatabase = ModulesLibrary(

   380

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

   381

   382

class RootClass:

   383

   384

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

   385

    EditorType = LibraryEditor

   386

   387

   388

    def __init__(self):

   389

        self.ModulesLibrary = None

   390

        self.LoadModulesLibrary()

   391

   392

    def GetIconName(self):

   393

        return "Ethercat"

   394

   395

    def GetModulesLibraryPath(self, project_path=None):

   396

        if project_path is None:

   397

            project_path = self.CTNPath()

   398

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

   399

   400

    def OnCTNSave(self, from_project_path=None):

   401

        if from_project_path is not None:

   402

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   403

                            self.GetModulesLibraryPath())

   404

        return True

   405

   406

    def CTNGenerate_C(self, buildpath, locations):

   407

        return [],"",False

   408

   409

    def LoadModulesLibrary(self):

   410

        if self.ModulesLibrary is None:

   411

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

   412

        else:

   413

            self.ModulesLibrary.LoadModulesLibrary()

   414

   415

    def GetModulesDatabaseInstance(self):

   416

        return ModulesDatabase

   417

   418

    def GetModulesLibraryInstance(self):

   419

        return self.ModulesLibrary

   420

   421

    def GetModulesLibrary(self, profile_filter=None):

   422

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   423

   424

    def GetVendors(self):

   425

        return self.ModulesLibrary.GetVendors()

   426

   427

    def GetModuleInfos(self, module_infos):

   428

        return self.ModulesLibrary.GetModuleInfos(module_infos)

   429