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

            self.CreateBuffer(True)

   287

        else:

   288

            self.CreateBuffer(False)

   289

            self.OnCTNSave()

   290

   291

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

   292

        self.CommonMethod = _CommonSlave(self)

   293

   294

    def GetIconName(self):

   295

        return "Ethercat"

   296

   297

    def GetContextualMenuItems(self):

   298

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

   299

   300

    def OnAddEthercatSlave(self, event):

   301

        app_frame = self.GetCTRoot().AppFrame

   302

        dialog = BrowseValuesLibraryDialog(app_frame,

   303

                                           _("Ethercat Slave Type"),

   304

                                           self.GetSlaveTypesLibrary())

   305

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

   306

            type_infos = dialog.GetValueInfos()

   307

            device, _module_extra_params = self.GetModuleInfos(type_infos)

   308

            if device is not None:

   309

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

   310

                    ConfNodeType = "EthercatCIA402Slave"

   311

                else:

   312

                    ConfNodeType = "EthercatSlave"

   313

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

   314

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

   315

                self.CTNRequestSave()

   316

                new_child._OpenView()

   317

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   318

        dialog.Destroy()

   319

   320

    def ExtractHexDecValue(self, value):

   321

        return ExtractHexDecValue(value)

   322

   323

    def GetSizeOfType(self, type):

   324

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

   325

   326

    def ConfigFileName(self):

   327

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

   328

   329

    def ProcessVariablesFileName(self):

   330

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

   331

   332

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

   333

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

   334

            return False

   335

        type_infos = slave.getType()

   336

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

   337

            return False

   338

        device, _module_extra_params = self.GetModuleInfos(type_infos)

   339

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

   340

            return False

   341

        return True

   342

   343

    def GetSlaveName(self, slave_pos):

   344

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   345

        if CTNChild is not None:

   346

            return CTNChild.CTNName()

   347

        return self.CTNName()

   348

   349

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

   350

        slaves = []

   351

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

   352

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

   353

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

   354

        slaves.sort()

   355

        return slaves

   356

   357

    def GetSlave(self, slave_pos):

   358

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

   359

            slave_info = slave.getInfo()

   360

            if slave_info.getPhysAddr() == slave_pos:

   361

                return slave

   362

        return None

   363

   364

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

   365

        commands = []

   366

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

   367

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

   368

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

   369

        commands.sort()

   370

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

   371

   372

    def AppendStartupCommand(self, command_infos):

   373

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

   374

        if slave is not None:

   375

            command_idx = slave.appendStartupCommand(command_infos)

   376

            self.BufferModel()

   377

            return command_idx

   378

        return None

   379

   380

    def SetStartupCommandInfos(self, command_infos):

   381

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

   382

        if slave is not None:

   383

            slave.setStartupCommand(command_infos)

   384

            self.BufferModel()

   385

   386

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

   387

        slave = self.GetSlave(slave_pos)

   388

        if slave is not None:

   389

            slave.removeStartupCommand(command_idx)

   390

            if buffer:

   391

                self.BufferModel()

   392

   393

    def SetProcessVariables(self, variables):

   394

        vars = []

   395

        for var in variables:

   396

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

   397

            variable.setName(var["Name"])

   398

            variable.setComment(var["Description"])

   399

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

   400

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

   401

                if variable.getReadFrom() is None:

   402

                    variable.addReadFrom()

   403

                read_from = variable.getReadFrom()

   404

                read_from.setPosition(position)

   405

                read_from.setIndex(index)

   406

                read_from.setSubIndex(subindex)

   407

            elif variable.getReadFrom() is not None:

   408

                variable.deleteReadFrom()

   409

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

   410

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

   411

                if variable.getWriteTo() is None:

   412

                    variable.addWriteTo()

   413

                write_to = variable.getWriteTo()

   414

                write_to.setPosition(position)

   415

                write_to.setIndex(index)

   416

                write_to.setSubIndex(subindex)

   417

            elif variable.getWriteTo() is not None:

   418

                variable.deleteWriteTo()

   419

            vars.append(variable)

   420

        self.ProcessVariables.setvariable(vars)

   421

        self.BufferModel()

   422

   423

    def GetProcessVariables(self):

   424

        variables = []

   425

        idx = 0

   426

        for variable in self.ProcessVariables.getvariable():

   427

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

   428

                   "Number": idx,

   429

                   "Description": variable.getComment()}

   430

            read_from = variable.getReadFrom()

   431

            if read_from is not None:

   432

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

   433

                                   read_from.getIndex(),

   434

                                   read_from.getSubIndex())

   435

            else:

   436

                var["ReadFrom"] = ""

   437

            write_to = variable.getWriteTo()

   438

            if write_to is not None:

   439

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

   440

                                  write_to.getIndex(),

   441

                                  write_to.getSubIndex())

   442

            else:

   443

                var["WriteTo"] = ""

   444

            variables.append(var)

   445

            idx += 1

   446

        return variables

   447

   448

    def _ScanNetwork(self):

   449

        app_frame = self.GetCTRoot().AppFrame

   450

   451

        execute = True

   452

        if len(self.Children) > 0:

   453

            dialog = wx.MessageDialog(

   454

                app_frame,

   455

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

   456

                _("Scan Network"),

   457

                wx.YES_NO | wx.ICON_QUESTION)

   458

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

   459

            dialog.Destroy()

   460

   461

        if execute:

   462

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

   463

            if error != 0:

   464

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

   465

                dialog.ShowModal()

   466

                dialog.Destroy()

   467

            elif returnVal is not None:

   468

                for child in self.IECSortedChildren():

   469

                    self._doRemoveChild(child)

   470

   471

                for slave in returnVal:

   472

                    type_infos = {

   473

                        "vendor": slave["vendor_id"],

   474

                        "product_code": slave["product_code"],

   475

                        "revision_number": slave["revision_number"],

   476

                    }

   477

                    device, _module_extra_params = self.GetModuleInfos(type_infos)

   478

                    if device is not None:

   479

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

   480

                            CTNType = "EthercatCIA402Slave"

   481

                        else:

   482

                            CTNType = "EthercatSlave"

   483

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

   484

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

   485

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

   486

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

   487

   488

                if app_frame:

   489

                    app_frame.RefreshProjectTree()

   490

   491

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

   492

        """

   493

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

   494

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

   495

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

   496

        """

   497

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

   498

   499

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

   500

        if slave is None:

   501

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

   502

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

   503

            slave_infos = slave.getInfo()

   504

            slave_infos.setName("undefined")

   505

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

   506

            slave_infos.setAutoIncAddr(0)

   507

            self.BufferModel()

   508

            self.OnCTNSave()