1

import os

     2

import cPickle

     3

from lxml import etree

     4

from copy import deepcopy

     5

     6

import wx

     7

     8

from xmlclass import *

     9

    10

from PLCControler import UndoBuffer, LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    11

from ConfigTreeNode import ConfigTreeNode

    12

from dialogs import BrowseValuesLibraryDialog

    13

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    14

    15

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

    16

from EthercatCFileGenerator import _EthercatCFileGenerator

    17

from ConfigEditor import MasterEditor

    18

from POULibrary import POULibrary

    19

    20

try:

    21

    from EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    22

    HAS_MCL = True

    23

except:

    24

    HAS_MCL = False

    25

    26

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

    27

#         Remote Exec Etherlab Commands

    28

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

    29

    30

SCAN_COMMAND = """

    31

import commands

    32

result = commands.getoutput("ethercat slaves")

    33

slaves = []

    34

for slave_line in result.splitlines():

    35

    chunks = slave_line.split()

    36

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

    37

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

    38

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

    39

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

    40

             "alias": int(alias),

    41

             "position": int(position),

    42

             "name": name}

    43

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

    44

    for details_line in details.splitlines():

    45

        details_line = details_line.strip()

    46

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

    47

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

    48

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

    49

            if details_line.startswith(header):

    50

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

    51

                break

    52

    slaves.append(slave)

    53

returnVal = slaves

    54

"""

    55

    56

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

    57

#      Etherlab Specific Blocks Library

    58

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

    59

    60

def GetLocalPath(filename):

    61

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

    62

    63

class EtherlabLibrary(POULibrary):

    64

    def GetLibraryPath(self):

    65

        return GetLocalPath("pous.xml")

    66

    67

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

    68

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

    69

        etherlab_ext_code = etherlab_ext_file.read()

    70

        etherlab_ext_file.close()

    71

    72

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

    73

        ethelabfile = open(Gen_etherlabfile_path,'w')

    74

        ethelabfile.write(etherlab_ext_code)

    75

        ethelabfile.close()

    76

    77

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

    78

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

    79

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

    80

    81

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

    82

#                 Ethercat MASTER

    83

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

    84

    85

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

    86

    87

def sort_commands(x, y):

    88

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

    89

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

    90

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

    91

    92

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

    93

if cls:

    94

    95

    def getType(self):

    96

        slave_info = self.getInfo()

    97

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

    98

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

    99

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

   100

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

   101

    setattr(cls, "getType", getType)

   102

   103

    def setType(self, type_infos):

   104

        slave_info = self.getInfo()

   105

        slave_info.setName(type_infos["device_type"])

   106

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

   107

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

   108

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

   109

    setattr(cls, "setType", setType)

   110

   111

    def getInitCmds(self, create_default=False):

   112

        Mailbox = self.getMailbox()

   113

        if Mailbox is None:

   114

            if create_default:

   115

                self.addMailbox()

   116

                Mailbox = self.getMailbox()

   117

            else:

   118

                return None

   119

        CoE = Mailbox.getCoE()

   120

        if CoE is None:

   121

            if create_default:

   122

                Mailbox.addCoE()

   123

                CoE = Mailbox.getCoE()

   124

            else:

   125

                return None

   126

        InitCmds = CoE.getInitCmds()

   127

        if InitCmds is None and create_default:

   128

            CoE.addInitCmds()

   129

            InitCmds = CoE.getInitCmds()

   130

        return InitCmds

   131

    setattr(cls, "getInitCmds", getInitCmds)

   132

   133

    def getStartupCommands(self):

   134

        pos = self.getInfo().getPhysAddr()

   135

        InitCmds = self.getInitCmds()

   136

        if InitCmds is None:

   137

            return []

   138

        commands = []

   139

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

   140

            comment = InitCmd.getComment()

   141

            if comment is None:

   142

                comment = ""

   143

            commands.append({

   144

                "command_idx": idx,

   145

                "Position": pos,

   146

                "Index": InitCmd.getIndex(),

   147

                "Subindex": InitCmd.getSubIndex(),

   148

                "Value": InitCmd.getData(),

   149

                "Description": comment})

   150

        commands.sort(sort_commands)

   151

        return commands

   152

    setattr(cls, "getStartupCommands", getStartupCommands)

   153

   154

    def appendStartupCommand(self, command_infos):

   155

        InitCmds = self.getInitCmds(True)

   156

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

   157

        InitCmds.appendInitCmd(command)

   158

        command.setIndex(command_infos["Index"])

   159

        command.setSubIndex(command_infos["Subindex"])

   160

        command.setData(command_infos["Value"])

   161

        command.setComment(command_infos["Description"])

   162

        return len(InitCmds.getInitCmd()) - 1

   163

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   164

   165

    def setStartupCommand(self, command_infos):

   166

        InitCmds = self.getInitCmds()

   167

        if InitCmds is not None:

   168

            commands = InitCmds.getInitCmd()

   169

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

   170

                command = commands[command_infos["command_idx"]]

   171

                command.setIndex(command_infos["Index"])

   172

                command.setSubIndex(command_infos["Subindex"])

   173

                command.setData(command_infos["Value"])

   174

                command.setComment(command_infos["Description"])

   175

    setattr(cls, "setStartupCommand", setStartupCommand)

   176

   177

    def removeStartupCommand(self, command_idx):

   178

        InitCmds = self.getInitCmds()

   179

        if InitCmds is not None:

   180

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

   181

                InitCmds.removeInitCmd(command_idx)

   182

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   183

   184

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

   185

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

   186

      <xsd:element name="ProcessVariables">

   187

        <xsd:complexType>

   188

          <xsd:sequence>

   189

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

   190

              <xsd:complexType>

   191

                <xsd:sequence>

   192

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

   193

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

   194

                </xsd:sequence>

   195

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

   196

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

   197

              </xsd:complexType>

   198

            </xsd:element>

   199

          </xsd:sequence>

   200

        </xsd:complexType>

   201

      </xsd:element>

   202

      <xsd:complexType name="LocationDesc">

   203

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

   204

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

   205

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

   206

      </xsd:complexType>

   207

    </xsd:schema>

   208

"""

   209

   210

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD) 

   211

   212

class _EthercatCTN:

   213

   214

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

   215

    if HAS_MCL:

   216

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

   217

    EditorType = MasterEditor

   218

   219

    def __init__(self):

   220

        config_filepath = self.ConfigFileName()

   221

        config_is_saved = False

   222

        self.Config = None

   223

        if os.path.isfile(config_filepath):

   224

            config_xmlfile = open(config_filepath, 'r')

   225

            try:

   226

                self.Config, error = \

   227

                    EtherCATConfigParser.LoadXMLString(config_xmlfile.read())

   228

                if error is None:

   229

                    config_is_saved = True

   230

            except Exception, e:

   231

                error = e.message

   232

            config_xmlfile.close()

   233

   234

            if error is not None:

   235

                self.GetCTRoot().logger.write_error(

   236

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

   237

   238

        if self.Config is None:

   239

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

   240

   241

        process_filepath = self.ProcessVariablesFileName()

   242

        process_is_saved = False

   243

        self.ProcessVariables = None

   244

        if os.path.isfile(process_filepath):

   245

            process_xmlfile = open(process_filepath, 'r')

   246

            try:

   247

                self.ProcessVariables, error = \

   248

                    ProcessVariablesParser.LoadXMLString(process_xmlfile.read())

   249

                if error is None:

   250

                    process_is_saved = True

   251

            except Exception, e:

   252

                error = e.message

   253

            process_xmlfile.close()

   254

   255

            if error is not None:

   256

                self.GetCTRoot().logger.write_error(

   257

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

   258

   259

        if self.ProcessVariables is None:

   260

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

   261

   262

        if config_is_saved and process_is_saved:

   263

            self.CreateBuffer(True)

   264

        else:

   265

            self.CreateBuffer(False)

   266

            self.OnCTNSave()

   267

   268

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

   269

        self.CommonMethod = _CommonSlave(self)

   270

   271

    def GetIconName(self):

   272

        return "Ethercat"

   273

   274

    def GetContextualMenuItems(self):

   275

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

   276

   277

    def OnAddEthercatSlave(self, event):

   278

        app_frame = self.GetCTRoot().AppFrame

   279

        dialog = BrowseValuesLibraryDialog(app_frame, 

   280

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

   281

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

   282

            type_infos = dialog.GetValueInfos()

   283

            device, module_extra_params = self.GetModuleInfos(type_infos)

   284

            if device is not None:

   285

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

   286

                    ConfNodeType = "EthercatCIA402Slave"

   287

                else:

   288

                    ConfNodeType = "EthercatSlave"

   289

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

   290

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

   291

                self.CTNRequestSave()

   292

                new_child._OpenView()

   293

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   294

        dialog.Destroy()

   295

   296

    def ExtractHexDecValue(self, value):

   297

        return ExtractHexDecValue(value)

   298

   299

    def GetSizeOfType(self, type):

   300

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

   301

   302

    def ConfigFileName(self):

   303

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

   304

   305

    def ProcessVariablesFileName(self):

   306

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

   307

   308

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

   309

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

   310

            return False

   311

        type_infos = slave.getType()

   312

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

   313

            return False

   314

        device, module_extra_params = self.GetModuleInfos(type_infos)

   315

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

   316

            return False

   317

        return True

   318

   319

    def GetSlaveName(self, slave_pos):

   320

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   321

        if CTNChild is not None:

   322

            return CTNChild.CTNName()

   323

        return self.CTNName()

   324

   325

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

   326

        slaves = []

   327

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

   328

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

   329

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

   330

        slaves.sort()

   331

        return slaves

   332

   333

    def GetSlave(self, slave_pos):

   334

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

   335

            slave_info = slave.getInfo()

   336

            if slave_info.getPhysAddr() == slave_pos:

   337

                return slave

   338

        return None

   339

   340

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

   341

        commands = []

   342

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

   343

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

   344

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

   345

        commands.sort()

   346

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

   347

   348

    def AppendStartupCommand(self, command_infos):

   349

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

   350

        if slave is not None:

   351

            command_idx = slave.appendStartupCommand(command_infos)

   352

            self.BufferModel()

   353

            return command_idx

   354

        return None

   355

   356

    def SetStartupCommandInfos(self, command_infos):

   357

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

   358

        if slave is not None:

   359

            slave.setStartupCommand(command_infos)

   360

            self.BufferModel()

   361

   362

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

   363

        slave = self.GetSlave(slave_pos)

   364

        if slave is not None:

   365

            slave.removeStartupCommand(command_idx)

   366

            if buffer:

   367

                self.BufferModel()

   368

   369

    def SetProcessVariables(self, variables):

   370

        vars = []

   371

        for var in variables:

   372

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

   373

            variable.setName(var["Name"])

   374

            variable.setComment(var["Description"])

   375

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

   376

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

   377

                if variable.getReadFrom() is None:

   378

                    variable.addReadFrom()

   379

                read_from = variable.getReadFrom()

   380

                read_from.setPosition(position)

   381

                read_from.setIndex(index)

   382

                read_from.setSubIndex(subindex)

   383

            elif variable.getReadFrom() is not None:

   384

                variable.deleteReadFrom()

   385

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

   386

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

   387

                if variable.getWriteTo() is None:

   388

                    variable.addWriteTo()

   389

                write_to = variable.getWriteTo()

   390

                write_to.setPosition(position)

   391

                write_to.setIndex(index)

   392

                write_to.setSubIndex(subindex)

   393

            elif variable.getWriteTo() is not None:

   394

                variable.deleteWriteTo()

   395

            vars.append(variable)

   396

        self.ProcessVariables.setvariable(vars)

   397

        self.BufferModel()

   398

   399

    def GetProcessVariables(self):

   400

        variables = []

   401

        idx = 0

   402

        for variable in self.ProcessVariables.getvariable():

   403

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

   404

                   "Number": idx,

   405

                   "Description": variable.getComment()}

   406

            read_from = variable.getReadFrom()

   407

            if read_from is not None:

   408

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

   409

                                   read_from.getIndex(),

   410

                                   read_from.getSubIndex())

   411

            else:

   412

                var["ReadFrom"] = ""

   413

            write_to = variable.getWriteTo()

   414

            if write_to is not None:

   415

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

   416

                                   write_to.getIndex(),

   417

                                   write_to.getSubIndex())

   418

            else:

   419

                var["WriteTo"] = ""

   420

            variables.append(var)

   421

            idx += 1

   422

        return variables

   423

   424

    def _ScanNetwork(self):

   425

        app_frame = self.GetCTRoot().AppFrame

   426

   427

        execute = True

   428

        if len(self.Children) > 0:

   429

            dialog = wx.MessageDialog(app_frame, 

   430

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

   431

                _("Scan Network"), 

   432

                wx.YES_NO|wx.ICON_QUESTION)

   433

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

   434

            dialog.Destroy()

   435

   436

        if execute:

   437

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

   438

            if error != 0:

   439

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

   440

                dialog.ShowModal()

   441

                dialog.Destroy()

   442

            elif returnVal is not None:

   443

                for child in self.IECSortedChildren():

   444

                    self._doRemoveChild(child)

   445

   446

                for slave in returnVal:

   447

                    type_infos = {

   448

                        "vendor": slave["vendor_id"],

   449

                        "product_code": slave["product_code"],

   450

                        "revision_number":slave["revision_number"],

   451

                    }

   452

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   453

                    if device is not None:

   454

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

   455

                            CTNType = "EthercatCIA402Slave"

   456

                        else:

   457

                            CTNType = "EthercatSlave"

   458

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

   459

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

   460

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

   461

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

   462

   463

                if app_frame:

   464

                    app_frame.RefreshProjectTree()

   465

   466

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

   467

        """

   468

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

   469

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

   470

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

   471

        """

   472

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

   473

   474

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

   475

        if slave is None:

   476

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

   477

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

   478

            slave_infos = slave.getInfo()

   479

            slave_infos.setName("undefined")

   480

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

   481

            slave_infos.setAutoIncAddr(0)

   482

            self.BufferModel()

   483

            self.OnCTNSave()

   484

   485

        return newConfNodeOpj

   486

   487

    def _doRemoveChild(self, CTNInstance):

   488

        slave_pos = CTNInstance.GetSlavePos()

   489

        config = self.Config.getConfig()

   490

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

   491

            slave_infos = slave.getInfo()

   492

            if slave_infos.getPhysAddr() == slave_pos:

   493

                config.removeSlave(idx)

   494

                self.BufferModel()

   495

                self.OnCTNSave()

   496

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   497

   498

    def SetSlavePosition(self, slave_pos, new_pos):

   499

        slave = self.GetSlave(slave_pos)

   500

        if slave is not None:

   501

            slave_info = slave.getInfo()

   502

            slave_info.setPhysAddr(new_pos)

   503

            for variable in self.ProcessVariables.getvariable():

   504

                read_from = variable.getReadFrom()

   505

                if read_from is not None and read_from.getPosition() == slave_pos:

   506

                    read_from.setPosition(new_pos)

   507

                write_to = variable.getWriteTo()

   508

                if write_to is not None and write_to.getPosition() == slave_pos:

   509

                    write_to.setPosition(new_pos)

   510

            self.CreateBuffer(True)

   511

            self.CTNRequestSave()

   512

            if self._View is not None:

   513

                self._View.RefreshView()

   514

                self._View.RefreshBuffer()

   515

   516

    def GetSlaveAlias(self, slave_pos):

   517

        slave = self.GetSlave(slave_pos)

   518

        if slave is not None:

   519

            slave_info = slave.getInfo()

   520

            return slave_info.getAutoIncAddr()

   521

        return None

   522