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

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

   101

#                 Ethercat MASTER

   102

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

   103

   104

   105

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

   106

   107

   108

def sort_commands(x, y):

   109

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

   110

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

   111

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

   112

   113

   114

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

   115

if cls:

   116

   117

    def getType(self):

   118

        slave_info = self.getInfo()

   119

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

   120

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

   121

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

   122

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

   123

    setattr(cls, "getType", getType)

   124

   125

    def setType(self, type_infos):

   126

        slave_info = self.getInfo()

   127

        slave_info.setName(type_infos["device_type"])

   128

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

   129

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

   130

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

   131

    setattr(cls, "setType", setType)

   132

   133

    def getInitCmds(self, create_default=False):

   134

        Mailbox = self.getMailbox()

   135

        if Mailbox is None:

   136

            if create_default:

   137

                self.addMailbox()

   138

                Mailbox = self.getMailbox()

   139

            else:

   140

                return None

   141

        CoE = Mailbox.getCoE()

   142

        if CoE is None:

   143

            if create_default:

   144

                Mailbox.addCoE()

   145

                CoE = Mailbox.getCoE()

   146

            else:

   147

                return None

   148

        InitCmds = CoE.getInitCmds()

   149

        if InitCmds is None and create_default:

   150

            CoE.addInitCmds()

   151

            InitCmds = CoE.getInitCmds()

   152

        return InitCmds

   153

    setattr(cls, "getInitCmds", getInitCmds)

   154

   155

    def getStartupCommands(self):

   156

        pos = self.getInfo().getPhysAddr()

   157

        InitCmds = self.getInitCmds()

   158

        if InitCmds is None:

   159

            return []

   160

        commands = []

   161

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

   162

            comment = InitCmd.getComment()

   163

            if comment is None:

   164

                comment = ""

   165

            commands.append({

   166

                "command_idx": idx,

   167

                "Position": pos,

   168

                "Index": InitCmd.getIndex(),

   169

                "Subindex": InitCmd.getSubIndex(),

   170

                "Value": InitCmd.getData(),

   171

                "Description": comment})

   172

        commands.sort(sort_commands)

   173

        return commands

   174

    setattr(cls, "getStartupCommands", getStartupCommands)

   175

   176

    def appendStartupCommand(self, command_infos):

   177

        InitCmds = self.getInitCmds(True)

   178

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

   179

        InitCmds.appendInitCmd(command)

   180

        command.setIndex(command_infos["Index"])

   181

        command.setSubIndex(command_infos["Subindex"])

   182

        command.setData(command_infos["Value"])

   183

        command.setComment(command_infos["Description"])

   184

        return len(InitCmds.getInitCmd()) - 1

   185

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   186

   187

    def setStartupCommand(self, command_infos):

   188

        InitCmds = self.getInitCmds()

   189

        if InitCmds is not None:

   190

            commands = InitCmds.getInitCmd()

   191

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

   192

                command = commands[command_infos["command_idx"]]

   193

                command.setIndex(command_infos["Index"])

   194

                command.setSubIndex(command_infos["Subindex"])

   195

                command.setData(command_infos["Value"])

   196

                command.setComment(command_infos["Description"])

   197

    setattr(cls, "setStartupCommand", setStartupCommand)

   198

   199

    def removeStartupCommand(self, command_idx):

   200

        InitCmds = self.getInitCmds()

   201

        if InitCmds is not None:

   202

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

   203

                InitCmds.removeInitCmd(command_idx)

   204

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   205

   206

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

   207

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

   208

      <xsd:element name="ProcessVariables">

   209

        <xsd:complexType>

   210

          <xsd:sequence>

   211

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

   212

              <xsd:complexType>

   213

                <xsd:sequence>

   214

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

   215

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

   216

                </xsd:sequence>

   217

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

   218

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

   219

              </xsd:complexType>

   220

            </xsd:element>

   221

          </xsd:sequence>

   222

        </xsd:complexType>

   223

      </xsd:element>

   224

      <xsd:complexType name="LocationDesc">

   225

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

   226

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

   227

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

   228

      </xsd:complexType>

   229

    </xsd:schema>

   230

"""

   231

   232

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   233

   234

   235

class _EthercatCTN(object):

   236

   237

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

   238

    if HAS_MCL:

   239

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

   240

    EditorType = MasterEditor

   241

   242

    def __init__(self):

   243

        config_filepath = self.ConfigFileName()

   244

        config_is_saved = False

   245

        self.Config = None

   246

        # if os.path.isfile(config_filepath):

   247

        #     config_xmlfile = open(config_filepath, 'r')

   248

        #     try:

   249

        #         self.Config, error = \

   250

        #             EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   251

        #         if error is None:

   252

        #             config_is_saved = True

   253

        #     except Exception as e:

   254

        #         error = str(e)

   255

        #     config_xmlfile.close()

   256

   257

        #     if error is not None:

   258

        #         self.GetCTRoot().logger.write_error(

   259

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

   260

   261

        if self.Config is None:

   262

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

   263

   264

        process_filepath = self.ProcessVariablesFileName()

   265

        process_is_saved = False

   266

        self.ProcessVariables = None

   267

        if os.path.isfile(process_filepath):

   268

            process_xmlfile = open(process_filepath, 'r')

   269

            try:

   270

                self.ProcessVariables, error = \

   271

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   272

                if error is None:

   273

                    process_is_saved = True

   274

            except Exception as e:

   275

                error = str(e)

   276

            process_xmlfile.close()

   277

   278

            if error is not None:

   279

                self.GetCTRoot().logger.write_error(

   280

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

   281

   282

        if self.ProcessVariables is None:

   283

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

   284

   285

        #if config_is_saved and process_is_saved:

   286

        if process_is_saved:

   287

            self.CreateBuffer(True)

   288

        else:

   289

            self.CreateBuffer(False)

   290

            self.OnCTNSave()

   291

   292

        if os.path.isfile(config_filepath):

   293

            config_xmlfile = open(config_filepath, 'r')

   294

            try:

   295

                self.Config, error = \

   296

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   297

                if error is None:

   298

                    config_is_saved = True

   299

            except Exception, e:

   300

                error = e.message

   301

            config_xmlfile.close()

   302

   303

            if error is not None:

   304

                self.GetCTRoot().logger.write_error(

   305

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

   306

   307

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

   308

        self.CommonMethod = _CommonSlave(self)

   309

   310

    def GetIconName(self):

   311

        return "Ethercat"

   312

   313

    def GetContextualMenuItems(self):

   314

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

   315

   316

    def OnAddEthercatSlave(self, event):

   317

        app_frame = self.GetCTRoot().AppFrame

   318

        dialog = BrowseValuesLibraryDialog(app_frame,

   319

                                           _("Ethercat Slave Type"),

   320

                                           self.GetSlaveTypesLibrary())

   321

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

   322

            type_infos = dialog.GetValueInfos()

   323

            device, _module_extra_params = self.GetModuleInfos(type_infos)

   324

            if device is not None:

   325

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

   326

                    ConfNodeType = "EthercatCIA402Slave"

   327

                else:

   328

                    ConfNodeType = "EthercatSlave"

   329

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

   330

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

   331

                self.CTNRequestSave()

   332

                new_child._OpenView()

   333

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   334

        dialog.Destroy()

   335

   336

    def ExtractHexDecValue(self, value):

   337

        return ExtractHexDecValue(value)

   338

   339

    def GetSizeOfType(self, type):

   340

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

   341

   342

    def ConfigFileName(self):

   343

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

   344

   345

    def ProcessVariablesFileName(self):

   346

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

   347

   348

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

   349

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

   350

            return False

   351

        type_infos = slave.getType()

   352

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

   353

            return False

   354

        device, _module_extra_params = self.GetModuleInfos(type_infos)

   355

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

   356

            return False

   357

        return True

   358

   359

    def GetSlaveName(self, slave_pos):

   360

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   361

        if CTNChild is not None:

   362

            return CTNChild.CTNName()

   363

        return self.CTNName()

   364

   365

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

   366

        slaves = []

   367

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

   368

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

   369

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

   370

        slaves.sort()

   371

        return slaves

   372

   373

    def GetSlave(self, slave_pos):

   374

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

   375

            slave_info = slave.getInfo()

   376

            if slave_info.getPhysAddr() == slave_pos:

   377

                return slave

   378

        return None

   379

   380

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

   381

        commands = []

   382

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

   383

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

   384

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

   385

        commands.sort()

   386

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

   387

   388

    def AppendStartupCommand(self, command_infos):

   389

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

   390

        if slave is not None:

   391

            command_idx = slave.appendStartupCommand(command_infos)

   392

            self.BufferModel()

   393

            return command_idx

   394

        return None

   395

   396

    def SetStartupCommandInfos(self, command_infos):

   397

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

   398

        if slave is not None:

   399

            slave.setStartupCommand(command_infos)

   400

            self.BufferModel()

   401

   402

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

   403

        slave = self.GetSlave(slave_pos)

   404

        if slave is not None:

   405

            slave.removeStartupCommand(command_idx)

   406

            if buffer:

   407

                self.BufferModel()

   408

   409

    def SetProcessVariables(self, variables):

   410

        vars = []

   411

        for var in variables:

   412

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

   413

            variable.setName(var["Name"])

   414

            variable.setComment(var["Description"])

   415

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

   416

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

   417

                if variable.getReadFrom() is None:

   418

                    variable.addReadFrom()

   419

                read_from = variable.getReadFrom()

   420

                read_from.setPosition(position)

   421

                read_from.setIndex(index)

   422

                read_from.setSubIndex(subindex)

   423

            elif variable.getReadFrom() is not None:

   424

                variable.deleteReadFrom()

   425

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

   426

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

   427

                if variable.getWriteTo() is None:

   428

                    variable.addWriteTo()

   429

                write_to = variable.getWriteTo()

   430

                write_to.setPosition(position)

   431

                write_to.setIndex(index)

   432

                write_to.setSubIndex(subindex)

   433

            elif variable.getWriteTo() is not None:

   434

                variable.deleteWriteTo()

   435

            vars.append(variable)

   436

        self.ProcessVariables.setvariable(vars)

   437

        self.BufferModel()

   438

   439

    def GetProcessVariables(self):

   440

        variables = []

   441

        idx = 0

   442

        for variable in self.ProcessVariables.getvariable():

   443

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

   444

                   "Number": idx,

   445

                   "Description": variable.getComment()}

   446

            read_from = variable.getReadFrom()

   447

            if read_from is not None:

   448

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

   449

                                   read_from.getIndex(),

   450

                                   read_from.getSubIndex())

   451

            else:

   452

                var["ReadFrom"] = ""

   453

            write_to = variable.getWriteTo()

   454

            if write_to is not None:

   455

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

   456

                                  write_to.getIndex(),

   457

                                  write_to.getSubIndex())

   458

            else:

   459

                var["WriteTo"] = ""

   460

            variables.append(var)

   461

            idx += 1

   462

        return variables

   463

   464

    def _ScanNetwork(self):

   465

        app_frame = self.GetCTRoot().AppFrame

   466

   467

        execute = True

   468

        if len(self.Children) > 0:

   469

            dialog = wx.MessageDialog(

   470

                app_frame,

   471

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

   472

                _("Scan Network"),

   473

                wx.YES_NO | wx.ICON_QUESTION)

   474

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

   475

            dialog.Destroy()

   476

   477

        if execute:

   478

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

   479

            if error != 0:

   480

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

   481

                dialog.ShowModal()

   482

                dialog.Destroy()

   483

            elif returnVal is not None:

   484

                for child in self.IECSortedChildren():

   485

                    self._doRemoveChild(child)

   486

   487

                for slave in returnVal:

   488

                    type_infos = {

   489

                        "vendor": slave["vendor_id"],

   490

                        "product_code": slave["product_code"],

   491

                        "revision_number": slave["revision_number"],

   492

                    }

   493

                    device, _module_extra_params = self.GetModuleInfos(type_infos)

   494

                    if device is not None:

   495

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

   496

                            CTNType = "EthercatCIA402Slave"

   497

                        else:

   498

                            CTNType = "EthercatSlave"

   499

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

   500

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

   501

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

   502

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

   503

   504

                if app_frame:

   505

                    app_frame.RefreshProjectTree()

   506

   507

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

   508

        """