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

    13

import shutil

    14

from lxml import etree

    15

    16

import wx

    17

import csv

    18

    19

from xmlclass import *

    20

    21

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    22

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

    23

    24

from EthercatSlave import ExtractHexDecValue, ExtractName

    25

from EthercatMaster import _EthercatCTN

    26

from ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    27

    28

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

    29

    30

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

    31

#                 Ethercat ConfNode

    32

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

    33

    34

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

    35

    36

    37

def EtherCATInfo_XPath(xpath):

    38

    return etree.XPath(xpath)

    39

    40

    41

def HexDecValue(context, *args):

    42

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

    43

    44

    45

def EntryName(context, *args):

    47

    48

    49

ENTRY_INFOS_KEYS = [

    50

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

    51

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

    52

    ("Name", str, ""),

    53

    ("Type", str, ""),

    54

    ("BitSize", int, 0),

    55

    ("Access", str, ""),

    56

    ("PDOMapping", str, ""),

    57

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

    58

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

    59

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

    60

    61

    62

class EntryListFactory:

    63

    64

    def __init__(self, entries):

    65

        self.Entries = entries

    66

    67

    def AddEntry(self, context, *args):

    68

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

    69

        new_entry_infos = {

    70

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

    71

            for (key, translate, default), arg

    72

            in zip(ENTRY_INFOS_KEYS, args)}

    73

    74

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

    75

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

    76

            if entry_infos is not None:

    77

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

    78

                    value = new_entry_infos.get(param)

    79

                    if value is not None:

    80

                        entry_infos[param] = value

    81

            else:

    82

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

    83

    84

    85

entries_list_xslt = etree.parse(

    86

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

    87

    88

cls = EtherCATInfoParser.GetElementClass("DeviceType")

    89

if cls:

    90

    91

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

    92

    def GetProfileNumbers(self):

    93

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

    94

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    95

    96

    def getCoE(self):

    97

        mailbox = self.getMailbox()

    98

        if mailbox is not None:

    99

            return mailbox.getCoE()

   100

        return None

   101

    setattr(cls, "getCoE", getCoE)

   102

   103

    def GetEntriesList(self, limits=None):

   104

        entries = {}

   105

   106

        factory = EntryListFactory(entries)

   107

   108

        entries_list_xslt_tree = etree.XSLT(

   109

            entries_list_xslt, extensions={

   110

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

   111

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

   112

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

   113

        entries_list_xslt_tree(self, **dict(zip(

   114

            ["min_index", "max_index"],

   115

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

   116

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

   117

            )))

   118

   119

        return entries

   120

    setattr(cls, "GetEntriesList", GetEntriesList)

   121

   122

    def GetSyncManagers(self):

   123

        sync_managers = []

   124

        for sync_manager in self.getSm():

   125

            sync_manager_infos = {}

   126

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

   127

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

   128

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

   129

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

   130

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

   131

                if value is None:

   132

                    value = ""

   133

                sync_manager_infos[name] = value

   134

            sync_managers.append(sync_manager_infos)

   135

        return sync_managers

   136

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   137

   138

   139

def GroupItemCompare(x, y):

   140

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

   141

        if x["type"] == ETHERCAT_GROUP:

   142

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

   143

        else:

   144

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

   145

    elif x["type"] == ETHERCAT_GROUP:

   146

        return -1

   147

    return 1

   148

   149

   150

def SortGroupItems(group):

   151

    for item in group["children"]:

   152

        if item["type"] == ETHERCAT_GROUP:

   153

            SortGroupItems(item)

   154

    group["children"].sort(GroupItemCompare)

   155

   156

   157

class ModulesLibrary:

   158

   159

    MODULES_EXTRA_PARAMS = [

   160

        ("pdo_alignment", {

   161

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

   162

            "column_size": 150,

   163

            "default": 8,

   164

            "description": _(

   165

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

   166

        ("max_pdo_size", {

   167

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

   168

            "column_size": 150,

   169

            "default": 255,

   170

            "description": _(

   171

"""Maximal number of entries mapped in a PDO

   172

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

   173

        ("add_pdo", {

   174

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

   175

            "column_size": 150,

   176

            "default": 0,

   177

            "description": _(

   178

"""Adding a PDO not defined in default configuration

   179

for mapping needed location variables

   180

(1 if possible)""")})

   181

    ]

   182

   183

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

   184

        self.Path = path

   185

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

   186

            os.makedirs(self.Path)

   187

        self.ParentLibrary = parent_library

   188

   189

        if parent_library is not None:

   190

            self.LoadModules()

   191

        else:

   192

            self.Library = None

   193

        self.LoadModulesExtraParams()

   194

   195

    def GetPath(self):

   196

        return self.Path

   197

   198

    def GetModulesExtraParamsFilePath(self):

   199

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

   200

   201

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

   202

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

   203

    def LoadModules(self):

   204

        self.Library = {}

   205

   206

        files = os.listdir(self.Path)

   207

        for file in files:

   208

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

   209

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

   210

                self.modules_infos = None

   211

   212

                xmlfile = open(filepath, 'r')

   213

                try:

   214

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

   215

                    if error is not None:

   216

                        self.GetCTRoot().logger.write_warning(

   217

                            XSDSchemaErrorMessage % (filepath + error))

   218

                except Exception, exc:

   219

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

   220

                xmlfile.close()

   221

   222

                if self.modules_infos is not None:

   223

                    vendor = self.modules_infos.getVendor()

   224

   225

                    vendor_category = self.Library.setdefault(

   226

                        ExtractHexDecValue(vendor.getId()),

   227

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

   228

                         "groups": {}})

   229

   230

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

   231

                        group_type = group.getType()

   232

   242

   243

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

   244

                        device_group = device.getGroupType()

   245

                        if device_group not in vendor_category["groups"]:

   246

                            raise ValueError("Not such group \"%\"" % device_group)

   247

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

   248

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

   249

   250

                else:

   251

   252

                    self.GetCTRoot().logger.write_error(

   253

                        _("Couldn't load %s XML file:\n%s") % (filepath, error))

   254

   255

        return self.Library

   256

   257

    def GetModulesLibrary(self, profile_filter=None):

   258

        if self.Library is None:

   259

            self.LoadModules()

   260

        library = []

   261

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

   262

            groups = []

   263

            children_dict = {}

   264

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

   265

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

   266

                               "order": group["order"],

   267

                               "type": ETHERCAT_GROUP,

   268

                               "infos": None,

   269

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

   270

                device_dict = {}

   271

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

   272

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

   273

                        product_code = device.getType().getProductCode()

   274

                        revision_number = device.getType().getRevisionNo()

   275

                        module_infos = {"device_type": device_type,

   276

                                        "vendor": vendor_id,

   277

                                        "product_code": product_code,

   278

                                        "revision_number": revision_number}

   279

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

   280

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

   281

                                        "type": ETHERCAT_DEVICE,

   282

                                        "infos": module_infos,

   283

                                        "children": []}

   284

                        group_infos["children"].append(device_infos)

   285

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   286

                        device_type_occurrences.append(device_infos)

   287

                for device_type_occurrences in device_dict.itervalues():

   288

                    if len(device_type_occurrences) > 1:

   289

                        for occurrence in device_type_occurrences:

   290

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

   291

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

   292

                    if group["parent"] is not None:

   293

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

   294

                        parent_children.append(group_infos)

   295

                    else:

   296

                        groups.append(group_infos)

   297

            if len(groups) > 0:

   298

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

   299

                                "type": ETHERCAT_VENDOR,

   300

                                "infos": None,

   301

                                "children": groups})

   302

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

   303

        return library

   304

   305

    def GetVendors(self):

   306

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

   307

   308

    def GetModuleInfos(self, module_infos):

   309

        vendor = ExtractHexDecValue(module_infos["vendor"])

   310

        vendor_infos = self.Library.get(vendor)

   311

        if vendor_infos is not None:

   312

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

   313

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

   314

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

   315

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

   316

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

   317

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

   318

                        self.cntdevice = device_infos

   319

                        self.cntdeviceType = device_type

   320

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

   321

        return None, None

   322

   323

    def ImportModuleLibrary(self, filepath):

   324

        if os.path.isfile(filepath):

   325

            shutil.copy(filepath, self.Path)

   326

            self.LoadModules()

   327

            return True

   328

        return False

   329

   330

    def LoadModulesExtraParams(self):

   331

        self.ModulesExtraParams = {}

   332

   333

        csvfile_path = self.GetModulesExtraParamsFilePath()

   334

        if os.path.exists(csvfile_path):

   335

            csvfile = open(csvfile_path, "rb")

   336

            sample = csvfile.read(1024)

   337

            csvfile.seek(0)

   338

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

   339

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

   340

            reader = csv.reader(csvfile, dialect)

   341

            for row in reader:

   342

                if has_header:

   343

                    has_header = False

   344

                else:

   345

                    params_values = {}

   346

                    for (param, param_infos), value in zip(

   347

                            self.MODULES_EXTRA_PARAMS, row[3:]):

   348

                        if value != "":

   349

                            params_values[param] = int(value)

   350

                    self.ModulesExtraParams[

   351

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

   352

            csvfile.close()

   353

   354

    def SaveModulesExtraParams(self):

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

                            [module_extra_params.get(param, '')

   362

                             for param in extra_params])

   363

        csvfile.close()

   364

   365

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

   366

        vendor = ExtractHexDecValue(vendor)

   367

        product_code = ExtractHexDecValue(product_code)

   368

        revision_number = ExtractHexDecValue(revision_number)

   369

   370

        module_infos = (vendor, product_code, revision_number)

   371

        self.ModulesExtraParams.setdefault(module_infos, {})

   372

        self.ModulesExtraParams[module_infos][param] = value

   373

   374

        self.SaveModulesExtraParams()

   375

   376

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

   377

        vendor = ExtractHexDecValue(vendor)

   378

        product_code = ExtractHexDecValue(product_code)

   379

        revision_number = ExtractHexDecValue(revision_number)

   380

   381

        if self.ParentLibrary is not None:

   382

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

   383

        else:

   384

            extra_params = {}

   385

   386

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

   387

   388

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   389

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

   390

   391

        return extra_params

   392

   393

   394

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

   395

if wx.Platform != '__WXMSW__':

   396

    USERDATA_DIR += '_files'

   397

   398

ModulesDatabase = ModulesLibrary(

   399

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

   400

   401

   402

class RootClass:

   403

   404

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

   405

    EditorType = LibraryEditor

   406

   407

    def __init__(self):

   408

        self.ModulesLibrary = None

   409

        self.LoadModulesLibrary()

   410

   411

    def GetIconName(self):

   412

        return "Ethercat"

   413

   414

    def GetModulesLibraryPath(self, project_path=None):

   415

        if project_path is None:

   416

            project_path = self.CTNPath()

   417

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

   418

   419

    def OnCTNSave(self, from_project_path=None):

   420

        if from_project_path is not None:

   421

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   422

                            self.GetModulesLibraryPath())

   423

        return True

   424

   425

    def CTNGenerate_C(self, buildpath, locations):

   426

        return [], "", False

   427

   428

    def LoadModulesLibrary(self):

   429

        if self.ModulesLibrary is None:

   430

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

   431

        else:

   432

            self.ModulesLibrary.LoadModulesLibrary()

   433

   434

    def GetModulesDatabaseInstance(self):

   435

        return ModulesDatabase

   436

   437

    def GetModulesLibraryInstance(self):

   438

        return self.ModulesLibrary

   439

   440

    def GetModulesLibrary(self, profile_filter=None):

   441

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   442

   443

    def GetVendors(self):

   444

        return self.ModulesLibrary.GetVendors()

   445

   446

    def GetModuleInfos(self, module_infos):

   447

        return self.ModulesLibrary.GetModuleInfos(module_infos)