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

from copy import deepcopy

    14

from lxml import etree

    15

    16

import wx

    17

    18

from xmlclass import *

    19

    21

from ConfigTreeNode import ConfigTreeNode

    22

from dialogs import BrowseValuesLibraryDialog

    23

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    24

from POULibrary import POULibrary

    25

    26

from ConfigEditor import MasterEditor

    27

from EthercatCFileGenerator import _EthercatCFileGenerator

    28

from EthercatSlave import _EthercatSlaveCTN, ExtractHexDecValue, GenerateHexDecValue, TYPECONVERSION, VARCLASSCONVERSION, _CommonSlave

    29

    30

try:

    31

    from EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    32

    HAS_MCL = True

    33

except Exception:

    34

    HAS_MCL = False

    35

    36

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

    37

#         Remote Exec Etherlab Commands

    38

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

    39

    40

SCAN_COMMAND = """

    41

import commands

    42

result = commands.getoutput("ethercat slaves")

    43

slaves = []

    44

for slave_line in result.splitlines():

    45

    chunks = slave_line.split()

    46

    idx, pos, state, flag = chunks[:4]

    47

    name = " ".join(chunks[4:])

    48

    alias, position = pos.split(":")

    49

    slave = {"idx": int(idx),

    50

             "alias": int(alias),

    51

             "position": int(position),

    52

             "name": name}

    53

    details = commands.getoutput("ethercat slaves -p %d -v" % slave["idx"])

    54

    for details_line in details.splitlines():

    55

        details_line = details_line.strip()

    56

        for header, param in [("Vendor Id:", "vendor_id"),

    57

                              ("Product code:", "product_code"),

    58

                              ("Revision number:", "revision_number")]:

    59

            if details_line.startswith(header):

    60

                slave[param] = details_line.split()[-1]

    61

                break

    62

    slaves.append(slave)

    63

returnVal = slaves

    64

"""

    65

    66

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

    67

#      Etherlab Specific Blocks Library

    68

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

    69

    70

    71

def GetLocalPath(filename):

    72

    return os.path.join(os.path.split(__file__)[0], filename)

    73

    74

    75

class EtherlabLibrary(POULibrary):

    76

    def GetLibraryPath(self):

    77

        return GetLocalPath("pous.xml")

    78

    79

    def Generate_C(self, buildpath, varlist, IECCFLAGS):

    80

        etherlab_ext_file = open(GetLocalPath("etherlab_ext.c"), 'r')

    81

        etherlab_ext_code = etherlab_ext_file.read()

    82

        etherlab_ext_file.close()

    83

    84

        Gen_etherlabfile_path = os.path.join(buildpath, "etherlab_ext.c")

    85

        ethelabfile = open(Gen_etherlabfile_path, 'w')

    86

        ethelabfile.write(etherlab_ext_code)

    87

        ethelabfile.close()

    88

    89

        runtimefile_path = os.path.join(os.path.split(__file__)[0], "runtime_etherlab.py")

    90

        return ((["etherlab_ext"], [(Gen_etherlabfile_path, IECCFLAGS)], True), "",

    91

                ("runtime_etherlab.py", file(GetLocalPath("runtime_etherlab.py"))))

    92

    93

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

    94

#                 Ethercat MASTER

    95

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

    96

    97

    98

EtherCATConfigParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATConfig.xsd"))

    99

   100

   101

def sort_commands(x, y):

   102

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

   103

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

   104

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

   105

   106

   107

cls = EtherCATConfigParser.GetElementClass("Slave", "Config")

   108

if cls:

   109

   110

    def getType(self):

   111

        slave_info = self.getInfo()

   112

        return {"device_type": slave_info.getName(),

   113

                "vendor": GenerateHexDecValue(slave_info.getVendorId()),

   114

                "product_code": GenerateHexDecValue(slave_info.getProductCode(), 16),

   115

                "revision_number": GenerateHexDecValue(slave_info.getRevisionNo(), 16)}

   116

    setattr(cls, "getType", getType)

   117

   118

    def setType(self, type_infos):

   119

        slave_info = self.getInfo()

   120

        slave_info.setName(type_infos["device_type"])

   121

        slave_info.setVendorId(ExtractHexDecValue(type_infos["vendor"]))

   122

        slave_info.setProductCode(ExtractHexDecValue(type_infos["product_code"]))

   123

        slave_info.setRevisionNo(ExtractHexDecValue(type_infos["revision_number"]))

   124

    setattr(cls, "setType", setType)

   125

   126

    def getInitCmds(self, create_default=False):

   127

        Mailbox = self.getMailbox()

   128

        if Mailbox is None:

   129

            if create_default:

   130

                self.addMailbox()

   131

                Mailbox = self.getMailbox()

   132

            else:

   133

                return None

   134

        CoE = Mailbox.getCoE()

   135

        if CoE is None:

   136

            if create_default:

   137

                Mailbox.addCoE()

   138

                CoE = Mailbox.getCoE()

   139

            else:

   140

                return None

   141

        InitCmds = CoE.getInitCmds()

   142

        if InitCmds is None and create_default:

   143

            CoE.addInitCmds()

   144

            InitCmds = CoE.getInitCmds()

   145

        return InitCmds

   146

    setattr(cls, "getInitCmds", getInitCmds)

   147

   148

    def getStartupCommands(self):

   149

        pos = self.getInfo().getPhysAddr()

   150

        InitCmds = self.getInitCmds()

   151

        if InitCmds is None:

   152

            return []

   153

        commands = []

   154

        for idx, InitCmd in enumerate(InitCmds.getInitCmd()):

   155

            comment = InitCmd.getComment()

   156

            if comment is None:

   157

                comment = ""

   158

            commands.append({

   159

                "command_idx": idx,

   160

                "Position": pos,

   161

                "Index": InitCmd.getIndex(),

   162

                "Subindex": InitCmd.getSubIndex(),

   163

                "Value": InitCmd.getData(),

   164

                "Description": comment})

   165

        commands.sort(sort_commands)

   166

        return commands

   167

    setattr(cls, "getStartupCommands", getStartupCommands)

   168

   169

    def appendStartupCommand(self, command_infos):

   170

        InitCmds = self.getInitCmds(True)

   171

        command = EtherCATConfigParser.CreateElement("InitCmd", "InitCmds", 1)

   172

        InitCmds.appendInitCmd(command)

   173

        command.setIndex(command_infos["Index"])

   174

        command.setSubIndex(command_infos["Subindex"])

   175

        command.setData(command_infos["Value"])

   176

        command.setComment(command_infos["Description"])

   177

        return len(InitCmds.getInitCmd()) - 1

   178

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   179

   180

    def setStartupCommand(self, command_infos):

   181

        InitCmds = self.getInitCmds()

   182

        if InitCmds is not None:

   183

            commands = InitCmds.getInitCmd()

   184

            if command_infos["command_idx"] < len(commands):

   185

                command = commands[command_infos["command_idx"]]

   186

                command.setIndex(command_infos["Index"])

   187

                command.setSubIndex(command_infos["Subindex"])

   188

                command.setData(command_infos["Value"])

   189

                command.setComment(command_infos["Description"])

   190

    setattr(cls, "setStartupCommand", setStartupCommand)

   191

   192

    def removeStartupCommand(self, command_idx):

   193

        InitCmds = self.getInitCmds()

   194

        if InitCmds is not None:

   195

            if command_idx < len(InitCmds.getInitCmd()):

   196

                InitCmds.removeInitCmd(command_idx)

   197

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   198

   199

ProcessVariablesXSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   200

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   201

      <xsd:element name="ProcessVariables">

   202

        <xsd:complexType>

   203

          <xsd:sequence>

   204

            <xsd:element name="variable" minOccurs="0" maxOccurs="unbounded">

   205

              <xsd:complexType>

   206

                <xsd:sequence>

   207

                  <xsd:element name="ReadFrom" type="LocationDesc" minOccurs="0"/>

   208

                  <xsd:element name="WriteTo" type="LocationDesc" minOccurs="0"/>

   209

                </xsd:sequence>

   210

                <xsd:attribute name="Name" type="xsd:string" use="required"/>

   211

                <xsd:attribute name="Comment" type="xsd:string" use="required"/>

   212

              </xsd:complexType>

   213

            </xsd:element>

   214

          </xsd:sequence>

   215

        </xsd:complexType>

   216

      </xsd:element>

   217

      <xsd:complexType name="LocationDesc">

   218

        <xsd:attribute name="Position" type="xsd:integer" use="required"/>

   219

        <xsd:attribute name="Index" type="xsd:integer" use="required"/>

   220

        <xsd:attribute name="SubIndex" type="xsd:integer" use="required"/>

   221

      </xsd:complexType>

   222

    </xsd:schema>

   223

"""

   224

   225

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   226

   227

   228

class _EthercatCTN:

   229

   230

    CTNChildrenTypes = [("EthercatSlave", _EthercatSlaveCTN, "Ethercat Slave")]

   231

    if HAS_MCL:

   232

        CTNChildrenTypes.append(("EthercatCIA402Slave", _EthercatCIA402SlaveCTN, "Ethercat CIA402 Slave"))

   233

    EditorType = MasterEditor

   234

   235

    def __init__(self):

   236

        config_filepath = self.ConfigFileName()

   237

        config_is_saved = False

   238

        self.Config = None

   239

        if os.path.isfile(config_filepath):

   240

            config_xmlfile = open(config_filepath, 'r')

   241

            try:

   242

                self.Config, error = \

   243

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   244

                if error is None:

   245

                    config_is_saved = True

   246

            except Exception, e:

   247

                error = e.message

   248

            config_xmlfile.close()

   249

   250

            if error is not None:

   251

                self.GetCTRoot().logger.write_error(

   252

                    _("Couldn't load %s network configuration file.") % CTNName)

   253

   254

        if self.Config is None:

   255

            self.Config = EtherCATConfigParser.CreateElement("EtherCATConfig")

   256

   257

        process_filepath = self.ProcessVariablesFileName()

   258

        process_is_saved = False

   259

        self.ProcessVariables = None

   260

        if os.path.isfile(process_filepath):

   261

            process_xmlfile = open(process_filepath, 'r')

   262

            try:

   263

                self.ProcessVariables, error = \

   264

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   265

                if error is None:

   266

                    process_is_saved = True

   267

            except Exception, e:

   268

                error = e.message

   269

            process_xmlfile.close()

   270

   271

            if error is not None:

   272

                self.GetCTRoot().logger.write_error(

   273

                    _("Couldn't load %s network process variables file.") % CTNName)

   274

   275

        if self.ProcessVariables is None:

   276

            self.ProcessVariables = ProcessVariablesParser.CreateElement("ProcessVariables")

   277

   278

        if config_is_saved and process_is_saved:

   279

            self.CreateBuffer(True)

   280

        else:

   281

            self.CreateBuffer(False)

   282

            self.OnCTNSave()

   283

   284

        # ----------- call ethercat mng. function --------------

   285

        self.CommonMethod = _CommonSlave(self)

   286

   287

    def GetIconName(self):

   288

        return "Ethercat"

   289

   290

    def GetContextualMenuItems(self):

   291

        return [("Add Ethercat Slave", "Add Ethercat Slave to Master", self.OnAddEthercatSlave)]

   292

   293

    def OnAddEthercatSlave(self, event):

   294

        app_frame = self.GetCTRoot().AppFrame

   295

        dialog = BrowseValuesLibraryDialog(app_frame,

   296

                                           "Ethercat Slave Type",

   297

                                           self.GetSlaveTypesLibrary())

   298

        if dialog.ShowModal() == wx.ID_OK:

   299

            type_infos = dialog.GetValueInfos()

   300

            device, module_extra_params = self.GetModuleInfos(type_infos)

   301

            if device is not None:

   302

                if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

   303

                    ConfNodeType = "EthercatCIA402Slave"

   304

                else:

   305

                    ConfNodeType = "EthercatSlave"

   306

                new_child = self.CTNAddChild("%s_0" % ConfNodeType, ConfNodeType)

   307

                new_child.SetParamsAttribute("SlaveParams.Type", type_infos)

   308

                self.CTNRequestSave()

   309

                new_child._OpenView()

   310

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   311

        dialog.Destroy()

   312

   313

    def ExtractHexDecValue(self, value):

   314

        return ExtractHexDecValue(value)

   315

   316

    def GetSizeOfType(self, type):

   317

        return TYPECONVERSION.get(self.GetCTRoot().GetBaseType(type), None)

   318

   319

    def ConfigFileName(self):

   320

        return os.path.join(self.CTNPath(), "config.xml")

   321

   322

    def ProcessVariablesFileName(self):

   323

        return os.path.join(self.CTNPath(), "process_variables.xml")

   324

   325

    def FilterSlave(self, slave, vendor=None, slave_pos=None, slave_profile=None):

   326

        if slave_pos is not None and slave.getInfo().getPhysAddr() != slave_pos:

   327

            return False

   328

        type_infos = slave.getType()

   329

        if vendor is not None and ExtractHexDecValue(type_infos["vendor"]) != vendor:

   330

            return False

   331

        device, module_extra_params = self.GetModuleInfos(type_infos)

   332

        if slave_profile is not None and slave_profile not in device.GetProfileNumbers():

   333

            return False

   334

        return True

   335

   336

    def GetSlaveName(self, slave_pos):

   337

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   338

        if CTNChild is not None:

   339

            return CTNChild.CTNName()

   340

        return self.CTNName()

   341

   342

    def GetSlaves(self, vendor=None, slave_pos=None, slave_profile=None):

   343

        slaves = []

   344

        for slave in self.Config.getConfig().getSlave():

   345

            if self.FilterSlave(slave, vendor, slave_pos, slave_profile):

   346

                slaves.append(slave.getInfo().getPhysAddr())

   347

        slaves.sort()

   348

        return slaves

   349

   350

    def GetSlave(self, slave_pos):

   351

        for slave in self.Config.getConfig().getSlave():

   352

            slave_info = slave.getInfo()

   353

            if slave_info.getPhysAddr() == slave_pos:

   354

                return slave

   355

        return None

   356

   357

    def GetStartupCommands(self, vendor=None, slave_pos=None, slave_profile=None):

   358

        commands = []

   359

        for slave in self.Config.getConfig().getSlave():

   360

            if self.FilterSlave(slave, vendor, slave_pos, slave_profile):

   361

                commands.append((slave.getInfo().getPhysAddr(), slave.getStartupCommands()))

   362

        commands.sort()

   363

        return reduce(lambda x, y: x + y[1], commands, [])

   364

   365

    def AppendStartupCommand(self, command_infos):

   366

        slave = self.GetSlave(command_infos["Position"])

   367

        if slave is not None:

   368

            command_idx = slave.appendStartupCommand(command_infos)

   369

            self.BufferModel()

   370

            return command_idx

   371

        return None

   372

   373

    def SetStartupCommandInfos(self, command_infos):

   374

        slave = self.GetSlave(command_infos["Position"])

   375

        if slave is not None:

   376

            slave.setStartupCommand(command_infos)

   377

            self.BufferModel()

   378

   379

    def RemoveStartupCommand(self, slave_pos, command_idx, buffer=True):

   380

        slave = self.GetSlave(slave_pos)

   381

        if slave is not None:

   382

            slave.removeStartupCommand(command_idx)

   383

            if buffer:

   384

                self.BufferModel()

   385

   386

    def SetProcessVariables(self, variables):

   387

        vars = []

   388

        for var in variables:

   389

            variable = ProcessVariablesParser.CreateElement("variable", "ProcessVariables")

   390

            variable.setName(var["Name"])

   391

            variable.setComment(var["Description"])

   392

            if var["ReadFrom"] != "":

   393

                position, index, subindex = var["ReadFrom"]

   394

                if variable.getReadFrom() is None:

   395

                    variable.addReadFrom()

   396

                read_from = variable.getReadFrom()

   397

                read_from.setPosition(position)

   398

                read_from.setIndex(index)

   399

                read_from.setSubIndex(subindex)

   400

            elif variable.getReadFrom() is not None:

   401

                variable.deleteReadFrom()

   402

            if var["WriteTo"] != "":

   403

                position, index, subindex = var["WriteTo"]

   404

                if variable.getWriteTo() is None:

   405

                    variable.addWriteTo()

   406

                write_to = variable.getWriteTo()

   407

                write_to.setPosition(position)

   408

                write_to.setIndex(index)

   409

                write_to.setSubIndex(subindex)

   410

            elif variable.getWriteTo() is not None:

   411

                variable.deleteWriteTo()

   412

            vars.append(variable)

   413

        self.ProcessVariables.setvariable(vars)

   414

        self.BufferModel()

   415

   416

    def GetProcessVariables(self):

   417

        variables = []

   418

        idx = 0

   419

        for variable in self.ProcessVariables.getvariable():

   420

            var = {"Name": variable.getName(),

   421

                   "Number": idx,

   422

                   "Description": variable.getComment()}

   423

            read_from = variable.getReadFrom()

   424

            if read_from is not None:

   425

                var["ReadFrom"] = (read_from.getPosition(),

   426

                                   read_from.getIndex(),

   427

                                   read_from.getSubIndex())

   428

            else:

   429

                var["ReadFrom"] = ""

   430

            write_to = variable.getWriteTo()

   431

            if write_to is not None:

   432

                var["WriteTo"] = (write_to.getPosition(),

   433

                                  write_to.getIndex(),

   434

                                  write_to.getSubIndex())

   435

            else:

   436

                var["WriteTo"] = ""

   437

            variables.append(var)

   438

            idx += 1

   439

        return variables

   440

   441

    def _ScanNetwork(self):

   442

        app_frame = self.GetCTRoot().AppFrame

   443

   444

        execute = True

   445

        if len(self.Children) > 0:

   446

            dialog = wx.MessageDialog(

   447

                app_frame,

   448

                _("The current network configuration will be deleted.\nDo you want to continue?"),

   449

                _("Scan Network"),

   450

                wx.YES_NO | wx.ICON_QUESTION)

   451

            execute = dialog.ShowModal() == wx.ID_YES

   452

            dialog.Destroy()

   453

   454

        if execute:

   455

            error, returnVal = self.RemoteExec(SCAN_COMMAND, returnVal=None)

   456

            if error != 0:

   457

                dialog = wx.MessageDialog(app_frame, returnVal, "Error", wx.OK | wx.ICON_ERROR)

   458

                dialog.ShowModal()

   459

                dialog.Destroy()

   460

            elif returnVal is not None:

   461

                for child in self.IECSortedChildren():

   462

                    self._doRemoveChild(child)

   463

   464

                for slave in returnVal:

   465

                    type_infos = {

   466

                        "vendor": slave["vendor_id"],

   467

                        "product_code": slave["product_code"],

   468

                        "revision_number": slave["revision_number"],

   469

                    }

   470

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   471

                    if device is not None:

   472

                        if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

   473

                            CTNType = "EthercatCIA402Slave"

   474

                        else:

   475

                            CTNType = "EthercatSlave"

   476

                        self.CTNAddChild("slave%s" % slave["idx"], CTNType, slave["idx"])

   477

                        self.SetSlaveAlias(slave["idx"], slave["alias"])

   478

                        type_infos["device_type"] = device.getType().getcontent()

   479

                        self.SetSlaveType(slave["idx"], type_infos)

   480

   481

                if app_frame:

   482

                    app_frame.RefreshProjectTree()

   483

   484

    def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   485

        """

   486

        Create the confnodes that may be added as child to this node self

   487

        @param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)

   488

        @param CTNName: string for the name of the confnode instance

   489

        """

   490

        newConfNodeOpj = ConfigTreeNode.CTNAddChild(self, CTNName, CTNType, IEC_Channel)

   491

   492

        slave = self.GetSlave(newConfNodeOpj.BaseParams.getIEC_Channel())

   493

        if slave is None:

   494

            slave = EtherCATConfigParser.CreateElement("Slave", "Config")

   495

            self.Config.getConfig().appendSlave(slave)

   496

            slave_infos = slave.getInfo()

   497

            slave_infos.setName("undefined")

   498

            slave_infos.setPhysAddr(newConfNodeOpj.BaseParams.getIEC_Channel())

   499

            slave_infos.setAutoIncAddr(0)

   500

            self.BufferModel()

   501

            self.OnCTNSave()

   502

   503

        return newConfNodeOpj

   504

   505

    def _doRemoveChild(self, CTNInstance):

   506

        slave_pos = CTNInstance.GetSlavePos()

   507

        config = self.Config.getConfig()

   508

        for idx, slave in enumerate(config.getSlave()):

   509

            slave_infos = slave.getInfo()

   510

            if slave_infos.getPhysAddr() == slave_pos: