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

    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

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

    77

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

    78

    79

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

    80

#                 Ethercat MASTER

    81

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

    82

    83

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

    84

    85

def sort_commands(x, y):

    86

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

    87

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

    88

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

    89

    90

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

    91

if cls:

    92

    93

    def getType(self):

    94

        slave_info = self.getInfo()

    95

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

    96

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

    97

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

    98

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

    99

    setattr(cls, "getType", getType)

   100

   101

    def setType(self, type_infos):

   102

        slave_info = self.getInfo()

   103

        slave_info.setName(type_infos["device_type"])

   104

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

   105

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

   106

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

   107

    setattr(cls, "setType", setType)

   108

   109

    def getInitCmds(self, create_default=False):

   110

        Mailbox = self.getMailbox()

   111

        if Mailbox is None:

   112

            if create_default:

   113

                self.addMailbox()

   114

                Mailbox = self.getMailbox()

   115

            else:

   116

                return None

   117

        CoE = Mailbox.getCoE()

   118

        if CoE is None:

   119

            if create_default:

   120

                Mailbox.addCoE()

   121

                CoE = Mailbox.getCoE()

   122

            else:

   123

                return None

   124

        InitCmds = CoE.getInitCmds()

   125

        if InitCmds is None and create_default:

   126

            CoE.addInitCmds()

   127

            InitCmds = CoE.getInitCmds()

   128

        return InitCmds

   129

    setattr(cls, "getInitCmds", getInitCmds)

   130

   131

    def getStartupCommands(self):

   132

        pos = self.getInfo().getPhysAddr()

   133

        InitCmds = self.getInitCmds()

   134

        if InitCmds is None:

   135

            return []

   136

        commands = []

   137

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

   138

            comment = InitCmd.getComment()

   139

            if comment is None:

   140

                comment = ""

   141

            commands.append({

   142

                "command_idx": idx,

   143

                "Position": pos,

   144

                "Index": InitCmd.getIndex(),

   145

                "Subindex": InitCmd.getSubIndex(),

   146

                "Value": InitCmd.getData(),

   147

                "Description": comment})

   148

        commands.sort(sort_commands)

   149

        return commands

   150

    setattr(cls, "getStartupCommands", getStartupCommands)

   151

   152

    def appendStartupCommand(self, command_infos):

   153

        InitCmds = self.getInitCmds(True)

   154

        command = EtherCATConfigClasses["InitCmds_InitCmd"]()

   155

        command.setIndex(command_infos["Index"])

   156

        command.setSubIndex(command_infos["Subindex"])

   157

        command.setData(command_infos["Value"])

   158

        command.setComment(command_infos["Description"])

   159

        InitCmds.appendInitCmd(command)

   160

        return len(InitCmds.getInitCmd()) - 1

   161

    setattr(cls, "appendStartupCommand", appendStartupCommand)

   162

   163

    def setStartupCommand(self, command_infos):

   164

        InitCmds = self.getInitCmds()

   165

        if InitCmds is not None:

   166

            commands = InitCmds.getInitCmd()

   167

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

   168

                command = commands[command_infos["command_idx"]]

   169

                command.setIndex(command_infos["Index"])

   170

                command.setSubIndex(command_infos["Subindex"])

   171

                command.setData(command_infos["Value"])

   172

                command.setComment(command_infos["Description"])

   173

    setattr(cls, "setStartupCommand", setStartupCommand)

   174

   175

    def removeStartupCommand(self, command_idx):

   176

        InitCmds = self.getInitCmds()

   177

        if InitCmds is not None:

   178

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

   179

                InitCmds.removeInitCmd(command_idx)

   180

    setattr(cls, "removeStartupCommand", removeStartupCommand)

   181

   182

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

   183

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

   184

      <xsd:element name="ProcessVariables">

   185

        <xsd:complexType>

   186

          <xsd:sequence>

   187

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

   188

              <xsd:complexType>

   189

                <xsd:sequence>

   190

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

   191

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

   192

                </xsd:sequence>

   193

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

   194

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

   195

              </xsd:complexType>

   196

            </xsd:element>

   197

          </xsd:sequence>

   198

        </xsd:complexType>

   199

      </xsd:element>

   200

      <xsd:complexType name="LocationDesc">

   201

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

   202

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

   203

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

   204

      </xsd:complexType>

   205

    </xsd:schema>

   206

"""

   207

   208

ProcessVariablesClasses = GenerateClassesFromXSDstring(ProcessVariablesXSD) 

   209

   210

class _EthercatCTN:

   211

   212

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

   213

    if HAS_MCL:

   214

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

   215

    EditorType = MasterEditor

   216

   217

    def __init__(self):

   218

        config_filepath = self.ConfigFileName()

   219

        config_is_saved = False

   220

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

   221

        if os.path.isfile(config_filepath):

   222

            config_xmlfile = open(config_filepath, 'r')

   223

            config_tree = minidom.parse(config_xmlfile)

   224

            config_xmlfile.close()

   225

   226

            for child in config_tree.childNodes:

   227

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

   228

                    self.Config.loadXMLTree(child)

   229

                    config_is_saved = True

   230

   231

        process_filepath = self.ProcessVariablesFileName()

   232

        process_is_saved = False

   233

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

   234

        if os.path.isfile(process_filepath):

   235

            process_xmlfile = open(process_filepath, 'r')

   236

            process_tree = minidom.parse(process_xmlfile)

   237

            process_xmlfile.close()

   238

   239

            for child in process_tree.childNodes:

   240

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

   241

                    self.ProcessVariables.loadXMLTree(child)

   242

                    process_is_saved = True

   243

   244

        if config_is_saved and process_is_saved:

   245

            self.CreateBuffer(True)

   246

        else:

   247

            self.CreateBuffer(False)

   248

            self.OnCTNSave()

   249

   250

    def GetContextualMenuItems(self):

   251

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

   252

   253

    def OnAddEthercatSlave(self, event):

   254

        app_frame = self.GetCTRoot().AppFrame

   255

        dialog = BrowseValuesLibraryDialog(app_frame, 

   256

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

   257

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

   258

            type_infos = dialog.GetValueInfos()

   259

            device, alignment = self.GetModuleInfos(type_infos)

   260

            if device is not None:

   261

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

   262

                    ConfNodeType = "EthercatCIA402Slave"

   263

                else:

   264

                    ConfNodeType = "EthercatSlave"

   265

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

   266

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

   267

                self.CTNRequestSave()

   268

                new_child._OpenView()

   269

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   270

        dialog.Destroy()

   271

   272

    def ExtractHexDecValue(self, value):

   273

        return ExtractHexDecValue(value)

   274

   275

    def GetSizeOfType(self, type):

   276

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

   277

   278

    def ConfigFileName(self):

   279

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

   280

   281

    def ProcessVariablesFileName(self):

   282

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

   283

   284

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

   285

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

   286

            return False

   287

        type_infos = slave.getType()

   288

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

   289

            return False

   290

        device, alignment = self.GetModuleInfos(type_infos)

   291

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

   292

            return False

   293

        return True

   294

   295

    def GetSlaveName(self, slave_pos):

   296

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   297

        if CTNChild is not None:

   298

            return CTNChild.CTNName()

   299

        return self.CTNName()

   300

   301

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

   302

        slaves = []

   303

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

   304

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

   305

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

   306

        slaves.sort()

   307

        return slaves

   308

   309

    def GetSlave(self, slave_pos):

   310

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

   311

            slave_info = slave.getInfo()

   312

            if slave_info.getPhysAddr() == slave_pos:

   313

                return slave

   314

        return None

   315

   316

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

   317

        commands = []

   318

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

   319

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

   320

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

   321

        commands.sort()

   322

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

   323

   324

    def AppendStartupCommand(self, command_infos):

   325

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

   326

        if slave is not None:

   327

            command_idx = slave.appendStartupCommand(command_infos)

   328

            self.BufferModel()

   329

            return command_idx

   330

        return None

   331

   332

    def SetStartupCommandInfos(self, command_infos):

   333

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

   334

        if slave is not None:

   335

            slave.setStartupCommand(command_infos)

   336

            self.BufferModel()

   337

   338

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

   339

        slave = self.GetSlave(slave_pos)

   340

        if slave is not None:

   341

            slave.removeStartupCommand(command_idx)

   342

            if buffer:

   343

                self.BufferModel()

   344

   345

    def SetProcessVariables(self, variables):

   346

        vars = []

   347

        for var in variables:

   348

            variable = ProcessVariablesClasses["ProcessVariables_variable"]()

   349

            variable.setName(var["Name"])

   350

            variable.setComment(var["Description"])

   351

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

   352

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

   353

                if variable.getReadFrom() is None:

   354

                    variable.addReadFrom()

   355

                read_from = variable.getReadFrom()

   356

                read_from.setPosition(position)

   357

                read_from.setIndex(index)

   358

                read_from.setSubIndex(subindex)

   359

            elif variable.getReadFrom() is not None:

   360

                variable.deleteReadFrom()

   361

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

   362

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

   363

                if variable.getWriteTo() is None:

   364

                    variable.addWriteTo()

   365

                write_to = variable.getWriteTo()

   366

                write_to.setPosition(position)

   367

                write_to.setIndex(index)

   368

                write_to.setSubIndex(subindex)

   369

            elif variable.getWriteTo() is not None:

   370

                variable.deleteWriteTo()

   371

            vars.append(variable)

   372

        self.ProcessVariables.setvariable(vars)

   373

        self.BufferModel()

   374

   375

    def GetProcessVariables(self):

   376

        variables = []

   377

        idx = 0

   378

        for variable in self.ProcessVariables.getvariable():

   379

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

   380

                   "Number": idx,

   381

                   "Description": variable.getComment()}

   382

            read_from = variable.getReadFrom()

   383

            if read_from is not None:

   384

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

   385

                                   read_from.getIndex(),

   386

                                   read_from.getSubIndex())

   387

            else:

   388

                var["ReadFrom"] = ""

   389

            write_to = variable.getWriteTo()

   390

            if write_to is not None:

   391

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

   392

                                   write_to.getIndex(),

   393

                                   write_to.getSubIndex())

   394

            else:

   395

                var["WriteTo"] = ""

   396

            variables.append(var)

   397

            idx += 1

   398

        return variables

   399

   400

    def _ScanNetwork(self):

   401

        app_frame = self.GetCTRoot().AppFrame

   402

   403

        execute = True

   404

        if len(self.Children) > 0:

   405

            dialog = wx.MessageDialog(app_frame, 

   406

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

   407

                _("Scan Network"), 

   408

                wx.YES_NO|wx.ICON_QUESTION)

   409

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

   410

            dialog.Destroy()

   411

   412

        if execute:

   413

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

   414

            if error != 0:

   415

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

   416

                dialog.ShowModal()

   417

                dialog.Destroy()

   418

            elif returnVal is not None:

   419

                for child in self.IECSortedChildren():

   420

                    self._doRemoveChild(child)

   421

   422

                for slave in returnVal:

   423

                    type_infos = {

   424

                        "vendor": slave["vendor_id"],

   425

                        "product_code": slave["product_code"],

   426

                        "revision_number":slave["revision_number"],

   427

                    }

   428

                    device, alignment = self.GetModuleInfos(type_infos)

   429

                    if device is not None:

   430

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

   431

                            CTNType = "EthercatCIA402Slave"

   432

                        else:

   433

                            CTNType = "EthercatSlave"

   434

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

   435

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

   436

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

   437

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

   438

   439

                if app_frame:

   440

                    app_frame.RefreshProjectTree()

   441

   442

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

   443

        """

   444

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

   445

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

   446

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

   447

        """

   448

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

   449

   450

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

   451

        if slave is None:

   452

            slave = EtherCATConfigClasses["Config_Slave"]()

   453

            slave_infos = slave.getInfo()

   454

            slave_infos.setName("undefined")

   455

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

   456

            slave_infos.setAutoIncAddr(0)

   457

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

   458

            self.BufferModel()

   459

            self.OnCTNSave()

   460

   461

        return newConfNodeOpj

   462

   463

    def _doRemoveChild(self, CTNInstance):

   464

        slave_pos = CTNInstance.GetSlavePos()

   465

        config = self.Config.getConfig()

   466

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

   467

            slave_infos = slave.getInfo()

   468

            if slave_infos.getPhysAddr() == slave_pos:

   469

                config.removeSlave(idx)

   470

                self.BufferModel()

   471

                self.OnCTNSave()

   472

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   473

   474

    def SetSlavePosition(self, slave_pos, new_pos):

   475

        slave = self.GetSlave(slave_pos)

   476

        if slave is not None:

   477

            slave_info = slave.getInfo()

   478

            slave_info.setPhysAddr(new_pos)

   479

            for variable in self.ProcessVariables.getvariable():

   480

                read_from = variable.getReadFrom()

   481

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

   482

                    read_from.setPosition(new_pos)

   483

                write_to = variable.getWriteTo()

   484

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

   485

                    write_to.setPosition(new_pos)

   486

            self.CreateBuffer(True)

   487

            self.OnCTNSave()

   488

            if self._View is not None:

   489

                self._View.RefreshView()

   490

                self._View.RefreshBuffer()

   491

   492

    def GetSlaveAlias(self, slave_pos):

   493

        slave = self.GetSlave(slave_pos)

   494

        if slave is not None:

   495

            slave_info = slave.getInfo()

   496

            return slave_info.getAutoIncAddr()

   497

        return None

   498

   499

    def SetSlaveAlias(self, slave_pos, alias):

   500

        slave = self.GetSlave(slave_pos)

   501

        if slave is not None:

   502

            slave_info = slave.getInfo()

   503

            slave_info.setAutoIncAddr(alias)

   504

            self.BufferModel()

   505

   506

    def GetSlaveType(self, slave_pos):

   507

        slave = self.GetSlave(slave_pos)

   508

        if slave is not None:

   509

            return slave.getType()

   510

        return None

   511

   512

    def SetSlaveType(self, slave_pos, type_infos):

   513

        slave = self.GetSlave(slave_pos)

   514

        if slave is not None:

   515

            slave.setType(type_infos)

   516

            self.BufferModel()

   517

   518

    def GetSlaveInfos(self, slave_pos):

   519

        slave = self.GetSlave(slave_pos)

   520

        if slave is not None:

   521

            type_infos = slave.getType()

   522

            device, alignment = self.GetModuleInfos(type_infos)

   523

            if device is not None:

   524

                infos = type_infos.copy()

   525

                infos.update({"physics": device.getPhysics(),

   526

                              "sync_managers": device.GetSyncManagers(),

   527

                              "entries": self.GetSlaveVariables(device)})

   528

                return infos