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

EtherCATInfo_XPath = lambda xpath: etree.XPath(xpath)

    36

    37

    38

def HexDecValue(context, *args):

    39

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

    40

    41

    42

def EntryName(context, *args):

    43

    return ExtractName(args[0],

    44

        args[1][0] if len(args) > 1 else None)

    45

    47

ENTRY_INFOS_KEYS = [

    48

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

    49

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

    50

    ("Name", str, ""),

    51

    ("Type", str, ""),

    52

    ("BitSize", int, 0),

    53

    ("Access", str, ""),

    54

    ("PDOMapping", str, ""),

    55

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

    56

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

    57

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

    58

    59

    60

class EntryListFactory:

    61

    62

    def __init__(self, entries):

    63

        self.Entries = entries

    64

    65

    def AddEntry(self, context, *args):

    66

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

    67

        new_entry_infos = {

    68

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

    69

            for (key, translate, default), arg

    70

            in zip(ENTRY_INFOS_KEYS, args)}

    71

    72

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

    73

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

    74

            if entry_infos is not None:

    75

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

    76

                    value = new_entry_infos.get(param)

    77

                    if value is not None:

    78

                        entry_infos[param] = value

    79

            else:

    80

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

    81

    83

entries_list_xslt = etree.parse(

    84

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

    85

    86

cls = EtherCATInfoParser.GetElementClass("DeviceType")

    87

if cls:

    88

    89

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

    90

    def GetProfileNumbers(self):

    91

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

    92

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    93

    94

    def getCoE(self):

    95

        mailbox = self.getMailbox()

    96

        if mailbox is not None:

    97

            return mailbox.getCoE()

    98

        return None

    99

    setattr(cls, "getCoE", getCoE)

   100

   101

    def GetEntriesList(self, limits=None):

   102

        entries = {}

   103

   104

        factory = EntryListFactory(entries)

   105

   106

        entries_list_xslt_tree = etree.XSLT(

   107

            entries_list_xslt, extensions={

   108

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

   109

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

   110

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

   111

        entries_list_xslt_tree(self, **dict(zip(

   112

            ["min_index", "max_index"],

   113

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

   114

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

   115

            )))

   116

   117

        return entries

   118

    setattr(cls, "GetEntriesList", GetEntriesList)

   119

   120

    def GetSyncManagers(self):

   121

        sync_managers = []

   122

        for sync_manager in self.getSm():

   123

            sync_manager_infos = {}

   124

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

   125

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

   126

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

   127

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

   128

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

   129

                if value is None:

   130

                    value = ""

   131

                sync_manager_infos[name] = value

   132

            sync_managers.append(sync_manager_infos)

   133

        return sync_managers

   134

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   135

   136

   137

def GroupItemCompare(x, y):

   138

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

   139

        if x["type"] == ETHERCAT_GROUP:

   140

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

   141

        else:

   142

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

   143

    elif x["type"] == ETHERCAT_GROUP:

   144

        return -1

   145

    return 1

   146

   147

   148

def SortGroupItems(group):

   149

    for item in group["children"]:

   150

        if item["type"] == ETHERCAT_GROUP:

   151

            SortGroupItems(item)

   152

    group["children"].sort(GroupItemCompare)

   153

   154

   155

class ModulesLibrary:

   156

   157

    MODULES_EXTRA_PARAMS = [

   158

        ("pdo_alignment", {

   159

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

   160

            "column_size": 150,

   161

            "default": 8,

   162

            "description": _(

   163

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

   164

        ("max_pdo_size", {

   165

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

   166

            "column_size": 150,

   167

            "default": 255,

   168

            "description": _(

   169

"""Maximal number of entries mapped in a PDO

   170

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

   171

        ("add_pdo", {

   172

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

   173

            "column_size": 150,

   174

            "default": 0,

   175

            "description": _(

   176

"""Adding a PDO not defined in default configuration

   177

for mapping needed location variables

   178

(1 if possible)""")})

   179

    ]

   180

   181

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

   182

        self.Path = path

   183

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

   184

            os.makedirs(self.Path)

   185

        self.ParentLibrary = parent_library

   186

   187

        if parent_library is not None:

   188

            self.LoadModules()

   189

        else:

   190

            self.Library = None

   191

        self.LoadModulesExtraParams()

   192

   193

    def GetPath(self):

   194

        return self.Path

   195

   196

    def GetModulesExtraParamsFilePath(self):

   197

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

   198

   199

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

   200

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

   201

    def LoadModules(self):

   202

        self.Library = {}

   203

   204

        files = os.listdir(self.Path)

   205

        for file in files:

   206

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

   207

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

   208

                self.modules_infos = None

   209

   210

                xmlfile = open(filepath, 'r')

   211

                try:

   212

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

   213

                    if error is not None:

   214

                        self.GetCTRoot().logger.write_warning(

   215

                            XSDSchemaErrorMessage % (filepath + error))

   216

                except Exception, exc:

   217

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

   218

                xmlfile.close()

   219

   220

                if self.modules_infos is not None:

   221

                    vendor = self.modules_infos.getVendor()

   222

   223

                    vendor_category = self.Library.setdefault(

   224

                        ExtractHexDecValue(vendor.getId()),

   225

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

   226

                         "groups": {}})

   227

   228

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

   229

                        group_type = group.getType()

   230

   231

                        vendor_category["groups"].setdefault(group_type,

   232

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

   233

                             "parent": group.getParentGroup(),

   234

                             "order": group.getSortOrder(),

   235

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

   236

                             "devices": []})

   237

   238

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

   239

                        device_group = device.getGroupType()

   240

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

   241

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

   242

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

   243

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

   244

   245

                else:

   246

   247

                    self.GetCTRoot().logger.write_error(

   248

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

   249

   250

        return self.Library

   251

   252

    def GetModulesLibrary(self, profile_filter=None):

   253

        if self.Library is None:

   254

            self.LoadModules()

   255

        library = []

   256

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

   257

            groups = []

   258

            children_dict = {}

   259

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

   260

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

   261

                               "order": group["order"],

   262

                               "type": ETHERCAT_GROUP,

   263

                               "infos": None,

   264

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

   265

                device_dict = {}

   266

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

   267

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

   268

                        product_code = device.getType().getProductCode()

   269

                        revision_number = device.getType().getRevisionNo()

   270

                        module_infos = {"device_type": device_type,

   271

                                        "vendor": vendor_id,

   272

                                        "product_code": product_code,

   273

                                        "revision_number": revision_number}

   274

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

   275

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

   276

                                        "type": ETHERCAT_DEVICE,

   277

                                        "infos": module_infos,

   278

                                        "children": []}

   279

                        group_infos["children"].append(device_infos)

   280

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   281

                        device_type_occurrences.append(device_infos)

   282

                for device_type_occurrences in device_dict.itervalues():

   283

                    if len(device_type_occurrences) > 1:

   284

                        for occurrence in device_type_occurrences:

   285

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

   286

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

   287

                    if group["parent"] is not None:

   288

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

   289

                        parent_children.append(group_infos)

   290

                    else:

   291

                        groups.append(group_infos)

   292

            if len(groups) > 0:

   293

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

   294

                                "type": ETHERCAT_VENDOR,

   295

                                "infos": None,

   296

                                "children": groups})

   297

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

   298

        return library

   299

   300

    def GetVendors(self):

   301

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

   302

   303

    def GetModuleInfos(self, module_infos):

   304

        vendor = ExtractHexDecValue(module_infos["vendor"])

   305

        vendor_infos = self.Library.get(vendor)

   306

        if vendor_infos is not None:

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

                        self.cntdevice = device_infos

   314

                        self.cntdeviceType = device_type

   315

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

   316

        return None, None

   317

   318

    def ImportModuleLibrary(self, filepath):

   319

        if os.path.isfile(filepath):

   320

            shutil.copy(filepath, self.Path)

   321

            self.LoadModules()

   322

            return True

   323

        return False

   324

   325

    def LoadModulesExtraParams(self):

   326

        self.ModulesExtraParams = {}

   327

   328

        csvfile_path = self.GetModulesExtraParamsFilePath()

   329

        if os.path.exists(csvfile_path):

   330

            csvfile = open(csvfile_path, "rb")

   331

            sample = csvfile.read(1024)

   332

            csvfile.seek(0)

   333

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

   334

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

   335

            reader = csv.reader(csvfile, dialect)

   336

            for row in reader:

   337

                if has_header:

   338

                    has_header = False

   339

                else:

   340

                    params_values = {}

   341

                    for (param, param_infos), value in zip(

   342

                        self.MODULES_EXTRA_PARAMS, row[3:]):

   343

                        if value != "":

   344

                            params_values[param] = int(value)

   345

                    self.ModulesExtraParams[

   346

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

   347

            csvfile.close()

   348

   349

    def SaveModulesExtraParams(self):

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

                            [module_extra_params.get(param, '')

   357

                             for param in extra_params])

   358

        csvfile.close()

   359

   360

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

   361

        vendor = ExtractHexDecValue(vendor)

   362

        product_code = ExtractHexDecValue(product_code)

   363

        revision_number = ExtractHexDecValue(revision_number)

   364

   365

        module_infos = (vendor, product_code, revision_number)

   366

        self.ModulesExtraParams.setdefault(module_infos, {})

   367

        self.ModulesExtraParams[module_infos][param] = value

   368

   369

        self.SaveModulesExtraParams()

   370

   371

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

   372

        vendor = ExtractHexDecValue(vendor)

   373

        product_code = ExtractHexDecValue(product_code)

   374

        revision_number = ExtractHexDecValue(revision_number)

   375

   376

        if self.ParentLibrary is not None:

   377

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

   378

        else:

   379

            extra_params = {}

   380

   381

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

   382

   383

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   384

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

   385

   386

        return extra_params

   387

   389

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

   390

if wx.Platform != '__WXMSW__':

   391

    USERDATA_DIR += '_files'

   392

   393

ModulesDatabase = ModulesLibrary(

   394

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

   395

   396

   397

class RootClass:

   398

   399

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

   400

    EditorType = LibraryEditor

   401

   402

    def __init__(self):

   403

        self.ModulesLibrary = None

   404

        self.LoadModulesLibrary()

   405

   406

    def GetIconName(self):

   407

        return "Ethercat"

   408

   409

    def GetModulesLibraryPath(self, project_path=None):

   410

        if project_path is None:

   411

            project_path = self.CTNPath()

   412

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

   413

   414

    def OnCTNSave(self, from_project_path=None):

   415

        if from_project_path is not None:

   416

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   417

                            self.GetModulesLibraryPath())

   418

        return True

   419

   420

    def CTNGenerate_C(self, buildpath, locations):

   421

        return [], "", False

   422

   423

    def LoadModulesLibrary(self):

   424

        if self.ModulesLibrary is None:

   425

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

   426

        else:

   427

            self.ModulesLibrary.LoadModulesLibrary()

   428

   429

    def GetModulesDatabaseInstance(self):

   430

        return ModulesDatabase

   431

   432

    def GetModulesLibraryInstance(self):

   433

        return self.ModulesLibrary

   434

   435

    def GetModulesLibrary(self, profile_filter=None):

   436

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   437

   438

    def GetVendors(self):

   439

        return self.ModulesLibrary.GetVendors()

   440

   441

    def GetModuleInfos(self, module_infos):

   442

        return self.ModulesLibrary.GetModuleInfos(module_infos)