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

    38

#         Remote Exec Etherlab Commands

    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

    68

#      Etherlab Specific Blocks Library

    70

    71

def GetLocalPath(filename):

    72

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

    73

    74

class EtherlabLibrary(POULibrary):

    75

    def GetLibraryPath(self):

    76

        return GetLocalPath("pous.xml")

    77

    78

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

    79

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

    80

        etherlab_ext_code = etherlab_ext_file.read()

    81

        etherlab_ext_file.close()

    82

    83

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

    84

        ethelabfile = open(Gen_etherlabfile_path,'w')

    85

        ethelabfile.write(etherlab_ext_code)

    86

        ethelabfile.close()

    87

    88

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

    89

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

    90

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

    91

    93

#                 Ethercat MASTER

    95

    96

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

    97

    98

def sort_commands(x, y):

    99

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

   100

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

   101

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

   102

   103

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

   104

if cls:

   105

   106

    def getType(self):

   107

        slave_info = self.getInfo()

   108

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

   109

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

   110

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

   111

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

   112

    setattr(cls, "getType", getType)

   113

   114

    def setType(self, type_infos):

   115

        slave_info = self.getInfo()

   116

        slave_info.setName(type_infos["device_type"])

   117

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

   118

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

   119

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

   120

    setattr(cls, "setType", setType)

   121

   122

    def getInitCmds(self, create_default=False):

   123

        Mailbox = self.getMailbox()

   124

        if Mailbox is None:

   125

            if create_default:

   126

                self.addMailbox()

   127

                Mailbox = self.getMailbox()

   128

            else:

   129

                return None

   130

        CoE = Mailbox.getCoE()

   131

        if CoE is None:

   132

            if create_default:

   133

                Mailbox.addCoE()

   134

                CoE = Mailbox.getCoE()

   135

            else:

   136

                return None

   137

        InitCmds = CoE.getInitCmds()

   138

        if InitCmds is None and create_default:

   139

            CoE.addInitCmds()

   140

            InitCmds = CoE.getInitCmds()

   141

        return InitCmds

   142

    setattr(cls, "getInitCmds", getInitCmds)

   143

   144

    def getStartupCommands(self):

   145

        pos = self.getInfo().getPhysAddr()

   146

        InitCmds = self.getInitCmds()

   147

        if InitCmds is None:

   148

            return []

   149

        commands = []

   150

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

   151

            comment = InitCmd.getComment()

   152

            if comment is None:

   153

                comment = ""

   154

            commands.append({

   155

                "command_idx": idx,

   156

                "Position": pos,

   157

                "Index": InitCmd.getIndex(),

   158

                "Subindex": InitCmd.getSubIndex(),

   159

                "Value": InitCmd.getData(),

   160

                "Description": comment})

   161

        commands.sort(sort_commands)

   162

        return commands

   163

    setattr(cls, "getStartupCommands", getStartupCommands)

   164

   165

    def appendStartupCommand(self, command_infos):

   166

        InitCmds = self.getInitCmds(True)

   167

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

   168

        InitCmds.appendInitCmd(command)

   169

        command.setIndex(command_infos["Index"])

   170

        command.setSubIndex(command_infos["Subindex"])

   171

        command.setData(command_infos["Value"])

   172

        command.setComment(command_infos["Description"])

   173

        return len(InitCmds.getInitCmd()) - 1

   174

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   175

   176

    def setStartupCommand(self, command_infos):

   177

        InitCmds = self.getInitCmds()

   178

        if InitCmds is not None:

   179

            commands = InitCmds.getInitCmd()

   180

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

   181

                command = commands[command_infos["command_idx"]]

   182

                command.setIndex(command_infos["Index"])

   183

                command.setSubIndex(command_infos["Subindex"])

   184

                command.setData(command_infos["Value"])

   185

                command.setComment(command_infos["Description"])

   186

    setattr(cls, "setStartupCommand", setStartupCommand)

   187

   188

    def removeStartupCommand(self, command_idx):

   189

        InitCmds = self.getInitCmds()

   190

        if InitCmds is not None:

   191

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

   192

                InitCmds.removeInitCmd(command_idx)

   193

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   194

   195

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

   196

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

   197

      <xsd:element name="ProcessVariables">

   198

        <xsd:complexType>

   199

          <xsd:sequence>

   200

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

   201

              <xsd:complexType>

   202

                <xsd:sequence>

   203

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

   204

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

   205

                </xsd:sequence>

   206

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

   207

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

   208

              </xsd:complexType>

   209

            </xsd:element>

   210

          </xsd:sequence>

   211

        </xsd:complexType>

   212

      </xsd:element>

   213

      <xsd:complexType name="LocationDesc">

   214

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

   215

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

   216

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

   217

      </xsd:complexType>

   218

    </xsd:schema>

   219

"""

   220

   221

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

   222

   223

class _EthercatCTN:

   224

   225

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

   226

    if HAS_MCL:

   227

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

   228

    EditorType = MasterEditor

   229

   230

    def __init__(self):

   231

        config_filepath = self.ConfigFileName()

   232

        config_is_saved = False

   233

        self.Config = None

   234

        if os.path.isfile(config_filepath):

   235

            config_xmlfile = open(config_filepath, 'r')

   236

            try:

   237

                self.Config, error = \

   238

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   239

                if error is None:

   240

                    config_is_saved = True

   241

            except Exception, e:

   242

                error = e.message

   243

            config_xmlfile.close()

   244

   245

            if error is not None:

   246

                self.GetCTRoot().logger.write_error(

   247

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

   248

   249

        if self.Config is None:

   250

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

   251

   252

        process_filepath = self.ProcessVariablesFileName()

   253

        process_is_saved = False

   254

        self.ProcessVariables = None

   255

        if os.path.isfile(process_filepath):

   256

            process_xmlfile = open(process_filepath, 'r')

   257

            try:

   258

                self.ProcessVariables, error = \

   259

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   260

                if error is None:

   261

                    process_is_saved = True

   262

            except Exception, e:

   263

                error = e.message

   264

            process_xmlfile.close()

   265

   266

            if error is not None:

   267

                self.GetCTRoot().logger.write_error(

   268

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

   269

   270

        if self.ProcessVariables is None:

   271

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

   272

   273

        if config_is_saved and process_is_saved:

   274

            self.CreateBuffer(True)

   275

        else:

   276

            self.CreateBuffer(False)

   277

            self.OnCTNSave()

   278

   279

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

   280

        self.CommonMethod = _CommonSlave(self)

   281

   282

    def GetIconName(self):

   283

        return "Ethercat"

   284

   285

    def GetContextualMenuItems(self):

   286

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

   287

   288

    def OnAddEthercatSlave(self, event):

   289

        app_frame = self.GetCTRoot().AppFrame

   290

        dialog = BrowseValuesLibraryDialog(app_frame,

   291

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

   292

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

   293

            type_infos = dialog.GetValueInfos()

   294

            device, module_extra_params = self.GetModuleInfos(type_infos)

   295

            if device is not None:

   296

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

   297

                    ConfNodeType = "EthercatCIA402Slave"

   298

                else:

   299

                    ConfNodeType = "EthercatSlave"

   300

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

   301

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

   302

                self.CTNRequestSave()

   303

                new_child._OpenView()

   304

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   305

        dialog.Destroy()

   306

   307

    def ExtractHexDecValue(self, value):

   308

        return ExtractHexDecValue(value)

   309

   310

    def GetSizeOfType(self, type):

   311

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

   312

   313

    def ConfigFileName(self):

   314

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

   315

   316

    def ProcessVariablesFileName(self):

   317

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

   318

   319

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

   320

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

   321

            return False

   322

        type_infos = slave.getType()

   323

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

   324

            return False

   325

        device, module_extra_params = self.GetModuleInfos(type_infos)

   326

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

   327

            return False

   328

        return True

   329

   330

    def GetSlaveName(self, slave_pos):

   331

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   332

        if CTNChild is not None:

   333

            return CTNChild.CTNName()

   334

        return self.CTNName()

   335

   336

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

   337

        slaves = []

   338

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

   339

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

   340

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

   341

        slaves.sort()

   342

        return slaves

   343

   344

    def GetSlave(self, slave_pos):

   345

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

   346

            slave_info = slave.getInfo()

   347

            if slave_info.getPhysAddr() == slave_pos:

   348

                return slave

   349

        return None

   350

   351

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

   352

        commands = []

   353

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

   354

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

   355

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

   356

        commands.sort()

   357

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

   358

   359

    def AppendStartupCommand(self, command_infos):

   360

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

   361

        if slave is not None:

   362

            command_idx = slave.appendStartupCommand(command_infos)

   363

            self.BufferModel()

   364

            return command_idx

   365

        return None

   366

   367

    def SetStartupCommandInfos(self, command_infos):

   368

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

   369

        if slave is not None:

   370

            slave.setStartupCommand(command_infos)

   371

            self.BufferModel()

   372

   373

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

   374

        slave = self.GetSlave(slave_pos)

   375

        if slave is not None:

   376

            slave.removeStartupCommand(command_idx)

   377

            if buffer:

   378

                self.BufferModel()

   379

   380

    def SetProcessVariables(self, variables):

   381

        vars = []

   382

        for var in variables:

   383

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

   384

            variable.setName(var["Name"])

   385

            variable.setComment(var["Description"])

   386

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

   387

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

   388

                if variable.getReadFrom() is None:

   389

                    variable.addReadFrom()

   390

                read_from = variable.getReadFrom()

   391

                read_from.setPosition(position)

   392

                read_from.setIndex(index)

   393

                read_from.setSubIndex(subindex)

   394

            elif variable.getReadFrom() is not None:

   395

                variable.deleteReadFrom()

   396

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

   397

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

   398

                if variable.getWriteTo() is None:

   399

                    variable.addWriteTo()

   400

                write_to = variable.getWriteTo()

   401

                write_to.setPosition(position)

   402

                write_to.setIndex(index)

   403

                write_to.setSubIndex(subindex)

   404

            elif variable.getWriteTo() is not None:

   405

                variable.deleteWriteTo()

   406

            vars.append(variable)

   407

        self.ProcessVariables.setvariable(vars)

   408

        self.BufferModel()

   409

   410

    def GetProcessVariables(self):

   411

        variables = []

   412

        idx = 0

   413

        for variable in self.ProcessVariables.getvariable():

   414

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

   415

                   "Number": idx,

   416

                   "Description": variable.getComment()}

   417

            read_from = variable.getReadFrom()

   418

            if read_from is not None:

   419

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

   420

                                   read_from.getIndex(),

   421

                                   read_from.getSubIndex())

   422

            else:

   423

                var["ReadFrom"] = ""

   424

            write_to = variable.getWriteTo()

   425

            if write_to is not None:

   426

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

   427

                                   write_to.getIndex(),

   428

                                   write_to.getSubIndex())

   429

            else:

   430

                var["WriteTo"] = ""

   431

            variables.append(var)

   432

            idx += 1

   433

        return variables

   434

   435

    def _ScanNetwork(self):

   436

        app_frame = self.GetCTRoot().AppFrame

   437

   438

        execute = True

   439

        if len(self.Children) > 0:

   440

            dialog = wx.MessageDialog(app_frame,

   441

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

   442

                _("Scan Network"),

   443

                wx.YES_NO|wx.ICON_QUESTION)

   444

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

   445

            dialog.Destroy()

   446

   447

        if execute:

   448

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

   449

            if error != 0:

   450

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

   451

                dialog.ShowModal()

   452

                dialog.Destroy()

   453

            elif returnVal is not None:

   454

                for child in self.IECSortedChildren():

   455

                    self._doRemoveChild(child)

   456

   457

                for slave in returnVal:

   458

                    type_infos = {

   459

                        "vendor": slave["vendor_id"],

   460

                        "product_code": slave["product_code"],

   461

                        "revision_number":slave["revision_number"],

   462

                    }

   463

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   464

                    if device is not None:

   465

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

   466

                            CTNType = "EthercatCIA402Slave"

   467

                        else:

   468

                            CTNType = "EthercatSlave"

   469

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

   470

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

   471

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

   472

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

   473

   474

                if app_frame:

   475

                    app_frame.RefreshProjectTree()

   476

   477

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

   478

        """

   479

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

   480

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

   481

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

   482

        """

   483

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

   484

   485

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

   486

        if slave is None:

   487

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

   488

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

   489

            slave_infos = slave.getInfo()

   490

            slave_infos.setName("undefined")

   491

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

   492

            slave_infos.setAutoIncAddr(0)

   493

            self.BufferModel()

   494

            self.OnCTNSave()

   495

   496

        return newConfNodeOpj

   497

   498

    def _doRemoveChild(self, CTNInstance):

   499

        slave_pos = CTNInstance.GetSlavePos()

   500

        config = self.Config.getConfig()

   501

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

   502

            slave_infos = slave.getInfo()

   503

            if slave_infos.getPhysAddr() == slave_pos:

   504

                config.removeSlave(idx)

   505

                self.BufferModel()

   506

                self.OnCTNSave()

   507

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   508

   509

    def SetSlavePosition(self, slave_pos, new_pos):

   510

        slave = self.GetSlave(slave_pos)

   511

        if slave is not None:

   512

            slave_info = slave.getInfo()

   513

            slave_info.setPhysAddr(new_pos)