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

    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", self.GetSlaveTypesLibrary())

   298

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

   299

            type_infos = dialog.GetValueInfos()

   300

            device, module_extra_params = self.GetModuleInfos(type_infos)

   301

            if device is not None:

   302

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

   303

                    ConfNodeType = "EthercatCIA402Slave"

   304

                else:

   305

                    ConfNodeType = "EthercatSlave"

   306

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

   307

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

   308

                self.CTNRequestSave()

   309

                new_child._OpenView()

   310

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   311

        dialog.Destroy()

   312

   313

    def ExtractHexDecValue(self, value):

   314

        return ExtractHexDecValue(value)

   315

   316

    def GetSizeOfType(self, type):

   317

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

   318

   319

    def ConfigFileName(self):

   320

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

   321

   322

    def ProcessVariablesFileName(self):

   323

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

   324

   325

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

   326

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

   327

            return False

   328

        type_infos = slave.getType()

   329

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

   330

            return False

   331

        device, module_extra_params = self.GetModuleInfos(type_infos)

   332

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

   333

            return False

   334

        return True

   335

   336

    def GetSlaveName(self, slave_pos):

   337

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   338

        if CTNChild is not None:

   339

            return CTNChild.CTNName()

   340

        return self.CTNName()

   341

   342

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

   343

        slaves = []

   344

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

   345

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

   346

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

   347

        slaves.sort()

   348

        return slaves

   349

   350

    def GetSlave(self, slave_pos):

   351

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

   352

            slave_info = slave.getInfo()

   353

            if slave_info.getPhysAddr() == slave_pos:

   354

                return slave

   355

        return None

   356

   357

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

   358

        commands = []

   359

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

   360

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

   361

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

   362

        commands.sort()

   363

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

   364

   365

    def AppendStartupCommand(self, command_infos):

   366

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

   367

        if slave is not None:

   368

            command_idx = slave.appendStartupCommand(command_infos)

   369

            self.BufferModel()

   370

            return command_idx

   371

        return None

   372

   373

    def SetStartupCommandInfos(self, command_infos):

   374

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

   375

        if slave is not None:

   376

            slave.setStartupCommand(command_infos)

   377

            self.BufferModel()

   378

   379

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

   380

        slave = self.GetSlave(slave_pos)

   381

        if slave is not None:

   382

            slave.removeStartupCommand(command_idx)

   383

            if buffer:

   384

                self.BufferModel()

   385

   386

    def SetProcessVariables(self, variables):

   387

        vars = []

   388

        for var in variables:

   389

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

   390

            variable.setName(var["Name"])

   391

            variable.setComment(var["Description"])

   392

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

   393

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

   394

                if variable.getReadFrom() is None:

   395

                    variable.addReadFrom()

   396

                read_from = variable.getReadFrom()

   397

                read_from.setPosition(position)

   398

                read_from.setIndex(index)

   399

                read_from.setSubIndex(subindex)

   400

            elif variable.getReadFrom() is not None:

   401

                variable.deleteReadFrom()

   402

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

   403

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

   404

                if variable.getWriteTo() is None:

   405

                    variable.addWriteTo()

   406

                write_to = variable.getWriteTo()

   407

                write_to.setPosition(position)

   408

                write_to.setIndex(index)

   409

                write_to.setSubIndex(subindex)

   410

            elif variable.getWriteTo() is not None:

   411

                variable.deleteWriteTo()

   412

            vars.append(variable)

   413

        self.ProcessVariables.setvariable(vars)

   414

        self.BufferModel()

   415

   416

    def GetProcessVariables(self):

   417

        variables = []

   418

        idx = 0

   419

        for variable in self.ProcessVariables.getvariable():

   420

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

   421

                   "Number": idx,

   422

                   "Description": variable.getComment()}

   423

            read_from = variable.getReadFrom()

   424

            if read_from is not None:

   425

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

   426

                                   read_from.getIndex(),

   427

                                   read_from.getSubIndex())

   428

            else:

   429

                var["ReadFrom"] = ""

   430

            write_to = variable.getWriteTo()

   431

            if write_to is not None:

   432

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

   435

            else:

   436

                var["WriteTo"] = ""

   437

            variables.append(var)

   438

            idx += 1

   439

        return variables

   440

   441

    def _ScanNetwork(self):

   442

        app_frame = self.GetCTRoot().AppFrame

   443

   444

        execute = True

   445

        if len(self.Children) > 0:

   446

            dialog = wx.MessageDialog(app_frame,

   447

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

   448

                _("Scan Network"),

   449

                wx.YES_NO | wx.ICON_QUESTION)

   450

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

   451

            dialog.Destroy()

   452

   453

        if execute:

   454

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

   455

            if error != 0:

   456

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

   457

                dialog.ShowModal()

   458

                dialog.Destroy()

   459

            elif returnVal is not None:

   460

                for child in self.IECSortedChildren():

   461

                    self._doRemoveChild(child)

   462

   463

                for slave in returnVal:

   464

                    type_infos = {

   465

                        "vendor": slave["vendor_id"],

   466

                        "product_code": slave["product_code"],

   467

                        "revision_number": slave["revision_number"],

   468

                    }

   469

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   470

                    if device is not None:

   471

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

   472

                            CTNType = "EthercatCIA402Slave"

   473

                        else:

   474

                            CTNType = "EthercatSlave"

   475

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

   476

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

   477

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

   478

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

   479

   480

                if app_frame:

   481

                    app_frame.RefreshProjectTree()

   482

   483

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

   484

        """

   485

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

   486

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

   487

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

   488

        """

   489

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

   490

   491

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

   492

        if slave is None:

   493

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

   494

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

   495

            slave_infos = slave.getInfo()

   496

            slave_infos.setName("undefined")

   497

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

   498

            slave_infos.setAutoIncAddr(0)

   499

            self.BufferModel()

   500

            self.OnCTNSave()

   501

   502

        return newConfNodeOpj

   503

   504

    def _doRemoveChild(self, CTNInstance):

   505

        slave_pos = CTNInstance.GetSlavePos()

   506

        config = self.Config.getConfig()

   507

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

   508

            slave_infos = slave.getInfo()

   509

            if slave_infos.getPhysAddr() == slave_pos:

   510

                config.removeSlave(idx)

   511

                self.BufferModel()