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

    15

from copy import deepcopy

    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

    25

    26

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

    27

from EthercatCFileGenerator import _EthercatCFileGenerator

    28

from ConfigEditor import MasterEditor

    29

from POULibrary import POULibrary

    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

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

    99

   100

   101

def sort_commands(x, y):

   102

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

   103

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

   104

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

   105

   106

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

   107

if cls:

   108

   109

    def getType(self):

   110

        slave_info = self.getInfo()

   111

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

   112

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

   113

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

   114

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

   115

    setattr(cls, "getType", getType)

   116

   117

    def setType(self, type_infos):

   118

        slave_info = self.getInfo()

   119

        slave_info.setName(type_infos["device_type"])

   120

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

   121

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

   122

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

   123

    setattr(cls, "setType", setType)

   124

   125

    def getInitCmds(self, create_default=False):

   126

        Mailbox = self.getMailbox()

   127

        if Mailbox is None:

   128

            if create_default:

   129

                self.addMailbox()

   130

                Mailbox = self.getMailbox()

   131

            else:

   132

                return None

   133

        CoE = Mailbox.getCoE()

   134

        if CoE is None:

   135

            if create_default:

   136

                Mailbox.addCoE()

   137

                CoE = Mailbox.getCoE()

   138

            else:

   139

                return None

   140

        InitCmds = CoE.getInitCmds()

   141

        if InitCmds is None and create_default:

   142

            CoE.addInitCmds()

   143

            InitCmds = CoE.getInitCmds()

   144

        return InitCmds

   145

    setattr(cls, "getInitCmds", getInitCmds)

   146

   147

    def getStartupCommands(self):

   148

        pos = self.getInfo().getPhysAddr()

   149

        InitCmds = self.getInitCmds()

   150

        if InitCmds is None:

   151

            return []

   152

        commands = []

   153

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

   154

            comment = InitCmd.getComment()

   155

            if comment is None:

   156

                comment = ""

   157

            commands.append({

   158

                "command_idx": idx,

   159

                "Position": pos,

   160

                "Index": InitCmd.getIndex(),

   161

                "Subindex": InitCmd.getSubIndex(),

   162

                "Value": InitCmd.getData(),

   163

                "Description": comment})

   164

        commands.sort(sort_commands)

   165

        return commands

   166

    setattr(cls, "getStartupCommands", getStartupCommands)

   167

   168

    def appendStartupCommand(self, command_infos):

   169

        InitCmds = self.getInitCmds(True)

   170

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

   171

        InitCmds.appendInitCmd(command)

   172

        command.setIndex(command_infos["Index"])

   173

        command.setSubIndex(command_infos["Subindex"])

   174

        command.setData(command_infos["Value"])

   175

        command.setComment(command_infos["Description"])

   176

        return len(InitCmds.getInitCmd()) - 1

   177

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   178

   179

    def setStartupCommand(self, command_infos):

   180

        InitCmds = self.getInitCmds()

   181

        if InitCmds is not None:

   182

            commands = InitCmds.getInitCmd()

   183

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

   184

                command = commands[command_infos["command_idx"]]

   185

                command.setIndex(command_infos["Index"])

   186

                command.setSubIndex(command_infos["Subindex"])

   187

                command.setData(command_infos["Value"])

   188

                command.setComment(command_infos["Description"])

   189

    setattr(cls, "setStartupCommand", setStartupCommand)

   190

   191

    def removeStartupCommand(self, command_idx):

   192

        InitCmds = self.getInitCmds()

   193

        if InitCmds is not None:

   194

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

   195

                InitCmds.removeInitCmd(command_idx)

   196

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   197

   198

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

   199

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

   200

      <xsd:element name="ProcessVariables">

   201

        <xsd:complexType>

   202

          <xsd:sequence>

   203

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

   204

              <xsd:complexType>

   205

                <xsd:sequence>

   206

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

   207

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

   208

                </xsd:sequence>

   209

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

   210

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

   211

              </xsd:complexType>

   212

            </xsd:element>

   213

          </xsd:sequence>

   214

        </xsd:complexType>

   215

      </xsd:element>

   216

      <xsd:complexType name="LocationDesc">

   217

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

   218

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

   219

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

   220

      </xsd:complexType>

   221

    </xsd:schema>

   222

"""

   223

   224

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   225

   226

   227

class _EthercatCTN:

   228

   229

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

   230

    if HAS_MCL:

   231

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

   232

    EditorType = MasterEditor

   233

   234

    def __init__(self):

   235

        config_filepath = self.ConfigFileName()

   236

        config_is_saved = False

   237

        self.Config = None

   238

        if os.path.isfile(config_filepath):

   239

            config_xmlfile = open(config_filepath, 'r')

   240

            try:

   241

                self.Config, error = \

   242

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   243

                if error is None:

   244

                    config_is_saved = True

   245

            except Exception, e:

   246

                error = e.message

   247

            config_xmlfile.close()

   248

   249

            if error is not None:

   250

                self.GetCTRoot().logger.write_error(

   251

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

   252

   253

        if self.Config is None:

   254

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

   255

   256

        process_filepath = self.ProcessVariablesFileName()

   257

        process_is_saved = False

   258

        self.ProcessVariables = None

   259

        if os.path.isfile(process_filepath):

   260

            process_xmlfile = open(process_filepath, 'r')

   261

            try:

   262

                self.ProcessVariables, error = \

   263

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   264

                if error is None:

   265

                    process_is_saved = True

   266

            except Exception, e:

   267

                error = e.message

   268

            process_xmlfile.close()

   269

   270

            if error is not None:

   271

                self.GetCTRoot().logger.write_error(

   272

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

   273

   274

        if self.ProcessVariables is None:

   275

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

   276

   277

        if config_is_saved and process_is_saved:

   278

            self.CreateBuffer(True)

   279

        else:

   280

            self.CreateBuffer(False)

   281

            self.OnCTNSave()

   282

   283

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

   284

        self.CommonMethod = _CommonSlave(self)

   285

   286

    def GetIconName(self):

   287

        return "Ethercat"

   288

   289

    def GetContextualMenuItems(self):

   290

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

   291

   292

    def OnAddEthercatSlave(self, event):

   293

        app_frame = self.GetCTRoot().AppFrame

   294

        dialog = BrowseValuesLibraryDialog(app_frame,

   295

            "Ethercat Slave Type", self.GetSlaveTypesLibrary())

   296

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

   297

            type_infos = dialog.GetValueInfos()

   298

            device, module_extra_params = self.GetModuleInfos(type_infos)

   299

            if device is not None:

   300

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

   301

                    ConfNodeType = "EthercatCIA402Slave"

   302

                else:

   303

                    ConfNodeType = "EthercatSlave"

   304

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

   305

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

   306

                self.CTNRequestSave()

   307

                new_child._OpenView()

   308

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   309

        dialog.Destroy()

   310

   311

    def ExtractHexDecValue(self, value):

   312

        return ExtractHexDecValue(value)

   313

   314

    def GetSizeOfType(self, type):

   315

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

   316

   317

    def ConfigFileName(self):

   318

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

   319

   320

    def ProcessVariablesFileName(self):

   321

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

   322

   323

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

   324

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

   325

            return False

   326

        type_infos = slave.getType()

   327

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

   328

            return False

   329

        device, module_extra_params = self.GetModuleInfos(type_infos)

   330

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

   331

            return False

   332

        return True

   333

   334

    def GetSlaveName(self, slave_pos):

   335

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   336

        if CTNChild is not None:

   337

            return CTNChild.CTNName()

   338

        return self.CTNName()

   339

   340

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

   341

        slaves = []

   342

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

   343

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

   344

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

   345

        slaves.sort()

   346

        return slaves

   347

   348

    def GetSlave(self, slave_pos):

   349

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

   350

            slave_info = slave.getInfo()

   351

            if slave_info.getPhysAddr() == slave_pos:

   352

                return slave

   353

        return None

   354

   355

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

   356

        commands = []

   357

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

   358

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

   359

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

   360

        commands.sort()

   361

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

   362

   363

    def AppendStartupCommand(self, command_infos):

   364

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

   365

        if slave is not None:

   366

            command_idx = slave.appendStartupCommand(command_infos)

   367

            self.BufferModel()

   368

            return command_idx

   369

        return None

   370

   371

    def SetStartupCommandInfos(self, command_infos):

   372

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

   373

        if slave is not None:

   374

            slave.setStartupCommand(command_infos)

   375

            self.BufferModel()

   376

   377

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

   378

        slave = self.GetSlave(slave_pos)

   379

        if slave is not None:

   380

            slave.removeStartupCommand(command_idx)

   381

            if buffer:

   382

                self.BufferModel()

   383

   384

    def SetProcessVariables(self, variables):

   385

        vars = []

   386

        for var in variables:

   387

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

   388

            variable.setName(var["Name"])

   389

            variable.setComment(var["Description"])

   390

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

   391

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

   392

                if variable.getReadFrom() is None:

   393

                    variable.addReadFrom()

   394

                read_from = variable.getReadFrom()

   395

                read_from.setPosition(position)

   396

                read_from.setIndex(index)

   397

                read_from.setSubIndex(subindex)

   398

            elif variable.getReadFrom() is not None:

   399

                variable.deleteReadFrom()

   400

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

   401

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

   402

                if variable.getWriteTo() is None:

   403

                    variable.addWriteTo()

   404

                write_to = variable.getWriteTo()

   405

                write_to.setPosition(position)

   406

                write_to.setIndex(index)

   407

                write_to.setSubIndex(subindex)

   408

            elif variable.getWriteTo() is not None:

   409

                variable.deleteWriteTo()

   410

            vars.append(variable)

   411

        self.ProcessVariables.setvariable(vars)

   412

        self.BufferModel()

   413

   414

    def GetProcessVariables(self):

   415

        variables = []

   416

        idx = 0

   417

        for variable in self.ProcessVariables.getvariable():

   418

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

   419

                   "Number": idx,

   420

                   "Description": variable.getComment()}

   421

            read_from = variable.getReadFrom()

   422

            if read_from is not None:

   423

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

   424

                                   read_from.getIndex(),

   425

                                   read_from.getSubIndex())

   426

            else:

   427

                var["ReadFrom"] = ""

   428

            write_to = variable.getWriteTo()

   429

            if write_to is not None:

   430

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

   431

                                   write_to.getIndex(),

   432

                                   write_to.getSubIndex())

   433

            else:

   434

                var["WriteTo"] = ""

   435

            variables.append(var)

   436

            idx += 1

   437

        return variables

   438

   439

    def _ScanNetwork(self):

   440

        app_frame = self.GetCTRoot().AppFrame

   441

   442

        execute = True

   443

        if len(self.Children) > 0:

   444

            dialog = wx.MessageDialog(app_frame,

   445

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

   446

                _("Scan Network"),

   447

                wx.YES_NO | wx.ICON_QUESTION)

   448

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

   449

            dialog.Destroy()

   450

   451

        if execute:

   452

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

   453

            if error != 0:

   454

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

   455

                dialog.ShowModal()

   456

                dialog.Destroy()

   457

            elif returnVal is not None:

   458

                for child in self.IECSortedChildren():

   459

                    self._doRemoveChild(child)

   460

   461

                for slave in returnVal:

   462

                    type_infos = {

   463

                        "vendor": slave["vendor_id"],

   464

                        "product_code": slave["product_code"],

   465

                        "revision_number": slave["revision_number"],

   466

                    }

   467

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   468

                    if device is not None:

   469

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

   470

                            CTNType = "EthercatCIA402Slave"

   471

                        else:

   472

                            CTNType = "EthercatSlave"

   473

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

   474

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

   475

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

   476

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

   477

   478

                if app_frame:

   479

                    app_frame.RefreshProjectTree()

   480

   481

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

   482

        """

   483

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

   484

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

   485

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

   486

        """

   487

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

   488

   489

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

   490

        if slave is None:

   491

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

   492

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

   493

            slave_infos = slave.getInfo()

   494

            slave_infos.setName("undefined")

   495

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

   496

            slave_infos.setAutoIncAddr(0)

   497

            self.BufferModel()

   498

            self.OnCTNSave()

   499

   500

        return newConfNodeOpj

   501

   502

    def _doRemoveChild(self, CTNInstance):

   503

        slave_pos = CTNInstance.GetSlavePos()

   504

        config = self.Config.getConfig()

   505

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

   506

            slave_infos = slave.getInfo()

   507

            if slave_infos.getPhysAddr() == slave_pos:

   508

                config.removeSlave(idx)

   509

                self.BufferModel()

   510

                self.OnCTNSave()

   511

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   512