1

import os

     2

import cPickle

     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

    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

    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)

   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

   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

        if os.path.isfile(config_filepath):

   223

            config_xmlfile = open(config_filepath, 'r')

   227

            config_xmlfile.close()

   231

   232

        process_filepath = self.ProcessVariablesFileName()

   233

        process_is_saved = False

   234

        if os.path.isfile(process_filepath):

   235

            process_xmlfile = open(process_filepath, 'r')

   239

            process_xmlfile.close()

   240

   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

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

   251

        self.CommonMethod = _CommonSlave(self)

   252

   253

    def GetIconName(self):

   254

        return "Ethercat"

   255

   256

    def GetContextualMenuItems(self):

   257

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

   258

   259

    def OnAddEthercatSlave(self, event):

   260

        app_frame = self.GetCTRoot().AppFrame

   261

        dialog = BrowseValuesLibraryDialog(app_frame, 

   262

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

   263

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

   264

            type_infos = dialog.GetValueInfos()

   265

            device, module_extra_params = self.GetModuleInfos(type_infos)

   266

            if device is not None:

   267

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

   268

                    ConfNodeType = "EthercatCIA402Slave"

   269

                else:

   270

                    ConfNodeType = "EthercatSlave"

   271

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

   272

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

   273

                self.CTNRequestSave()

   274

                new_child._OpenView()

   275

                app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   276

        dialog.Destroy()

   277

   278

    def ExtractHexDecValue(self, value):

   279

        return ExtractHexDecValue(value)

   280

   281

    def GetSizeOfType(self, type):

   282

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

   283

   284

    def ConfigFileName(self):

   285

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

   286

   287

    def ProcessVariablesFileName(self):

   288

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

   289

   290

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

   291

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

   292

            return False

   293

        type_infos = slave.getType()

   294

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

   295

            return False

   296

        device, module_extra_params = self.GetModuleInfos(type_infos)

   297

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

   298

            return False

   299

        return True

   300

   301

    def GetSlaveName(self, slave_pos):

   302

        CTNChild = self.GetChildByIECLocation((slave_pos,))

   303

        if CTNChild is not None:

   304

            return CTNChild.CTNName()

   305

        return self.CTNName()

   306

   307

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

   308

        slaves = []

   309

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

   310

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

   311

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

   312

        slaves.sort()

   313

        return slaves

   314

   315

    def GetSlave(self, slave_pos):

   316

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

   317

            slave_info = slave.getInfo()

   318

            if slave_info.getPhysAddr() == slave_pos:

   319

                return slave

   320

        return None

   321

   322

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

   323

        commands = []

   324

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

   325

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

   326

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

   327

        commands.sort()

   328

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

   329

   330

    def AppendStartupCommand(self, command_infos):

   331

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

   332

        if slave is not None:

   333

            command_idx = slave.appendStartupCommand(command_infos)

   334

            self.BufferModel()

   335

            return command_idx

   336

        return None

   337

   338

    def SetStartupCommandInfos(self, command_infos):

   339

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

   340

        if slave is not None:

   341

            slave.setStartupCommand(command_infos)

   342

            self.BufferModel()

   343

   344

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

   345

        slave = self.GetSlave(slave_pos)

   346

        if slave is not None:

   347

            slave.removeStartupCommand(command_idx)

   348

            if buffer:

   349

                self.BufferModel()

   350

   351

    def SetProcessVariables(self, variables):

   352

        vars = []

   353

        for var in variables:

   355

            variable.setName(var["Name"])

   356

            variable.setComment(var["Description"])

   357

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

   358

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

   359

                if variable.getReadFrom() is None:

   360

                    variable.addReadFrom()

   361

                read_from = variable.getReadFrom()

   362

                read_from.setPosition(position)

   363

                read_from.setIndex(index)

   364

                read_from.setSubIndex(subindex)

   365

            elif variable.getReadFrom() is not None:

   366

                variable.deleteReadFrom()

   367

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

   368

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

   369

                if variable.getWriteTo() is None:

   370

                    variable.addWriteTo()

   371

                write_to = variable.getWriteTo()

   372

                write_to.setPosition(position)

   373

                write_to.setIndex(index)

   374

                write_to.setSubIndex(subindex)

   375

            elif variable.getWriteTo() is not None:

   376

                variable.deleteWriteTo()

   377

            vars.append(variable)

   378

        self.ProcessVariables.setvariable(vars)

   379

        self.BufferModel()

   380

   381

    def GetProcessVariables(self):

   382

        variables = []

   383

        idx = 0

   384

        for variable in self.ProcessVariables.getvariable():

   385

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

   386

                   "Number": idx,

   387

                   "Description": variable.getComment()}

   388

            read_from = variable.getReadFrom()

   389

            if read_from is not None:

   390

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

   391

                                   read_from.getIndex(),

   392

                                   read_from.getSubIndex())

   393

            else:

   394

                var["ReadFrom"] = ""

   395

            write_to = variable.getWriteTo()

   396

            if write_to is not None:

   397

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

   398

                                   write_to.getIndex(),

   399

                                   write_to.getSubIndex())

   400

            else:

   401

                var["WriteTo"] = ""

   402

            variables.append(var)

   403

            idx += 1

   404

        return variables

   405

   406

    def _ScanNetwork(self):

   407

        app_frame = self.GetCTRoot().AppFrame

   408

   409

        execute = True

   410

        if len(self.Children) > 0:

   411

            dialog = wx.MessageDialog(app_frame, 

   412

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

   413

                _("Scan Network"), 

   414

                wx.YES_NO|wx.ICON_QUESTION)

   415

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

   416

            dialog.Destroy()

   417

   418

        if execute:

   419

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

   420

            if error != 0:

   421

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

   422

                dialog.ShowModal()

   423

                dialog.Destroy()

   424

            elif returnVal is not None:

   425

                for child in self.IECSortedChildren():

   426

                    self._doRemoveChild(child)

   427

   428

                for slave in returnVal:

   429

                    type_infos = {

   430

                        "vendor": slave["vendor_id"],

   431

                        "product_code": slave["product_code"],

   432

                        "revision_number":slave["revision_number"],

   433

                    }

   434

                    device, module_extra_params = self.GetModuleInfos(type_infos)

   435

                    if device is not None:

   436

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

   437

                            CTNType = "EthercatCIA402Slave"

   438

                        else:

   439

                            CTNType = "EthercatSlave"

   440

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

   441

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

   442

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

   443

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

   444

   445

                if app_frame:

   446

                    app_frame.RefreshProjectTree()

   447

   448

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

   449

        """

   450

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

   451

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

   452

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

   453

        """

   454

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

   455

   456

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

   457

        if slave is None:

   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.BufferModel()

   465

            self.OnCTNSave()

   466

   467

        return newConfNodeOpj

   468

   469

    def _doRemoveChild(self, CTNInstance):

   470

        slave_pos = CTNInstance.GetSlavePos()

   471

        config = self.Config.getConfig()

   472

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

   473

            slave_infos = slave.getInfo()

   474

            if slave_infos.getPhysAddr() == slave_pos:

   475

                config.removeSlave(idx)

   476

                self.BufferModel()

   477

                self.OnCTNSave()

   478

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   479

   480

    def SetSlavePosition(self, slave_pos, new_pos):

   481

        slave = self.GetSlave(slave_pos)

   482

        if slave is not None:

   483

            slave_info = slave.getInfo()

   484

            slave_info.setPhysAddr(new_pos)

   485

            for variable in self.ProcessVariables.getvariable():

   486

                read_from = variable.getReadFrom()

   487

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

   488

                    read_from.setPosition(new_pos)

   489

                write_to = variable.getWriteTo()

   490

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

   491

                    write_to.setPosition(new_pos)

   492

            self.CreateBuffer(True)

   493

            self.CTNRequestSave()

   494

            if self._View is not None:

   495

                self._View.RefreshView()

   496

                self._View.RefreshBuffer()

   497

   498

    def GetSlaveAlias(self, slave_pos):

   499

        slave = self.GetSlave(slave_pos)

   500

        if slave is not None:

   501

            slave_info = slave.getInfo()

   502

            return slave_info.getAutoIncAddr()

   503

        return None

   504

   505

    def SetSlaveAlias(self, slave_pos, alias):

   506

        slave = self.GetSlave(slave_pos)

   507

        if slave is not None:

   508

            slave_info = slave.getInfo()

   509

            slave_info.setAutoIncAddr(alias)

   510

            self.BufferModel()

   511

   512

    def GetSlaveType(self, slave_pos):

   513

        slave = self.GetSlave(slave_pos)

   514

        if slave is not None:

   515

            return slave.getType()

   516

        return None

   517

   518

    def SetSlaveType(self, slave_pos, type_infos):

   519

        slave = self.GetSlave(slave_pos)

   520

        if slave is not None:

   521

            slave.setType(type_infos)

   522

            self.BufferModel()

   523

   524