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

from copy import deepcopy

    15

from functools import reduce

    16

from lxml import etree

    17

    18

import wx

    19

    20

from xmlclass import *

    21

    22

from PLCControler import UndoBuffer, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT

    23

from ConfigTreeNode import ConfigTreeNode

    24

from dialogs import BrowseValuesLibraryDialog

    25

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    26

from POULibrary import POULibrary

    27

    28

from etherlab.ConfigEditor import MasterEditor

    29

from etherlab.EthercatCFileGenerator import _EthercatCFileGenerator

    30

from etherlab.EthercatSlave import \

    31

    _EthercatSlaveCTN, \

    32

    ExtractHexDecValue, \

    33

    GenerateHexDecValue, \

    34

    TYPECONVERSION, \

    35

    VARCLASSCONVERSION, \

    36

    _CommonSlave

    37

    38

try:

    39

    from etherlab.EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    40

    HAS_MCL = True

    41

except Exception:

    42

    HAS_MCL = False

    43

    44

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

    45

#         Remote Exec Etherlab Commands

    46

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

    47

    48

SCAN_COMMAND = """

    49

import commands

    50

result = commands.getoutput("ethercat slaves")

    51

slaves = []

    52

for slave_line in result.splitlines():

    53

    chunks = slave_line.split()

    54

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

    55

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

    56

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

    57

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

    58

             "alias": int(alias),

    59

             "position": int(position),

    60

             "name": name}

    61

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

    62

    for details_line in details.splitlines():

    63

        details_line = details_line.strip()

    64

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

    65

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

    66

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

    67

            if details_line.startswith(header):

    68

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

    69

                break

    70

    slaves.append(slave)

    71

returnVal = slaves

    72

"""

    73

    74

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

    75

#      Etherlab Specific Blocks Library

    76

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

    77

    78

    79

def GetLocalPath(filename):

    80

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

    81

    82

    83

class EtherlabLibrary(POULibrary):

    84

    def GetLibraryPath(self):

    85

        return GetLocalPath("pous.xml")

    86

    87

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

    88

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

    89

        etherlab_ext_code = etherlab_ext_file.read()

    90

        etherlab_ext_file.close()

    91

    92

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

    93

        ethelabfile = open(Gen_etherlabfile_path, 'w')

    94

        ethelabfile.write(etherlab_ext_code)

    95

        ethelabfile.close()

    96

    97

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

    98

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

    99

   100

                # TODO : rename to match runtime_{location}_extname.py format

   101

   102

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

   103

#                 Ethercat MASTER

   104

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

   105

   106

   107

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

   108

   109

   110

def sort_commands(x, y):

   111

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

   112

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

   113

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

   114

   115

   116

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

   117

if cls:

   118

   119

    def getType(self):

   120

        slave_info = self.getInfo()

   121

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

   122

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

   123

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

   124

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

   125

    setattr(cls, "getType", getType)

   126

   127

    def setType(self, type_infos):

   128

        slave_info = self.getInfo()

   129

        slave_info.setName(type_infos["device_type"])

   130

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

   131

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

   132

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

   133

    setattr(cls, "setType", setType)

   134

   135

    def getInitCmds(self, create_default=False):

   136

        Mailbox = self.getMailbox()

   137

        if Mailbox is None:

   138

            if create_default:

   139

                self.addMailbox()

   140

                Mailbox = self.getMailbox()

   141

            else:

   142

                return None

   143

        CoE = Mailbox.getCoE()

   144

        if CoE is None:

   145

            if create_default:

   146

                Mailbox.addCoE()

   147

                CoE = Mailbox.getCoE()

   148

            else:

   149

                return None

   150

        InitCmds = CoE.getInitCmds()

   151

        if InitCmds is None and create_default:

   152

            CoE.addInitCmds()

   153

            InitCmds = CoE.getInitCmds()

   154

        return InitCmds

   155

    setattr(cls, "getInitCmds", getInitCmds)

   156

   157

    def getStartupCommands(self):

   158

        pos = self.getInfo().getPhysAddr()

   159

        InitCmds = self.getInitCmds()

   160

        if InitCmds is None:

   161

            return []

   162

        commands = []

   163

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

   164

            comment = InitCmd.getComment()

   165

            if comment is None:

   166

                comment = ""

   167

            commands.append({

   168

                "command_idx": idx,

   169

                "Position": pos,

   170

                "Index": InitCmd.getIndex(),

   171

                "Subindex": InitCmd.getSubIndex(),

   172

                "Value": InitCmd.getData(),

   173

                "Description": comment})

   174

        commands.sort(sort_commands)

   175

        return commands

   176

    setattr(cls, "getStartupCommands", getStartupCommands)

   177

   178

    def appendStartupCommand(self, command_infos):

   179

        InitCmds = self.getInitCmds(True)

   180

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

   181

        InitCmds.appendInitCmd(command)

   182

        command.setIndex(command_infos["Index"])

   183

        command.setSubIndex(command_infos["Subindex"])

   184

        command.setData(command_infos["Value"])

   185

        command.setComment(command_infos["Description"])

   186

        return len(InitCmds.getInitCmd()) - 1

   187

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   188

   189

    def setStartupCommand(self, command_infos):

   190

        InitCmds = self.getInitCmds()

   191

        if InitCmds is not None:

   192

            commands = InitCmds.getInitCmd()

   193

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

   194

                command = commands[command_infos["command_idx"]]

   195

                command.setIndex(command_infos["Index"])

   196

                command.setSubIndex(command_infos["Subindex"])

   197

                command.setData(command_infos["Value"])

   198

                command.setComment(command_infos["Description"])

   199

    setattr(cls, "setStartupCommand", setStartupCommand)

   200

   201

    def removeStartupCommand(self, command_idx):

   202

        InitCmds = self.getInitCmds()

   203

        if InitCmds is not None:

   204

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

   205

                InitCmds.removeInitCmd(command_idx)

   206

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   207

   208

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

   209

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

   210

      <xsd:element name="ProcessVariables">

   211

        <xsd:complexType>

   212

          <xsd:sequence>

   213

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

   214

              <xsd:complexType>

   215

                <xsd:sequence>

   216

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

   217

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

   218

                </xsd:sequence>

   219

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

   220

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

   221

              </xsd:complexType>

   222

            </xsd:element>

   223

          </xsd:sequence>

   224

        </xsd:complexType>

   225

      </xsd:element>

   226

      <xsd:complexType name="LocationDesc">

   227

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

   228

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

   229

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

   230

      </xsd:complexType>

   231

    </xsd:schema>

   232

"""

   233

   234

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   235

   236

   237

class _EthercatCTN(object):

   238

   239

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

   240

    if HAS_MCL:

   241

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

   242

    EditorType = MasterEditor

   243

   244

    def __init__(self):

   245

        config_filepath = self.ConfigFileName()

   246

        config_is_saved = False

   247

        self.Config = None

   248

        # if os.path.isfile(config_filepath):

   249

        #     config_xmlfile = open(config_filepath, 'r')

   250

        #     try:

   251

        #         self.Config, error = \

   252

        #             EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   253

        #         if error is None:

   254

        #             config_is_saved = True

   255

        #     except Exception as e:

   256

        #         error = str(e)

   257

        #     config_xmlfile.close()

   258

   259

        #     if error is not None:

   260

        #         self.GetCTRoot().logger.write_error(

   261

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

   262

   263

        if self.Config is None:

   264

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

   265

   266

        process_filepath = self.ProcessVariablesFileName()

   267

        process_is_saved = False

   268

        self.ProcessVariables = None

   269

        if os.path.isfile(process_filepath):

   270

            process_xmlfile = open(process_filepath, 'r')

   271

            try:

   272

                self.ProcessVariables, error = \

   273

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   274

                if error is None:

   275

                    process_is_saved = True

   276

            except Exception as e:

   277

                error = str(e)

   278

            process_xmlfile.close()

   279

   280

            if error is not None:

   281

                self.GetCTRoot().logger.write_error(

   282

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

   283

   284

        if self.ProcessVariables is None:

   285

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

   286

   287

        #if config_is_saved and process_is_saved:

   288

        if process_is_saved:

   289

            self.CreateBuffer(True)

   290

        else:

   291

            self.CreateBuffer(False)

   292

            self.OnCTNSave()

   293

   294

        if os.path.isfile(config_filepath):

   295

            config_xmlfile = open(config_filepath, 'r')

   296

            try:

   297

                self.Config, error = \

   298

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   299

                if error is None:

   300

                    config_is_saved = True

   301

            except Exception, e:

   302

                error = e.message

   303

            config_xmlfile.close()

   304

   305

            if error is not None:

   306

                self.GetCTRoot().logger.write_error(

   307

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

   308

   309

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

   310

        self.CommonMethod = _CommonSlave(self)

   311

   312

    def GetIconName(self):

   313

        return "Ethercat"

   314

   315

    def GetContextualMenuItems(self):

   316

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

   317

   318

    def OnAddEthercatSlave(self, event):

   319

        app_frame = self.GetCTRoot().AppFrame

   320

        dialog = BrowseValuesLibraryDialog(app_frame,

   321

                                           _("Ethercat Slave Type"),

   322

                                           self.GetSlaveTypesLibrary())

   323

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

   324

            type_infos = dialog.GetValueInfos()

   325

            device, _module_extra_params = self.GetModuleInfos(type_infos)

   326

            if device is not None:

   327

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

   328

                    ConfNodeType = "EthercatCIA402Slave"

   329

                else:

   330

                    ConfNodeType = "EthercatSlave"

   331

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

   332

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

   333

                self.CTNRequestSave()

   334

                new_child._OpenView()

   335

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   336

        dialog.Destroy()

   337

   338

    def ExtractHexDecValue(self, value):

   339

        return ExtractHexDecValue(value)

   340

   341

    def GetSizeOfType(self, type):

   342

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

   343

   344

    def ConfigFileName(self):

   345

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

   346

   347

    def ProcessVariablesFileName(self):

   348

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

   349

   350

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

   351

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

   352

            return False

   353

        type_infos = slave.getType()

   354

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

   355

            return False

   356

        device, _module_extra_params = self.GetModuleInfos(type_infos)

   357

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

   358

            return False

   359

        return True

   360

   361

    def GetSlaveName(self, slave_pos):

   362

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   363

        if CTNChild is not None:

   364

            return CTNChild.CTNName()

   365

        return self.CTNName()

   366

   367

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

   368

        slaves = []

   369

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

   370

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

   371

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

   372

        slaves.sort()

   373

        return slaves

   374

   375

    def GetSlave(self, slave_pos):

   376

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

   377

            slave_info = slave.getInfo()

   378

            if slave_info.getPhysAddr() == slave_pos:

   379

                return slave

   380

        return None

   381

   382

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

   383

        commands = []

   384

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

   385

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

   386

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

   387

        commands.sort()

   388

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

   389

   390

    def AppendStartupCommand(self, command_infos):

   391

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

   392

        if slave is not None:

   393

            command_idx = slave.appendStartupCommand(command_infos)

   394

            self.BufferModel()

   395

            return command_idx

   396

        return None

   397

   398

    def SetStartupCommandInfos(self, command_infos):

   399

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

   400

        if slave is not None:

   401

            slave.setStartupCommand(command_infos)

   402

            self.BufferModel()

   403

   404

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

   405

        slave = self.GetSlave(slave_pos)

   406

        if slave is not None:

   407

            slave.removeStartupCommand(command_idx)

   408

            if buffer:

   409

                self.BufferModel()

   410

   411

    def SetProcessVariables(self, variables):

   412

        vars = []

   413

        for var in variables:

   414

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

   415

            variable.setName(var["Name"])

   416

            variable.setComment(var["Description"])

   417

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

   418

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

   419

                if variable.getReadFrom() is None:

   420

                    variable.addReadFrom()

   421

                read_from = variable.getReadFrom()

   422

                read_from.setPosition(position)

   423

                read_from.setIndex(index)

   424

                read_from.setSubIndex(subindex)

   425

            elif variable.getReadFrom() is not None:

   426

                variable.deleteReadFrom()

   427

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

   428

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

   429

                if variable.getWriteTo() is None:

   430

                    variable.addWriteTo()

   431

                write_to = variable.getWriteTo()

   432

                write_to.setPosition(position)

   433

                write_to.setIndex(index)

   434

                write_to.setSubIndex(subindex)

   435

            elif variable.getWriteTo() is not None:

   436

                variable.deleteWriteTo()

   437

            vars.append(variable)

   438

        self.ProcessVariables.setvariable(vars)

   439

        self.BufferModel()

   440

   441

    def GetProcessVariables(self):

   442

        variables = []

   443

        idx = 0

   444

        for variable in self.ProcessVariables.getvariable():

   445

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

   446

                   "Number": idx,

   447

                   "Description": variable.getComment()}

   448

            read_from = variable.getReadFrom()

   449

            if read_from is not None:

   450

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

   451

                                   read_from.getIndex(),

   452

                                   read_from.getSubIndex())

   453

            else:

   454

                var["ReadFrom"] = ""

   455

            write_to = variable.getWriteTo()

   456

            if write_to is not None:

   457

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

   458

                                  write_to.getIndex(),

   459

                                  write_to.getSubIndex())

   460

            else:

   461

                var["WriteTo"] = ""

   462

            variables.append(var)

   463

            idx += 1

   464

        return variables

   465

   466

    def _ScanNetwork(self):

   467

        app_frame = self.GetCTRoot().AppFrame

   468

   469

        execute = True

   470

        if len(self.Children) > 0:

   471

            dialog = wx.MessageDialog(

   472

                app_frame,

   473

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

   474

                _("Scan Network"),

   475

                wx.YES_NO | wx.ICON_QUESTION)

   476

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

   477

            dialog.Destroy()

   478

   479

        if execute:

   480

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

   481

            if error != 0:

   482

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

   483

                dialog.ShowModal()

   484

                dialog.Destroy()

   485

            elif returnVal is not None:

   486

                for child in self.IECSortedChildren():

   487

                    self._doRemoveChild(child)

   488

   489

                for slave in returnVal:

   490

                    type_infos = {

   491

                        "vendor": slave["vendor_id"],

   492

                        "product_code": slave["product_code"],

   493

                        "revision_number": slave["revision_number"],

   494

                    }

   495

                    device, _module_extra_params = self.GetModuleInfos(type_infos)

   496

                    if device is not None:

   497

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

   498

                            CTNType = "EthercatCIA402Slave"

   499

                        else:

   500

                            CTNType = "EthercatSlave"

   501

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

   502

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

   503

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

   504

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

   505

   506

                if app_frame:

   507

                    app_frame.RefreshProjectTree()

   508