1

import os

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

     9

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

    10

from ConfigTreeNode import ConfigTreeNode

    11

from dialogs import BrowseValuesLibraryDialog

    12

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    13

    14

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

    15

from EthercatCFileGenerator import _EthercatCFileGenerator

    16

from ConfigEditor import MasterEditor

    17

from POULibrary import POULibrary

    18

    19

try:

    20

    from EthercatCIA402Slave import _EthercatCIA402SlaveCTN

    21

    HAS_MCL = True

    22

except:

    23

    HAS_MCL = False

    24

    25

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

    26

#         Remote Exec Etherlab Commands

    27

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

    28

    29

SCAN_COMMAND = """

    30

import commands

    31

result = commands.getoutput("ethercat slaves")

    32

slaves = []

    33

for slave_line in result.splitlines():

    34

    chunks = slave_line.split()

    35

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

    36

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

    37

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

    38

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

    39

             "alias": int(alias),

    40

             "position": int(position),

    41

             "name": name}

    42

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

    43

    for details_line in details.splitlines():

    44

        details_line = details_line.strip()

    45

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

    46

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

    47

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

    48

            if details_line.startswith(header):

    49

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

    50

                break

    51

    slaves.append(slave)

    52

returnVal = slaves

    53

"""

    54

    55

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

    56

#      Etherlab Specific Blocks Library

    57

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

    58

    59

def GetLocalPath(filename):

    60

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

    61

    62

class EtherlabLibrary(POULibrary):

    63

    def GetLibraryPath(self):

    64

        return GetLocalPath("pous.xml")

    65

    66

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

    67

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

    68

        etherlab_ext_code = etherlab_ext_file.read()

    69

        etherlab_ext_file.close()

    70

    71

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

    72

        ethelabfile = open(Gen_etherlabfile_path,'w')

    73

        ethelabfile.write(etherlab_ext_code)

    74

        ethelabfile.close()

    75

    76

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

    77

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

    78

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

    79

    80

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

    81

#                 Ethercat MASTER

    82

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

    83

    84

EtherCATConfigClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATConfig.xsd")) 

    85

    86

def sort_commands(x, y):

    87

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

    88

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

    89

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

    90

    91

cls = EtherCATConfigClasses.get("Config_Slave", None)

    92

if cls:

    93

    94

    def getType(self):

    95

        slave_info = self.getInfo()

    96

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

    97

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

    98

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

    99

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

   100

    setattr(cls, "getType", getType)

   101

   102

    def setType(self, type_infos):

   103

        slave_info = self.getInfo()

   104

        slave_info.setName(type_infos["device_type"])

   105

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

   106

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

   107

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

   108

    setattr(cls, "setType", setType)

   109

   110

    def getInitCmds(self, create_default=False):

   111

        Mailbox = self.getMailbox()

   112

        if Mailbox is None:

   113

            if create_default:

   114

                self.addMailbox()

   115

                Mailbox = self.getMailbox()

   116

            else:

   117

                return None

   118

        CoE = Mailbox.getCoE()

   119

        if CoE is None:

   120

            if create_default:

   121

                Mailbox.addCoE()

   122

                CoE = Mailbox.getCoE()

   123

            else:

   124

                return None

   125

        InitCmds = CoE.getInitCmds()

   126

        if InitCmds is None and create_default:

   127

            CoE.addInitCmds()

   128

            InitCmds = CoE.getInitCmds()

   129

        return InitCmds

   130

    setattr(cls, "getInitCmds", getInitCmds)

   131

   132

    def getStartupCommands(self):

   133

        pos = self.getInfo().getPhysAddr()

   134

        InitCmds = self.getInitCmds()

   135

        if InitCmds is None:

   136

            return []

   137

        commands = []

   138

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

   139

            comment = InitCmd.getComment()

   140

            if comment is None:

   141

                comment = ""

   142

            commands.append({

   143

                "command_idx": idx,

   144

                "Position": pos,

   145

                "Index": InitCmd.getIndex(),

   146

                "Subindex": InitCmd.getSubIndex(),

   147

                "Value": InitCmd.getData(),

   148

                "Description": comment})

   149

        commands.sort(sort_commands)

   150

        return commands

   151

    setattr(cls, "getStartupCommands", getStartupCommands)

   152

   153

    def appendStartupCommand(self, command_infos):

   154

        InitCmds = self.getInitCmds(True)

   155

        command = EtherCATConfigClasses["InitCmds_InitCmd"]()

   156

        command.setIndex(command_infos["Index"])

   157

        command.setSubIndex(command_infos["Subindex"])

   158

        command.setData(command_infos["Value"])

   159

        command.setComment(command_infos["Description"])

   160

        InitCmds.appendInitCmd(command)

   161

        return len(InitCmds.getInitCmd()) - 1

   162

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   163

   164

    def setStartupCommand(self, command_infos):

   165

        InitCmds = self.getInitCmds()

   166

        if InitCmds is not None:

   167

            commands = InitCmds.getInitCmd()

   168

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

   169

                command = commands[command_infos["command_idx"]]

   170

                command.setIndex(command_infos["Index"])

   171

                command.setSubIndex(command_infos["Subindex"])

   172

                command.setData(command_infos["Value"])

   173

                command.setComment(command_infos["Description"])

   174

    setattr(cls, "setStartupCommand", setStartupCommand)

   175

   176

    def removeStartupCommand(self, command_idx):

   177

        InitCmds = self.getInitCmds()

   178

        if InitCmds is not None:

   179

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

   180

                InitCmds.removeInitCmd(command_idx)

   181

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   182

   183

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

   184

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

   185

      <xsd:element name="ProcessVariables">

   186

        <xsd:complexType>

   187

          <xsd:sequence>

   188

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

   189

              <xsd:complexType>

   190

                <xsd:sequence>

   191

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

   192

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

   193

                </xsd:sequence>

   194

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

   195

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

   196

              </xsd:complexType>

   197

            </xsd:element>

   198

          </xsd:sequence>

   199

        </xsd:complexType>

   200

      </xsd:element>

   201

      <xsd:complexType name="LocationDesc">

   202

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

   203

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

   204

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

   205

      </xsd:complexType>

   206

    </xsd:schema>

   207

"""

   208

   209

ProcessVariablesClasses = GenerateClassesFromXSDstring(ProcessVariablesXSD) 

   210

   211

class _EthercatCTN:

   212

   213

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

   214

    if HAS_MCL:

   215

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

   216

    EditorType = MasterEditor

   217

   218

    def __init__(self):

   219

        config_filepath = self.ConfigFileName()

   220

        config_is_saved = False

   221

        self.Config = EtherCATConfigClasses["EtherCATConfig"]()

   222

        if os.path.isfile(config_filepath):

   223

            config_xmlfile = open(config_filepath, 'r')

   224

            config_tree = minidom.parse(config_xmlfile)

   225

            config_xmlfile.close()

   226

   227

            for child in config_tree.childNodes:

   228

                if child.nodeType == config_tree.ELEMENT_NODE and child.nodeName == "EtherCATConfig":

   229

                    self.Config.loadXMLTree(child)

   230

                    config_is_saved = True

   231

   232

        process_filepath = self.ProcessVariablesFileName()

   233

        process_is_saved = False

   234

        self.ProcessVariables = ProcessVariablesClasses["ProcessVariables"]()

   235

        if os.path.isfile(process_filepath):

   236

            process_xmlfile = open(process_filepath, 'r')

   237

            process_tree = minidom.parse(process_xmlfile)

   238

            process_xmlfile.close()

   239

   240

            for child in process_tree.childNodes:

   241

                if child.nodeType == process_tree.ELEMENT_NODE and child.nodeName == "ProcessVariables":

   242

                    self.ProcessVariables.loadXMLTree(child)

   243

                    process_is_saved = True

   244

   245

        if config_is_saved and process_is_saved:

   246

            self.CreateBuffer(True)

   247

        else:

   248

            self.CreateBuffer(False)

   249

            self.OnCTNSave()

   250

   251

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

   252

        self.CommonMethod = _CommonSlave(self)

   253

   254

    def GetIconName(self):

   255

        return "Ethercat"

   256

   257

    def GetContextualMenuItems(self):

   258

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

   259

   260

    def OnAddEthercatSlave(self, event):

   261

        app_frame = self.GetCTRoot().AppFrame

   262

        dialog = BrowseValuesLibraryDialog(app_frame, 

   263

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

   264

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

   265

            type_infos = dialog.GetValueInfos()

   266

            device, module_extra_params = self.GetModuleInfos(type_infos)

   267

            if device is not None:

   268

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

   269

                    ConfNodeType = "EthercatCIA402Slave"

   270

                else:

   271

                    ConfNodeType = "EthercatSlave"

   272

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

   273

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

   274

                self.CTNRequestSave()

   275

                new_child._OpenView()

   276

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   277

        dialog.Destroy()

   278

   279

    def ExtractHexDecValue(self, value):

   280

        return ExtractHexDecValue(value)

   281

   282

    def GetSizeOfType(self, type):

   283

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

   284

   285

    def ConfigFileName(self):

   286

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

   287

   288

    def ProcessVariablesFileName(self):

   289

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

   290

   291

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

   292

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

   293

            return False

   294

        type_infos = slave.getType()

   295

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

   296

            return False

   297

        device, module_extra_params = self.GetModuleInfos(type_infos)

   298

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

   299

            return False

   300

        return True

   301

   302

    def GetSlaveName(self, slave_pos):

   303

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   304

        if CTNChild is not None:

   305

            return CTNChild.CTNName()

   306

        return self.CTNName()

   307

   308

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

   309

        slaves = []

   310

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

   311

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

   312

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

   313

        slaves.sort()

   314

        return slaves

   315

   316

    def GetSlave(self, slave_pos):

   317

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

   318

            slave_info = slave.getInfo()

   319

            if slave_info.getPhysAddr() == slave_pos:

   320

                return slave

   321

        return None

   322

   323

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

   324

        commands = []

   325

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

   326

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

   327

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

   328

        commands.sort()

   329

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

   330

   331

    def AppendStartupCommand(self, command_infos):

   332

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

   333

        if slave is not None:

   334

            command_idx = slave.appendStartupCommand(command_infos)

   335

            self.BufferModel()

   336

            return command_idx

   337

        return None

   338

   339

    def SetStartupCommandInfos(self, command_infos):

   340

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

   341

        if slave is not None:

   342

            slave.setStartupCommand(command_infos)

   343

            self.BufferModel()

   344

   345

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

   346

        slave = self.GetSlave(slave_pos)

   347

        if slave is not None:

   348

            slave.removeStartupCommand(command_idx)

   349

            if buffer:

   350

                self.BufferModel()

   351

   352

    def SetProcessVariables(self, variables):

   353

        vars = []

   354

        for var in variables:

   355

            variable = ProcessVariablesClasses["ProcessVariables_variable"]()

   356

            variable.setName(var["Name"])

   357

            variable.setComment(var["Description"])

   358

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

   359

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

   360

                if variable.getReadFrom() is None:

   361

                    variable.addReadFrom()

   362

                read_from = variable.getReadFrom()

   363

                read_from.setPosition(position)

   364

                read_from.setIndex(index)

   365

                read_from.setSubIndex(subindex)

   366

            elif variable.getReadFrom() is not None:

   367

                variable.deleteReadFrom()

   368

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

   369

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

   370

                if variable.getWriteTo() is None:

   371

                    variable.addWriteTo()

   372

                write_to = variable.getWriteTo()

   373

                write_to.setPosition(position)

   374

                write_to.setIndex(index)

   375

                write_to.setSubIndex(subindex)

   376

            elif variable.getWriteTo() is not None:

   377

                variable.deleteWriteTo()

   378

            vars.append(variable)

   379

        self.ProcessVariables.setvariable(vars)

   380

        self.BufferModel()

   381

   382

    def GetProcessVariables(self):

   383

        variables = []

   384

        idx = 0

   385

        for variable in self.ProcessVariables.getvariable():

   386

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

   387

                   "Number": idx,

   388

                   "Description": variable.getComment()}

   389

            read_from = variable.getReadFrom()

   390

            if read_from is not None:

   391

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

   392

                                   read_from.getIndex(),

   393

                                   read_from.getSubIndex())

   394

            else:

   395

                var["ReadFrom"] = ""

   396

            write_to = variable.getWriteTo()

   397

            if write_to is not None:

   398

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

   399

                                   write_to.getIndex(),

   400

                                   write_to.getSubIndex())

   401

            else:

   402

                var["WriteTo"] = ""

   403

            variables.append(var)

   404

            idx += 1

   405

        return variables

   406

   407

    def _ScanNetwork(self):

   408

        app_frame = self.GetCTRoot().AppFrame

   409

   410

        execute = True

   411

        if len(self.Children) > 0:

   412

            dialog = wx.MessageDialog(app_frame, 

   413

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

   414

                _("Scan Network"), 

   415

                wx.YES_NO|wx.ICON_QUESTION)

   416

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

   417

            dialog.Destroy()

   418

   419

        if execute:

   420

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

   421

            if error != 0:

   422

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

   423

                dialog.ShowModal()

   424

                dialog.Destroy()

   425

            elif returnVal is not None:

   426

                for child in self.IECSortedChildren():

   427

                    self._doRemoveChild(child)

   428

   429

                for slave in returnVal:

   430

                    type_infos = {

   431

                        "vendor": slave["vendor_id"],

   432

                        "product_code": slave["product_code"],

   433

                        "revision_number":slave["revision_number"],

   434

                    }

   435

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   436

                    if device is not None:

   437

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

   438

                            CTNType = "EthercatCIA402Slave"

   439

                        else:

   440

                            CTNType = "EthercatSlave"

   441

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

   442

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

   443

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

   444

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

   445

   446

                if app_frame:

   447

                    app_frame.RefreshProjectTree()

   448

   449

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

   450

        """

   451

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

   452

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

   453

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

   454

        """

   455

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

   456

   457

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

   458

        if slave is None:

   459

            slave = EtherCATConfigClasses["Config_Slave"]()

   460

            slave_infos = slave.getInfo()

   461

            slave_infos.setName("undefined")

   462

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

   463

            slave_infos.setAutoIncAddr(0)

   464

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

   465

            self.BufferModel()

   466

            self.OnCTNSave()

   467

   468

        return newConfNodeOpj

   469

   470

    def _doRemoveChild(self, CTNInstance):

   471

        slave_pos = CTNInstance.GetSlavePos()

   472

        config = self.Config.getConfig()

   473

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

   474

            slave_infos = slave.getInfo()

   475

            if slave_infos.getPhysAddr() == slave_pos:

   476

                config.removeSlave(idx)

   477

                self.BufferModel()

   478

                self.OnCTNSave()

   479

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   480

   481

    def SetSlavePosition(self, slave_pos, new_pos):

   482

        slave = self.GetSlave(slave_pos)

   483

        if slave is not None:

   484

            slave_info = slave.getInfo()

   485

            slave_info.setPhysAddr(new_pos)

   486

            for variable in self.ProcessVariables.getvariable():

   487

                read_from = variable.getReadFrom()

   488

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

   489

                    read_from.setPosition(new_pos)

   490

                write_to = variable.getWriteTo()

   491

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

   492

                    write_to.setPosition(new_pos)

   493

            self.CreateBuffer(True)

   494

            self.CTNRequestSave()

   495

            if self._View is not None:

   496

                self._View.RefreshView()

   497

                self._View.RefreshBuffer()

   498

   499

    def GetSlaveAlias(self, slave_pos):

   500

        slave = self.GetSlave(slave_pos)

   501

        if slave is not None:

   502

            slave_info = slave.getInfo()

   503

            return slave_info.getAutoIncAddr()

   504

        return None

   505

   506

    def SetSlaveAlias(self, slave_pos, alias):

   507

        slave = self.GetSlave(slave_pos)

   508

        if slave is not None:

   509

            slave_info = slave.getInfo()

   510

            slave_info.setAutoIncAddr(alias)

   511

            self.BufferModel()

   512

   513

    def GetSlaveType(self, slave_pos):

   514

        slave = self.GetSlave(slave_pos)

   515

        if slave is not None:

   516

            return slave.getType()

   517

        return None

   518

   519

    def SetSlaveType(self, slave_pos, type_infos):

   520

        slave = self.GetSlave(slave_pos)

   521

        if slave is not None:

   522

            slave.setType(type_infos)

   523

            self.BufferModel()

   524

   525

    def GetSlaveInfos(self, slave_pos):

   526

        slave = self.GetSlave(slave_pos)

   527