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:

    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

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

        try:

    89

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

    90

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

    91

        except:

    92

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

    93

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

    94

    95

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

    96

#                 Ethercat MASTER

    97

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

    98

    99

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

   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

class _EthercatCTN:

   227

   228

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

   229

    if HAS_MCL:

   230

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

   231

    EditorType = MasterEditor

   232

   233

    def __init__(self):

   234

        config_filepath = self.ConfigFileName()

   235

        config_is_saved = False

   236

        self.Config = None

   237

   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

        if process_is_saved:

   279

            self.CreateBuffer(True)

   280

        else:

   281

            self.CreateBuffer(False)

   282

            self.OnCTNSave()

   283

   284

        if os.path.isfile(config_filepath):

   285

            config_xmlfile = open(config_filepath, 'r')

   286

            try:

   287

                self.Config, error = \

   288

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   289

                if error is None:

   290

                    config_is_saved = True

   291

            except Exception, e:

   292

                error = e.message

   293

            config_xmlfile.close()

   294

   295

            if error is not None:

   296

                self.GetCTRoot().logger.write_error(

   297

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

   298

   299

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

   300

        self.CommonMethod = _CommonSlave(self)

   301

   302

        ###################################### Test Section #########################################

   303

   304

    def GetIconName(self):

   305

        return "Ethercat"

   306

   307

    def GetContextualMenuItems(self):

   308

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

   309

   310

    def OnAddEthercatSlave(self, event):

   311

        app_frame = self.GetCTRoot().AppFrame

   312

        dialog = BrowseValuesLibraryDialog(app_frame, 

   313

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

   314

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

   315

            type_infos = dialog.GetValueInfos()

   316

            device, module_extra_params = self.GetModuleInfos(type_infos)

   317

            if device is not None:

   318

                # device.GetProfileNumbers() return type is string

   319

                # _EthercatCIA402SlaveCTN.NODE_PROFILE change to string

   320

                # 151224 jblee

   321

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

   322

                    ConfNodeType = "EthercatCIA402Slave"

   323

                else:

   324

                    ConfNodeType = "EthercatSlave"

   325

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

   326

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

   327

                self.CTNRequestSave()

   328

                new_child._OpenView()

   329

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   330

        dialog.Destroy()

   331

   332

    def ExtractHexDecValue(self, value):

   333

        return ExtractHexDecValue(value)

   334

   335

    def GetSizeOfType(self, type):

   336

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

   337

   338

    def ConfigFileName(self):

   339

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

   340

   341

    def ProcessVariablesFileName(self):

   342

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

   343

   344

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

   345

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

   346

            return False

   347

        type_infos = slave.getType()

   348

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

   349

            return False

   350

        device, module_extra_params = self.GetModuleInfos(type_infos)

   351

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

   352

            return False

   353

        return True

   354

   355

    def GetSlaveName(self, slave_pos):

   356

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   357

        if CTNChild is not None:

   358

            return CTNChild.CTNName()

   359

        return self.CTNName()

   360

   361

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

   362

        slaves = []

   363

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

   364

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

   365

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

   366

        slaves.sort()

   367

        return slaves

   368

   369

    def GetSlave(self, slave_pos):

   370

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

   371

            slave_info = slave.getInfo()

   372

            if slave_info.getPhysAddr() == slave_pos:

   373

                return slave

   374

        return None

   375

   376

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

   377

        commands = []

   378

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

   379

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

   380

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

   381

        commands.sort()

   382

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

   383

   384

    def AppendStartupCommand(self, command_infos):

   385

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

   386

        if slave is not None:

   387

            command_idx = slave.appendStartupCommand(command_infos)

   388

            self.BufferModel()

   389

            return command_idx

   390

        return None

   391

   392

    def SetStartupCommandInfos(self, command_infos):

   393

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

   394

        if slave is not None:

   395

            slave.setStartupCommand(command_infos)

   396

            self.BufferModel()

   397

   398

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

   399

        slave = self.GetSlave(slave_pos)

   400

        if slave is not None:

   401

            slave.removeStartupCommand(command_idx)

   402

            if buffer:

   403

                self.BufferModel()

   404

   405

    def SetProcessVariables(self, variables):

   406

        vars = []

   407

        for var in variables:

   408

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

   409

            variable.setName(var["Name"])

   410

            variable.setComment(var["Description"])

   411

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

   412

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

   413

                if variable.getReadFrom() is None:

   414

                    variable.addReadFrom()

   415

                read_from = variable.getReadFrom()

   416

                read_from.setPosition(position)

   417

                read_from.setIndex(index)

   418

                read_from.setSubIndex(subindex)

   419

            elif variable.getReadFrom() is not None:

   420

                variable.deleteReadFrom()

   421

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

   422

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

   423

                if variable.getWriteTo() is None:

   424

                    variable.addWriteTo()

   425

                write_to = variable.getWriteTo()

   426

                write_to.setPosition(position)

   427

                write_to.setIndex(index)

   428

                write_to.setSubIndex(subindex)

   429

            elif variable.getWriteTo() is not None:

   430

                variable.deleteWriteTo()

   431

            vars.append(variable)

   432

        self.ProcessVariables.setvariable(vars)

   433

        self.BufferModel()

   434

   435

    def GetProcessVariables(self):

   436

        variables = []

   437

        idx = 0

   438

        for variable in self.ProcessVariables.getvariable():

   439

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

   440

                   "Number": idx,

   441

                   "Description": variable.getComment()}

   442

            read_from = variable.getReadFrom()

   443

            if read_from is not None:

   444

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

   445

                                   read_from.getIndex(),

   446

                                   read_from.getSubIndex())

   447

            else:

   448

                var["ReadFrom"] = ""

   449

            write_to = variable.getWriteTo()

   450

            if write_to is not None:

   451

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

   452

                                   write_to.getIndex(),

   453

                                   write_to.getSubIndex())

   454

            else:

   455

                var["WriteTo"] = ""

   456

            variables.append(var)

   457

            idx += 1

   458

        return variables

   459

   460

    def _ScanNetwork(self):

   461

        app_frame = self.GetCTRoot().AppFrame

   462

   463

        execute = True

   464

        if len(self.Children) > 0:

   465

            dialog = wx.MessageDialog(app_frame, 

   466

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

   467

                _("Scan Network"), 

   468

                wx.YES_NO|wx.ICON_QUESTION)

   469

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

   470

            dialog.Destroy()

   471

   472

        if execute:

   473

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

   474

            if error != 0:

   475

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

   476

                dialog.ShowModal()

   477

                dialog.Destroy()

   478

            elif returnVal is not None:

   479

                for child in self.IECSortedChildren():

   480

                    self._doRemoveChild(child)

   481

   482

                for slave in returnVal:

   483

                    type_infos = {

   484

                        "vendor": slave["vendor_id"],

   485

                        "product_code": slave["product_code"],

   486

                        "revision_number":slave["revision_number"],

   487

                    }

   488

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   489

                    if device is not None:

   490

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

   491

                            CTNType = "EthercatCIA402Slave"

   492

                        else:

   493

                            CTNType = "EthercatSlave"

   494

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

   495

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

   496

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

   497

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

   498

   499

                if app_frame:

   500

                    app_frame.RefreshProjectTree()

   501

   502

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

   503

        """

   504

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

   505

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

   506

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

   507

        """

   508

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

   509

   510

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

   511

        if slave is None:

   512

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

   513

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

   514

            slave_infos = slave.getInfo()

   515

            slave_infos.setName("undefined")

   516

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

   517

            slave_infos.setAutoIncAddr(0)

   518

            self.BufferModel()

   519