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 lxml import etree

    16

    17

import wx

    18

    19

from xmlclass import *

    20

    21

from PLCControler import UndoBuffer, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT

    22

from ConfigTreeNode import ConfigTreeNode

    23

from dialogs import BrowseValuesLibraryDialog

    24

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    25

from POULibrary import POULibrary

    26

    27

from etherlab.ConfigEditor import MasterEditor

    28

from etherlab.EthercatCFileGenerator import _EthercatCFileGenerator

    29

from etherlab.EthercatSlave import \

    30

    _EthercatSlaveCTN, \

    31

    ExtractHexDecValue, \

    32

    GenerateHexDecValue, \

    33

    TYPECONVERSION, \

    34

    VARCLASSCONVERSION, \

    35

    _CommonSlave

    36

    37

try:

    38

    from etherlab.EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    39

    HAS_MCL = True

    40

except Exception:

    41

    HAS_MCL = False

    42

    43

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

    44

#         Remote Exec Etherlab Commands

    45

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

    46

    47

SCAN_COMMAND = """

    48

import commands

    49

result = commands.getoutput("ethercat slaves")

    50

slaves = []

    51

for slave_line in result.splitlines():

    52

    chunks = slave_line.split()

    53

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

    54

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

    55

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

    56

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

    57

             "alias": int(alias),

    58

             "position": int(position),

    59

             "name": name}

    60

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

    61

    for details_line in details.splitlines():

    62

        details_line = details_line.strip()

    63

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

    64

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

    65

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

    66

            if details_line.startswith(header):

    67

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

    68

                break

    69

    slaves.append(slave)

    70

returnVal = slaves

    71

"""

    72

    73

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

    74

#      Etherlab Specific Blocks Library

    75

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

    76

    77

    78

def GetLocalPath(filename):

    79

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

    80

    81

    82

class EtherlabLibrary(POULibrary):

    83

    def GetLibraryPath(self):

    84

        return GetLocalPath("pous.xml")

    85

    86

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

    87

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

    88

        etherlab_ext_code = etherlab_ext_file.read()

    89

        etherlab_ext_file.close()

    90

    91

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

    92

        ethelabfile = open(Gen_etherlabfile_path, 'w')

    93

        ethelabfile.write(etherlab_ext_code)

    94

        ethelabfile.close()

    95

    96

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

    97

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

    98

    99

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

   100

#                 Ethercat MASTER

   101

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

   102

   103

   104

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

   105

   106

   107

def sort_commands(x, y):

   108

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

   109

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

   110

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

   111

   112

   113

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

   114

if cls:

   115

   116

    def getType(self):

   117

        slave_info = self.getInfo()

   118

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

   119

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

   120

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

   121

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

   122

    setattr(cls, "getType", getType)

   123

   124

    def setType(self, type_infos):

   125

        slave_info = self.getInfo()

   126

        slave_info.setName(type_infos["device_type"])

   127

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

   128

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

   129

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

   130

    setattr(cls, "setType", setType)

   131

   132

    def getInitCmds(self, create_default=False):

   133

        Mailbox = self.getMailbox()

   134

        if Mailbox is None:

   135

            if create_default:

   136

                self.addMailbox()

   137

                Mailbox = self.getMailbox()

   138

            else:

   139

                return None

   140

        CoE = Mailbox.getCoE()

   141

        if CoE is None:

   142

            if create_default:

   143

                Mailbox.addCoE()

   144

                CoE = Mailbox.getCoE()

   145

            else:

   146

                return None

   147

        InitCmds = CoE.getInitCmds()

   148

        if InitCmds is None and create_default:

   149

            CoE.addInitCmds()

   150

            InitCmds = CoE.getInitCmds()

   151

        return InitCmds

   152

    setattr(cls, "getInitCmds", getInitCmds)

   153

   154

    def getStartupCommands(self):

   155

        pos = self.getInfo().getPhysAddr()

   156

        InitCmds = self.getInitCmds()

   157

        if InitCmds is None:

   158

            return []

   159

        commands = []

   160

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

   161

            comment = InitCmd.getComment()

   162

            if comment is None:

   163

                comment = ""

   164

            commands.append({

   165

                "command_idx": idx,

   166

                "Position": pos,

   167

                "Index": InitCmd.getIndex(),

   168

                "Subindex": InitCmd.getSubIndex(),

   169

                "Value": InitCmd.getData(),

   170

                "Description": comment})

   171

        commands.sort(sort_commands)

   172

        return commands

   173

    setattr(cls, "getStartupCommands", getStartupCommands)

   174

   175

    def appendStartupCommand(self, command_infos):

   176

        InitCmds = self.getInitCmds(True)

   177

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

   178

        InitCmds.appendInitCmd(command)

   179

        command.setIndex(command_infos["Index"])

   180

        command.setSubIndex(command_infos["Subindex"])

   181

        command.setData(command_infos["Value"])

   182

        command.setComment(command_infos["Description"])

   183

        return len(InitCmds.getInitCmd()) - 1

   184

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   185

   186

    def setStartupCommand(self, command_infos):

   187

        InitCmds = self.getInitCmds()

   188

        if InitCmds is not None:

   189

            commands = InitCmds.getInitCmd()

   190

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

   191

                command = commands[command_infos["command_idx"]]

   192

                command.setIndex(command_infos["Index"])

   193

                command.setSubIndex(command_infos["Subindex"])

   194

                command.setData(command_infos["Value"])

   195

                command.setComment(command_infos["Description"])

   196

    setattr(cls, "setStartupCommand", setStartupCommand)

   197

   198

    def removeStartupCommand(self, command_idx):

   199

        InitCmds = self.getInitCmds()

   200

        if InitCmds is not None:

   201

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

   202

                InitCmds.removeInitCmd(command_idx)

   203

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   204

   205

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

   206

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

   207

      <xsd:element name="ProcessVariables">

   208

        <xsd:complexType>

   209

          <xsd:sequence>

   210

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

   211

              <xsd:complexType>

   212

                <xsd:sequence>

   213

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

   214

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

   215

                </xsd:sequence>

   216

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

   217

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

   218

              </xsd:complexType>

   219

            </xsd:element>

   220

          </xsd:sequence>

   221

        </xsd:complexType>

   222

      </xsd:element>

   223

      <xsd:complexType name="LocationDesc">

   224

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

   225

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

   226

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

   227

      </xsd:complexType>

   228

    </xsd:schema>

   229

"""

   230

   231

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   232

   233

   234

class _EthercatCTN(object):

   235

   236

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

   237

    if HAS_MCL:

   238

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

   239

    EditorType = MasterEditor

   240

   241

    def __init__(self):

   242

        config_filepath = self.ConfigFileName()

   243

        config_is_saved = False

   244

        self.Config = None

   245

        if os.path.isfile(config_filepath):

   246

            config_xmlfile = open(config_filepath, 'r')

   247

            try:

   248

                self.Config, error = \

   249

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   250

                if error is None:

   251

                    config_is_saved = True

   252

            except Exception as e:

   253

                error = e.message

   254

            config_xmlfile.close()

   255

   256

            if error is not None:

   257

                self.GetCTRoot().logger.write_error(

   258

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

   259

   260

        if self.Config is None:

   261

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

   262

   263

        process_filepath = self.ProcessVariablesFileName()

   264

        process_is_saved = False

   265

        self.ProcessVariables = None

   266

        if os.path.isfile(process_filepath):

   267

            process_xmlfile = open(process_filepath, 'r')

   268

            try:

   269

                self.ProcessVariables, error = \

   270

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   271

                if error is None:

   272

                    process_is_saved = True

   273

            except Exception as e:

   274

                error = e.message

   275

            process_xmlfile.close()

   276

   277

            if error is not None:

   278

                self.GetCTRoot().logger.write_error(

   279

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

   280

   281

        if self.ProcessVariables is None:

   282

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

   283

   284

        if config_is_saved and process_is_saved:

   285

            self.CreateBuffer(True)

   286

        else:

   287

            self.CreateBuffer(False)

   288

            self.OnCTNSave()

   289

   290

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

   291

        self.CommonMethod = _CommonSlave(self)

   292

   293

    def GetIconName(self):

   294

        return "Ethercat"

   295

   296

    def GetContextualMenuItems(self):

   297

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

   298

   299

    def OnAddEthercatSlave(self, event):

   300

        app_frame = self.GetCTRoot().AppFrame

   301

        dialog = BrowseValuesLibraryDialog(app_frame,

   302

                                           _("Ethercat Slave Type"),

   303

                                           self.GetSlaveTypesLibrary())

   304

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

   305

            type_infos = dialog.GetValueInfos()

   306

            device, _module_extra_params = self.GetModuleInfos(type_infos)

   307

            if device is not None:

   308

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

   309

                    ConfNodeType = "EthercatCIA402Slave"

   310

                else:

   311

                    ConfNodeType = "EthercatSlave"

   312

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

   313

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

   314

                self.CTNRequestSave()

   315

                new_child._OpenView()

   316

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   317

        dialog.Destroy()

   318

   319

    def ExtractHexDecValue(self, value):

   320

        return ExtractHexDecValue(value)

   321

   322

    def GetSizeOfType(self, type):

   323

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

   324

   325

    def ConfigFileName(self):

   326

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

   327

   328

    def ProcessVariablesFileName(self):

   329

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

   330

   331

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

   332

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

   333

            return False

   334

        type_infos = slave.getType()

   335

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

   336

            return False

   337

        device, _module_extra_params = self.GetModuleInfos(type_infos)

   338

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

   339

            return False

   340

        return True

   341

   342

    def GetSlaveName(self, slave_pos):

   343

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   344

        if CTNChild is not None:

   345

            return CTNChild.CTNName()

   346

        return self.CTNName()

   347

   348

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

   349

        slaves = []

   350

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

   351

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

   352

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

   353

        slaves.sort()

   354

        return slaves

   355

   356

    def GetSlave(self, slave_pos):

   357

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

   358

            slave_info = slave.getInfo()

   359

            if slave_info.getPhysAddr() == slave_pos:

   360

                return slave

   361

        return None

   362

   363

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

   364

        commands = []

   365

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

   366

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

   367

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

   368

        commands.sort()

   369

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

   370

   371

    def AppendStartupCommand(self, command_infos):

   372

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

   373

        if slave is not None:

   374

            command_idx = slave.appendStartupCommand(command_infos)

   375

            self.BufferModel()

   376

            return command_idx

   377

        return None

   378

   379

    def SetStartupCommandInfos(self, command_infos):

   380

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

   381

        if slave is not None:

   382

            slave.setStartupCommand(command_infos)

   383

            self.BufferModel()

   384

   385

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

   386

        slave = self.GetSlave(slave_pos)

   387

        if slave is not None:

   388

            slave.removeStartupCommand(command_idx)

   389

            if buffer:

   390

                self.BufferModel()

   391

   392

    def SetProcessVariables(self, variables):

   393

        vars = []

   394

        for var in variables:

   395

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

   396

            variable.setName(var["Name"])

   397

            variable.setComment(var["Description"])

   398

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

   399

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

   400

                if variable.getReadFrom() is None:

   401

                    variable.addReadFrom()

   402

                read_from = variable.getReadFrom()

   403

                read_from.setPosition(position)

   404

                read_from.setIndex(index)

   405

                read_from.setSubIndex(subindex)

   406

            elif variable.getReadFrom() is not None:

   407

                variable.deleteReadFrom()

   408

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

   409

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

   410

                if variable.getWriteTo() is None:

   411

                    variable.addWriteTo()

   412

                write_to = variable.getWriteTo()

   413

                write_to.setPosition(position)

   414

                write_to.setIndex(index)

   415

                write_to.setSubIndex(subindex)

   416

            elif variable.getWriteTo() is not None:

   417

                variable.deleteWriteTo()

   418

            vars.append(variable)

   419

        self.ProcessVariables.setvariable(vars)

   420

        self.BufferModel()

   421

   422

    def GetProcessVariables(self):

   423

        variables = []

   424

        idx = 0

   425

        for variable in self.ProcessVariables.getvariable():

   426

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

   427

                   "Number": idx,

   428

                   "Description": variable.getComment()}

   429

            read_from = variable.getReadFrom()

   430

            if read_from is not None:

   431

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

   432

                                   read_from.getIndex(),

   433

                                   read_from.getSubIndex())

   434

            else:

   435

                var["ReadFrom"] = ""

   436

            write_to = variable.getWriteTo()

   437

            if write_to is not None:

   438

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

   439

                                  write_to.getIndex(),

   440

                                  write_to.getSubIndex())

   441

            else:

   442

                var["WriteTo"] = ""

   443

            variables.append(var)

   444

            idx += 1

   445

        return variables

   446

   447

    def _ScanNetwork(self):

   448

        app_frame = self.GetCTRoot().AppFrame

   449

   450

        execute = True

   451

        if len(self.Children) > 0:

   452

            dialog = wx.MessageDialog(

   453

                app_frame,

   454

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

   455

                _("Scan Network"),

   456

                wx.YES_NO | wx.ICON_QUESTION)

   457

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

   458

            dialog.Destroy()

   459

   460

        if execute:

   461

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

   462

            if error != 0:

   463

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

   464

                dialog.ShowModal()

   465

                dialog.Destroy()

   466

            elif returnVal is not None:

   467

                for child in self.IECSortedChildren():

   468

                    self._doRemoveChild(child)

   469

   470

                for slave in returnVal:

   471

                    type_infos = {

   472

                        "vendor": slave["vendor_id"],

   473

                        "product_code": slave["product_code"],

   474

                        "revision_number": slave["revision_number"],

   475

                    }

   476

                    device, _module_extra_params = self.GetModuleInfos(type_infos)

   477

                    if device is not None:

   478

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

   479

                            CTNType = "EthercatCIA402Slave"

   480

                        else:

   481

                            CTNType = "EthercatSlave"

   482

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

   483

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

   484

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

   485

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

   486

   487

                if app_frame:

   488

                    app_frame.RefreshProjectTree()

   489

   490

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

   491

        """

   492

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

   493

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

   494

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

   495

        """

   496

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

   497

   498

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

   499

        if slave is None:

   500

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

   501

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

   502

            slave_infos = slave.getInfo()

   503

            slave_infos.setName("undefined")

   504

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

   505

            slave_infos.setAutoIncAddr(0)

   506

            self.BufferModel()

   507

            self.OnCTNSave()

   508

   509

        return newConfNodeOpj