1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     5

#

     6

# Copyright (C) 2011-2014: Laurent BESSARD, Edouard TISSERANT

     7

#                          RTES Lab : CRKim, JBLee, youcu

     8

#                          Higen Motor : Donggu Kang

     9

#

    10

# See COPYING file for copyrights details.

    11

    12

import os

    13

import cPickle

    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_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    22

from ConfigTreeNode import ConfigTreeNode

    23

from dialogs import BrowseValuesLibraryDialog

    24

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    29

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

    30

    31

try:

    32

    from EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    33

    HAS_MCL = True

    34

except Exception:

    35

    HAS_MCL = False

    36

    37

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

    38

#         Remote Exec Etherlab Commands

    39

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

    40

    41

SCAN_COMMAND = """

    42

import commands

    43

result = commands.getoutput("ethercat slaves")

    44

slaves = []

    45

for slave_line in result.splitlines():

    46

    chunks = slave_line.split()

    47

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

    48

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

    49

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

    50

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

    51

             "alias": int(alias),

    52

             "position": int(position),

    53

             "name": name}

    54

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

    55

    for details_line in details.splitlines():

    56

        details_line = details_line.strip()

    57

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

    58

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

    59

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

    60

            if details_line.startswith(header):

    61

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

    62

                break

    63

    slaves.append(slave)

    64

returnVal = slaves

    65

"""

    66

    67

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

    68

#      Etherlab Specific Blocks Library

    69

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

    70

    71

    72

def GetLocalPath(filename):

    73

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

    74

    75

    76

class EtherlabLibrary(POULibrary):

    77

    def GetLibraryPath(self):

    78

        return GetLocalPath("pous.xml")

    79

    80

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

    81

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

    82

        etherlab_ext_code = etherlab_ext_file.read()

    83

        etherlab_ext_file.close()

    84

    85

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

    86

        ethelabfile = open(Gen_etherlabfile_path, 'w')

    87

        ethelabfile.write(etherlab_ext_code)

    88

        ethelabfile.close()

    89

    90

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

    91

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

    92

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

    93

    94

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

    95

#                 Ethercat MASTER

    96

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

    97

    98

    99

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

   100

   101

   102

def sort_commands(x, y):

   103

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

   104

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

   105

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

   106

   107

   108

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

   109

if cls:

   110

   111

    def getType(self):

   112

        slave_info = self.getInfo()

   113

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

   114

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

   115

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

   116

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

   117

    setattr(cls, "getType", getType)

   118

   119

    def setType(self, type_infos):

   120

        slave_info = self.getInfo()

   121

        slave_info.setName(type_infos["device_type"])

   122

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

   123

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

   124

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

   125

    setattr(cls, "setType", setType)

   126

   127

    def getInitCmds(self, create_default=False):

   128

        Mailbox = self.getMailbox()

   129

        if Mailbox is None:

   130

            if create_default:

   131

                self.addMailbox()

   132

                Mailbox = self.getMailbox()

   133

            else:

   134

                return None

   135

        CoE = Mailbox.getCoE()

   136

        if CoE is None:

   137

            if create_default:

   138

                Mailbox.addCoE()

   139

                CoE = Mailbox.getCoE()

   140

            else:

   141

                return None

   142

        InitCmds = CoE.getInitCmds()

   143

        if InitCmds is None and create_default:

   144

            CoE.addInitCmds()

   145

            InitCmds = CoE.getInitCmds()

   146

        return InitCmds

   147

    setattr(cls, "getInitCmds", getInitCmds)

   148

   149

    def getStartupCommands(self):

   150

        pos = self.getInfo().getPhysAddr()

   151

        InitCmds = self.getInitCmds()

   152

        if InitCmds is None:

   153

            return []

   154

        commands = []

   155

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

   156

            comment = InitCmd.getComment()

   157

            if comment is None:

   158

                comment = ""

   159

            commands.append({

   160

                "command_idx": idx,

   161

                "Position": pos,

   162

                "Index": InitCmd.getIndex(),

   163

                "Subindex": InitCmd.getSubIndex(),

   164

                "Value": InitCmd.getData(),

   165

                "Description": comment})

   166

        commands.sort(sort_commands)

   167

        return commands

   168

    setattr(cls, "getStartupCommands", getStartupCommands)

   169

   170

    def appendStartupCommand(self, command_infos):

   171

        InitCmds = self.getInitCmds(True)

   172

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

   173

        InitCmds.appendInitCmd(command)

   174

        command.setIndex(command_infos["Index"])

   175

        command.setSubIndex(command_infos["Subindex"])

   176

        command.setData(command_infos["Value"])

   177

        command.setComment(command_infos["Description"])

   178

        return len(InitCmds.getInitCmd()) - 1

   179

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   180

   181

    def setStartupCommand(self, command_infos):

   182

        InitCmds = self.getInitCmds()

   183

        if InitCmds is not None:

   184

            commands = InitCmds.getInitCmd()

   185

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

   186

                command = commands[command_infos["command_idx"]]

   187

                command.setIndex(command_infos["Index"])

   188

                command.setSubIndex(command_infos["Subindex"])

   189

                command.setData(command_infos["Value"])

   190

                command.setComment(command_infos["Description"])

   191

    setattr(cls, "setStartupCommand", setStartupCommand)

   192

   193

    def removeStartupCommand(self, command_idx):

   194

        InitCmds = self.getInitCmds()

   195

        if InitCmds is not None:

   196

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

   197

                InitCmds.removeInitCmd(command_idx)

   198

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   199

   200

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

   201

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

   202

      <xsd:element name="ProcessVariables">

   203

        <xsd:complexType>

   204

          <xsd:sequence>

   205

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

   206

              <xsd:complexType>

   207

                <xsd:sequence>

   208

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

   209

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

   210

                </xsd:sequence>

   211

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

   212

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

   213

              </xsd:complexType>

   214

            </xsd:element>

   215

          </xsd:sequence>

   216

        </xsd:complexType>

   217

      </xsd:element>

   218

      <xsd:complexType name="LocationDesc">

   219

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

   220

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

   221

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

   222

      </xsd:complexType>

   223

    </xsd:schema>

   224

"""

   225

   226

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   227

   228

   229

class _EthercatCTN:

   230

   231

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

   232

    if HAS_MCL:

   233

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

   234

    EditorType = MasterEditor

   235

   236

    def __init__(self):

   237

        config_filepath = self.ConfigFileName()

   238

        config_is_saved = False

   239

        self.Config = None

   240

        if os.path.isfile(config_filepath):

   241

            config_xmlfile = open(config_filepath, 'r')

   242

            try:

   243

                self.Config, error = \

   244

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   245

                if error is None:

   246

                    config_is_saved = True

   247

            except Exception, e:

   248

                error = e.message

   249

            config_xmlfile.close()

   250

   251

            if error is not None:

   252

                self.GetCTRoot().logger.write_error(

   253

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

   254

   255

        if self.Config is None:

   256

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

   257

   258

        process_filepath = self.ProcessVariablesFileName()

   259

        process_is_saved = False

   260

        self.ProcessVariables = None

   261

        if os.path.isfile(process_filepath):

   262

            process_xmlfile = open(process_filepath, 'r')

   263

            try:

   264

                self.ProcessVariables, error = \

   265

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   266

                if error is None:

   267

                    process_is_saved = True

   268

            except Exception, e:

   269

                error = e.message

   270

            process_xmlfile.close()

   271

   272

            if error is not None:

   273

                self.GetCTRoot().logger.write_error(

   274

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

   275

   276

        if self.ProcessVariables is None:

   277

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

   278

   279

        if config_is_saved and process_is_saved:

   280

            self.CreateBuffer(True)

   281

        else:

   282

            self.CreateBuffer(False)

   283

            self.OnCTNSave()

   284

   285

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

   286

        self.CommonMethod = _CommonSlave(self)

   287

   288

    def GetIconName(self):

   289

        return "Ethercat"

   290

   291

    def GetContextualMenuItems(self):

   292

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

   293

   294

    def OnAddEthercatSlave(self, event):

   295

        app_frame = self.GetCTRoot().AppFrame

   296

        dialog = BrowseValuesLibraryDialog(app_frame,

   297

                                           "Ethercat Slave Type",

   298

                                           self.GetSlaveTypesLibrary())

   299

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

   300

            type_infos = dialog.GetValueInfos()

   301

            device, module_extra_params = self.GetModuleInfos(type_infos)

   302

            if device is not None:

   303

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

   304

                    ConfNodeType = "EthercatCIA402Slave"

   305

                else:

   306

                    ConfNodeType = "EthercatSlave"

   307

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

   308

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

   309

                self.CTNRequestSave()

   310

                new_child._OpenView()

   311

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   312

        dialog.Destroy()

   313

   314

    def ExtractHexDecValue(self, value):

   315

        return ExtractHexDecValue(value)

   316

   317

    def GetSizeOfType(self, type):

   318

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

   319

   320

    def ConfigFileName(self):

   321

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

   322

   323

    def ProcessVariablesFileName(self):

   324

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

   325

   326

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

   327

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

   328

            return False

   329

        type_infos = slave.getType()

   330

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

   331

            return False

   332

        device, module_extra_params = self.GetModuleInfos(type_infos)

   333

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

   334

            return False

   335

        return True

   336

   337

    def GetSlaveName(self, slave_pos):

   338

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   339

        if CTNChild is not None:

   340

            return CTNChild.CTNName()

   341

        return self.CTNName()

   342

   343

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

   344

        slaves = []

   345

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

   346

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

   347

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

   348

        slaves.sort()

   349

        return slaves

   350

   351

    def GetSlave(self, slave_pos):

   352

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

   353

            slave_info = slave.getInfo()

   354

            if slave_info.getPhysAddr() == slave_pos:

   355

                return slave

   356

        return None

   357

   358

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

   359

        commands = []

   360

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

   361

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

   362

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

   363

        commands.sort()

   364

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

   365

   366

    def AppendStartupCommand(self, command_infos):

   367

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

   368

        if slave is not None:

   369

            command_idx = slave.appendStartupCommand(command_infos)

   370

            self.BufferModel()

   371

            return command_idx

   372

        return None

   373

   374

    def SetStartupCommandInfos(self, command_infos):

   375

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

   376

        if slave is not None:

   377

            slave.setStartupCommand(command_infos)

   378

            self.BufferModel()

   379

   380

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

   381

        slave = self.GetSlave(slave_pos)

   382

        if slave is not None:

   383

            slave.removeStartupCommand(command_idx)

   384

            if buffer:

   385

                self.BufferModel()

   386

   387

    def SetProcessVariables(self, variables):

   388

        vars = []

   389

        for var in variables:

   390

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

   391

            variable.setName(var["Name"])

   392

            variable.setComment(var["Description"])

   393

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

   394

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

   395

                if variable.getReadFrom() is None:

   396

                    variable.addReadFrom()

   397

                read_from = variable.getReadFrom()

   398

                read_from.setPosition(position)

   399

                read_from.setIndex(index)

   400

                read_from.setSubIndex(subindex)

   401

            elif variable.getReadFrom() is not None:

   402

                variable.deleteReadFrom()

   403

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

   404

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

   405

                if variable.getWriteTo() is None:

   406

                    variable.addWriteTo()

   407

                write_to = variable.getWriteTo()

   408

                write_to.setPosition(position)

   409

                write_to.setIndex(index)

   410

                write_to.setSubIndex(subindex)

   411

            elif variable.getWriteTo() is not None:

   412

                variable.deleteWriteTo()

   413

            vars.append(variable)

   414

        self.ProcessVariables.setvariable(vars)

   415

        self.BufferModel()

   416

   417

    def GetProcessVariables(self):

   418

        variables = []

   419

        idx = 0

   420

        for variable in self.ProcessVariables.getvariable():

   421

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

   422

                   "Number": idx,

   423

                   "Description": variable.getComment()}

   424

            read_from = variable.getReadFrom()

   425

            if read_from is not None:

   426

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

   427

                                   read_from.getIndex(),

   428

                                   read_from.getSubIndex())

   429

            else:

   430

                var["ReadFrom"] = ""

   431

            write_to = variable.getWriteTo()

   432

            if write_to is not None:

   433

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

   434

                                  write_to.getIndex(),

   435

                                  write_to.getSubIndex())

   436

            else:

   437

                var["WriteTo"] = ""

   438

            variables.append(var)

   439

            idx += 1

   440

        return variables

   441

   442

    def _ScanNetwork(self):

   443

        app_frame = self.GetCTRoot().AppFrame

   444

   445

        execute = True

   446

        if len(self.Children) > 0:

   447

            dialog = wx.MessageDialog(

   448

                app_frame,

   449

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

   450

                _("Scan Network"),

   451

                wx.YES_NO | wx.ICON_QUESTION)

   452

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

   453

            dialog.Destroy()

   454

   455

        if execute:

   456

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

   457

            if error != 0:

   458

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

   459

                dialog.ShowModal()

   460

                dialog.Destroy()

   461

            elif returnVal is not None:

   462

                for child in self.IECSortedChildren():

   463

                    self._doRemoveChild(child)

   464

   465

                for slave in returnVal:

   466

                    type_infos = {

   467

                        "vendor": slave["vendor_id"],

   468

                        "product_code": slave["product_code"],

   469

                        "revision_number": slave["revision_number"],

   470

                    }

   471

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   472

                    if device is not None:

   473

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

   474

                            CTNType = "EthercatCIA402Slave"

   475

                        else:

   476

                            CTNType = "EthercatSlave"

   477

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

   478

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

   479

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

   480

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

   481

   482

                if app_frame:

   483

                    app_frame.RefreshProjectTree()

   484

   485

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

   486

        """

   487

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

   488

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

   489

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

   490

        """

   491

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

   492

   493

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

   494

        if slave is None:

   495

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

   496

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

   497

            slave_infos = slave.getInfo()

   498

            slave_infos.setName("undefined")

   499

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

   500

            slave_infos.setAutoIncAddr(0)

   501

            self.BufferModel()

   502

            self.OnCTNSave()

   503

   504

        return newConfNodeOpj

   505

   506

    def _doRemoveChild(self, CTNInstance):

   507

        slave_pos = CTNInstance.GetSlavePos()

   508

        config = self.Config.getConfig()

   509

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

   510

            slave_infos = slave.getInfo()