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

from __future__ import absolute_import

    13

import os

    14

import shutil

    15

import csv

    16

from builtins import str as text

    17

    18

from lxml import etree

    19

import wx

    20

    21

from xmlclass import *

    22

    23

from ConfigTreeNode import XSDSchemaErrorMessage

    24

    25

from etherlab.EthercatSlave import ExtractHexDecValue, ExtractName

    26

from etherlab.EthercatMaster import _EthercatCTN

    27

from etherlab.ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    28

    29

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

    30

    31

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

    32

#                 Ethercat ConfNode

    33

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

    34

    35

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

    36

    37

    38

def EtherCATInfo_XPath(xpath):

    39

    return etree.XPath(xpath)

    40

    41

    42

def HexDecValue(context, *args):

    43

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

    44

    45

    46

def EntryName(context, *args):

    47

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

    48

    49

    50

ENTRY_INFOS_KEYS = [

    51

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

    52

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

    53

    ("Name", str, ""),

    54

    ("Type", str, ""),

    55

    ("BitSize", int, 0),

    56

    ("Access", str, ""),

    57

    ("PDOMapping", str, ""),

    58

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

    59

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

    60

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

    61

    62

    63

class EntryListFactory(object):

    64

    65

    def __init__(self, entries):

    66

        self.Entries = entries

    67

    68

    def AddEntry(self, context, *args):

    69

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

    70

        new_entry_infos = {

    71

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

    72

            for (key, translate, default), arg

    73

            in zip(ENTRY_INFOS_KEYS, args)}

    74

    75

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

    76

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

    77

            if entry_infos is not None:

    78

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

    79

                    value = new_entry_infos.get(param)

    80

                    if value is not None:

    81

                        entry_infos[param] = value

    82

            else:

    83

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

    84

    85

    86

entries_list_xslt = etree.parse(

    87

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

    88

    89

cls = EtherCATInfoParser.GetElementClass("DeviceType")

    90

if cls:

    91

    92

    profile_numbers_xpath = EtherCATInfo_XPath("Profile/ProfileNo")

    93

    94

    def GetProfileNumbers(self):

    95

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

    96

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    97

    98

    def getCoE(self):

    99

        mailbox = self.getMailbox()

   100

        if mailbox is not None:

   101

            return mailbox.getCoE()

   102

        return None

   103

    setattr(cls, "getCoE", getCoE)

   104

   105

    def GetEntriesList(self, limits=None):

   106

        entries = {}

   107

   108

        factory = EntryListFactory(entries)

   109

   110

        entries_list_xslt_tree = etree.XSLT(

   111

            entries_list_xslt, extensions={

   112

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

   113

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

   114

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

   115

        entries_list_xslt_tree(self, **dict(zip(

   116

            ["min_index", "max_index"],

   117

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

   118

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

   119

            )))

   120

   121

        return entries

   122

    setattr(cls, "GetEntriesList", GetEntriesList)

   123

   124

    def GetSyncManagers(self):

   125

        sync_managers = []

   126

        for sync_manager in self.getSm():

   127

            sync_manager_infos = {}

   128

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

   129

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

   130

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

   131

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

   132

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

   133

                if value is None:

   134

                    value = ""

   135

                sync_manager_infos[name] = value

   136

            sync_managers.append(sync_manager_infos)

   137

        return sync_managers

   138

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   139

   140

   141

def GroupItemCompare(x, y):

   142

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

   143

        if x["type"] == ETHERCAT_GROUP:

   144

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

   145

        else:

   146

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

   147

    elif x["type"] == ETHERCAT_GROUP:

   148

        return -1

   149

    return 1

   150

   151

   152

def SortGroupItems(group):

   153

    for item in group["children"]:

   154

        if item["type"] == ETHERCAT_GROUP:

   155

            SortGroupItems(item)

   156

    group["children"].sort(GroupItemCompare)

   157

   158

   159

class ModulesLibrary(object):

   160

   161

    MODULES_EXTRA_PARAMS = [

   162

        (

   163

            "pdo_alignment",

   164

            {

   165

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

   166

                "column_size": 150,

   167

                "default": 8,

   168

                "description": _("Minimal size in bits between 2 pdo entries")

   169

            }

   170

        ),

   171

        (

   172

            "max_pdo_size",

   173

            {

   174

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

   175

                "column_size": 150,

   176

                "default": 255,

   177

                "description": _("""Maximal number of entries mapped in a PDO

   178

including empty entries used for PDO alignment""")

   179

            }

   180

        ),

   181

        (

   182

            "add_pdo",

   183

            {

   184

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

   185

                "column_size": 150,

   186

                "default": 0,

   187

                "description": _("""Adding a PDO not defined in default configuration

   188

for mapping needed location variables

   189

(1 if possible)""")

   190

            }

   191

        )

   192

    ]

   193

   194

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

   195

        self.Path = path

   196

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

   197

            os.makedirs(self.Path)

   198

        self.ParentLibrary = parent_library

   199

   200

        if parent_library is not None:

   201

            self.LoadModules()

   202

        else:

   203

            self.Library = None

   204

        self.LoadModulesExtraParams()

   205

   206

    def GetPath(self):

   207

        return self.Path

   208

   209

    def GetModulesExtraParamsFilePath(self):

   210

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

   211

   212

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

   213

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

   214

   215

    def LoadModules(self):

   216

        self.Library = {}

   217

   218

        files = os.listdir(self.Path)

   219

        for file in files:

   220

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

   221

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

   222

                self.modules_infos = None

   223

   224

                xmlfile = open(filepath, 'r')

   225

                try:

   226

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

   227

                    if error is not None:

   228

                        self.GetCTRoot().logger.write_warning(

   229

                            XSDSchemaErrorMessage % (filepath + error))

   230

                except Exception as exc:

   231

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

   232

                xmlfile.close()

   233

   234

                if self.modules_infos is not None:

   235

                    vendor = self.modules_infos.getVendor()

   236

   237

                    vendor_category = self.Library.setdefault(

   238

                        ExtractHexDecValue(vendor.getId()),

   239

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

   240

                         "groups": {}})

   241

   242

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

   243

                        group_type = group.getType()

   244

   245

                        vendor_category["groups"].setdefault(

   246

                            group_type,

   247

                            {

   248

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

   249

                                "parent": group.getParentGroup(),

   250

                                "order": group.getSortOrder(),

   251

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

   252

                                "devices": [],

   253

                            })

   254

   255

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

   256

                        device_group = device.getGroupType()

   257

                        if device_group not in vendor_category["groups"]:

   258

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

   259

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

   260

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

   261

   262

                else:

   263

   264

                    self.GetCTRoot().logger.write_error(

   265

                        _("Couldn't load {a1} XML file:\n{a2}").format(a1=filepath, a2=error))

   266

   267

        return self.Library

   268

   269

    def GetModulesLibrary(self, profile_filter=None):

   270

        if self.Library is None:

   271

            self.LoadModules()

   272

        library = []

   273

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

   274

            groups = []

   275

            children_dict = {}

   276

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

   277

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

   278

                               "order": group["order"],

   279

                               "type": ETHERCAT_GROUP,

   280

                               "infos": None,

   281

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

   282

                device_dict = {}

   283

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

   284

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

   285

                        product_code = device.getType().getProductCode()

   286

                        revision_number = device.getType().getRevisionNo()

   287

                        module_infos = {"device_type": device_type,

   288

                                        "vendor": vendor_id,

   289

                                        "product_code": product_code,

   290

                                        "revision_number": revision_number}

   291

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

   292

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

   293

                                        "type": ETHERCAT_DEVICE,

   294

                                        "infos": module_infos,

   295

                                        "children": []}

   296

                        group_infos["children"].append(device_infos)

   297

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   298

                        device_type_occurrences.append(device_infos)

   299

                for device_type_occurrences in device_dict.itervalues():

   300

                    if len(device_type_occurrences) > 1:

   301

                        for occurrence in device_type_occurrences:

   302

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

   303

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

   304

                    if group["parent"] is not None:

   305

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

   306

                        parent_children.append(group_infos)

   307

                    else:

   308

                        groups.append(group_infos)

   309

            if len(groups) > 0:

   310

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

   311

                                "type": ETHERCAT_VENDOR,

   312

                                "infos": None,

   313

                                "children": groups})

   314

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

   315

        return library

   316

   317

    def GetVendors(self):

   318

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

   319

   320

    def GetModuleInfos(self, module_infos):

   321

        vendor = ExtractHexDecValue(module_infos["vendor"])

   322

        vendor_infos = self.Library.get(vendor)

   323

        if vendor_infos is not None:

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

                        self.cntdevice = device_infos

   331

                        self.cntdeviceType = device_type

   332

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

   333

        return None, None

   334

   335

    def ImportModuleLibrary(self, filepath):

   336

        if os.path.isfile(filepath):

   337

            shutil.copy(filepath, self.Path)

   338

            self.LoadModules()

   339

            return True

   340

        return False

   341

   342

    def LoadModulesExtraParams(self):

   343

        self.ModulesExtraParams = {}

   344

   345

        csvfile_path = self.GetModulesExtraParamsFilePath()

   346

        if os.path.exists(csvfile_path):

   347

            csvfile = open(csvfile_path, "rb")

   348

            sample = csvfile.read(1024)

   349

            csvfile.seek(0)

   350

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

   351

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

   352

            reader = csv.reader(csvfile, dialect)

   353

            for row in reader:

   354

                if has_header:

   355

                    has_header = False

   356

                else:

   357

                    params_values = {}

   358

                    for (param, _param_infos), value in zip(

   359

                            self.MODULES_EXTRA_PARAMS, row[3:]):

   360

                        if value != "":

   361

                            params_values[param] = int(value)

   362

                    self.ModulesExtraParams[

   363

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

   364

            csvfile.close()

   365

   366

    def SaveModulesExtraParams(self):

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

                            [module_extra_params.get(param, '')

   374

                             for param in extra_params])

   375

        csvfile.close()

   376

   377

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

   378

        vendor = ExtractHexDecValue(vendor)

   379

        product_code = ExtractHexDecValue(product_code)

   380

        revision_number = ExtractHexDecValue(revision_number)

   381

   382

        module_infos = (vendor, product_code, revision_number)

   383

        self.ModulesExtraParams.setdefault(module_infos, {})

   384

        self.ModulesExtraParams[module_infos][param] = value

   385

   386

        self.SaveModulesExtraParams()

   387

   388

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

   389

        vendor = ExtractHexDecValue(vendor)

   390

        product_code = ExtractHexDecValue(product_code)

   391

        revision_number = ExtractHexDecValue(revision_number)

   392

   393

        if self.ParentLibrary is not None:

   394

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

   395

        else:

   396

            extra_params = {}

   397

   398

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

   399

   400

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   401

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

   402

   403

        return extra_params

   404

   405

   406

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

   407

if wx.Platform != '__WXMSW__':

   408

    USERDATA_DIR += '_files'

   409

   410

ModulesDatabase = ModulesLibrary(

   411

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

   412

   413

   414

class RootClass(object):

   415

   416

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

   417

    EditorType = LibraryEditor

   418

   419

    def __init__(self):

   420

        self.ModulesLibrary = None

   421

        self.LoadModulesLibrary()

   422

   423

    def GetIconName(self):

   424

        return "Ethercat"

   425

   426

    def GetModulesLibraryPath(self, project_path=None):

   427

        if project_path is None:

   428

            project_path = self.CTNPath()

   429

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

   430

   431

    def OnCTNSave(self, from_project_path=None):

   432

        if from_project_path is not None:

   433

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   434

                            self.GetModulesLibraryPath())

   435

        return True

   436

   437

    def CTNGenerate_C(self, buildpath, locations):

   438

        return [], "", False

   439

   440

    def LoadModulesLibrary(self):

   441

        if self.ModulesLibrary is None:

   442

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

   443

        else:

   444

            self.ModulesLibrary.LoadModulesLibrary()

   445

   446

    def GetModulesDatabaseInstance(self):

   447

        return ModulesDatabase

   448

   449

    def GetModulesLibraryInstance(self):

   450

        return self.ModulesLibrary

   451

   452

    def GetModulesLibrary(self, profile_filter=None):

   453

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   454

   455

    def GetVendors(self):

   456

        return self.ModulesLibrary.GetVendors()

   457

   458

    def GetModuleInfos(self, module_infos):

   459

        return self.ModulesLibrary.GetModuleInfos(module_infos)