1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from ConfigTreeNode import ConfigTreeNode

     9

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

    10

from ConfigEditor import NodeEditor, CIA402NodeEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    11

    12

try:

    13

    from MotionLibrary import Headers, AxisXSD

    14

    HAS_MCL = True

    15

except:

    16

    HAS_MCL = False

    17

    18

TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",

    19

    "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", 

    20

    "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L"}

    21

    22

DATATYPECONVERSION = {"BOOL" : "BIT", "SINT" : "S8", "INT" : "S16", "DINT" : "S32", "LINT" : "S64",

    23

    "USINT" : "U8", "UINT" : "U16", "UDINT" : "U32", "ULINT" : "U64", 

    24

    "BYTE" : "U8", "WORD" : "U16", "DWORD" : "U32", "LWORD" : "U64"}

    25

    26

VARCLASSCONVERSION = {"T": LOCATION_VAR_INPUT, "R": LOCATION_VAR_OUTPUT, "RT": LOCATION_VAR_MEMORY}

    27

    28

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

    29

#         Remote Exec Etherlab Commands

    30

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

    31

    32

SCAN_COMMAND = """

    33

import commands

    34

result = commands.getoutput("ethercat slaves")

    35

slaves = []

    36

for slave_line in result.splitlines():

    37

    chunks = slave_line.split()

    38

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

    39

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

    40

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

    41

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

    42

             "alias": int(alias),

    43

             "position": int(position),

    44

             "name": name}

    45

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

    46

    for details_line in details.splitlines():

    47

        details_line = details_line.strip()

    48

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

    49

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

    50

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

    51

            if details_line.startswith(header):

    52

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

    53

                break

    54

    slaves.append(slave)

    55

returnVal = slaves

    56

"""

    57

    58

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

    59

#                    Ethercat Node

    60

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

    61

    62

class _EthercatSlaveCTN:

    63

    64

    NODE_PROFILE = None

    65

    EditorType = NodeEditor

    66

    67

    def GetIconName(self):

    68

        return "Slave"

    69

    70

    def ExtractHexDecValue(self, value):

    71

        return ExtractHexDecValue(value)

    72

    73

    def GetSizeOfType(self, type):

    74

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

    75

    76

    def GetSlavePos(self):

    77

        return self.BaseParams.getIEC_Channel()

    78

    79

    def GetParamsAttributes(self, path = None):

    80

        if path:

    81

            parts = path.split(".", 1)

    82

            if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

    83

                return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

    84

            elif self.CTNParams and parts[0] == self.CTNParams[0]:

    85

                return self.CTNParams[1].getElementInfos(parts[0], parts[1])

    86

        else:

    87

            params = []

    88

            if self.CTNParams:

    89

                params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

    90

            else:

    91

                params.append({

    92

                    'use': 'required', 

    93

                    'type': 'element', 

    94

                    'name': 'SlaveParams', 

    95

                    'value': None, 

    96

                    'children': []

    97

                })

    98

    99

            slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   100

            params[0]['children'].insert(0,

   101

                   {'use': 'optional', 

   102

                    'type': self.CTNParent.GetSlaveTypesLibrary(self.NODE_PROFILE), 

   103

                    'name': 'Type', 

   104

                    'value': (slave_type["device_type"], slave_type)}) 

   105

            params[0]['children'].insert(1,

   106

                   {'use': 'optional', 

   107

                    'type': 'unsignedLong', 

   108

                    'name': 'Alias', 

   109

                    'value': self.CTNParent.GetSlaveAlias(self.GetSlavePos())})

   110

            return params

   111

   112

    def SetParamsAttribute(self, path, value):

   113

        position = self.BaseParams.getIEC_Channel()

   114

   115

        if path == "SlaveParams.Type":

   116

            self.CTNParent.SetSlaveType(position, value)

   117

            slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   118

            value = (slave_type["device_type"], slave_type)

   119

            if self._View is not None:

   120

                wx.CallAfter(self._View.RefreshSlaveInfos)

   121

            return value, True

   122

        elif path == "SlaveParams.Alias":

   123

            self.CTNParent.SetSlaveAlias(position, value)

   124

            return value, True

   125

   126

        value, refresh = ConfigTreeNode.SetParamsAttribute(self, path, value)

   127

   128

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   129

        if path == "BaseParams.IEC_Channel" and value != position:

   130

            self.CTNParent.SetSlavePosition(position, value)

   131

   132

        return value, refresh

   133

   134

    def GetSlaveInfos(self):

   135

        return self.CTNParent.GetSlaveInfos(self.GetSlavePos())

   136

   137

    def GetVariableLocationTree(self):

   138

        return  {"name": self.BaseParams.getName(),

   139

                 "type": LOCATION_CONFNODE,

   140

                 "location": self.GetFullIEC_Channel(),

   141

                 "children": self.CTNParent.GetDeviceLocationTree(self.GetSlavePos(), self.GetCurrentLocation(), self.BaseParams.getName())

   142

        }

   143

   144

    def CTNGenerate_C(self, buildpath, locations):

   145

        """

   146

        Generate C code

   147

        @param current_location: Tupple containing confnode IEC location : %I0.0.4.5 => (0,0,4,5)

   148

        @param locations: List of complete variables locations \

   149

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   150

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   151

            "DIR" : direction "Q","I" or "M"

   152

            "SIZE" : size "X", "B", "W", "D", "L"

   153

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   154

            }, ...]

   155

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   156

        """

   157

        return [],"",False

   158

   159

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

   160

#                 Ethercat CIA402 Node

   161

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

   162

   163

if HAS_MCL:

   164

   165

    NODE_VARIABLES = [

   166

        ("ControlWord", 0x6040, 0x00, "UINT", "Q"),

   167

        ("TargetPosition", 0x607a, 0x00, "DINT", "Q"),

   168

        ("ModesOfOperation", 0x06060, 0x00, "SINT", "Q"),

   169

        ("StatusWord", 0x6041, 0x00, "UINT", "I"),

   170

        ("ModesOfOperationDisplay", 0x06061, 0x00, "SINT", "I"),

   171

        ("ActualPosition", 0x6064, 0x00, "DINT", "I"),

   172

    ]

   173

   185

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   186

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

   187

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

   188

          <xsd:element name="CIA402SlaveParams">

   189

            <xsd:complexType>

   190

              %s

   191

            </xsd:complexType>

   192

          </xsd:element>

   193

        </xsd:schema>

   196

   197

        NODE_PROFILE = 402

   198

        EditorType = CIA402NodeEditor

   199

   200

        ConfNodeMethods = [

   201

            {"bitmap" : "CIA402AxisRef",

   202

             "name" : _("Axis Ref"),

   203

             "tooltip" : _("Initiate Drag'n drop of Axis ref located variable"),

   204

             "method" : "_getCIA402AxisRef",

   205

             "push": True},

   206

        ]

   207

   208

        def GetIconName(self):

   209

            return "CIA402Slave"

   210

   211

        def SetParamsAttribute(self, path, value):

   212

            if path == "CIA402SlaveParams.Type":

   213

                path = "SlaveParams.Type"

   214

            elif path == "CIA402SlaveParams.Alias":

   215

                path = "SlaveParams.Alias"

   216

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   217

   218

        def GetVariableLocationTree(self):

   219

            axis_name = self.CTNName()

   220

            current_location = self.GetCurrentLocation()

   221

            children = [{"name": "%s Axis Ref" % (axis_name),

   222

                         "type": LOCATION_VAR_INPUT,

   223

                         "size": "W",

   224

                         "IEC_type": "AXIS_REF",

   225

                         "var_name": axis_name,

   226

                         "location": "%%IW%s.0" % (".".join(map(str, current_location))),

   227

                         "description": "",

   228

                         "children": []}]

   229

            children.extend(self.CTNParent.GetDeviceLocationTree(self.GetSlavePos(), current_location, axis_name))

   230

            return  {"name": axis_name,

   231

                     "type": LOCATION_CONFNODE,

   232

                     "location": self.GetFullIEC_Channel(),

   233

                     "children": children,

   234

            }

   235

   236

        def _getCIA402AxisRef(self):

   237

            data = wx.TextDataObject(str(("%%IW%s.0" % ".".join(map(str, self.GetCurrentLocation())), 

   238

                                          "location", "AXIS_REF", self.CTNName(), "")))

   239

            dragSource = wx.DropSource(self.GetCTRoot().AppFrame)

   240

            dragSource.SetData(data)

   241

            dragSource.DoDragDrop()

   242

   243

        def CTNGenerate_C(self, buildpath, locations):

   244

            """

   245

            Generate C code

   246

            @param current_location: Tupple containing confnode IEC location : %I0.0.4.5 => (0,0,4,5)

   247

            @param locations: List of complete variables locations \

   248

                [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   249

                "NAME" : name of the variable (generally "__IW0_1_2" style)

   250

                "DIR" : direction "Q","I" or "M"

   251

                "SIZE" : size "X", "B", "W", "D", "L"

   252

                "LOC" : tuple of interger for IEC location (0,1,2,...)

   253

                }, ...]

   254

            @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   255

            """

   256

            current_location = self.GetCurrentLocation()

   257

   258

            location_str = "_".join(map(lambda x:str(x), current_location))

   259

   260

            plc_cia402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_cia402node.c")

   261

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   262

            plc_cia402node_code = plc_cia402node_file.read()

   263

            plc_cia402node_file.close()

   264

   265

            str_completion = {

   266

                "location": location_str,

   267

                "MCL_headers": Headers,

   268

                "extern_located_variables_declaration": [],

   269

                "entry_variables": [],

   270

                "init_axis_params": [],

   271

                "init_entry_variables": [],

   274

            }

   275

   311

                var_infos = dict(zip(["name", "index", "subindex", "var_type", "dir"], variable))

   312

                var_infos["location"] = location_str

   313

                var_infos["var_size"] = self.GetSizeOfType(var_infos["var_type"])

   314

                var_infos["var_name"] = "__%(dir)s%(var_size)s%(location)s_%(index)d_%(subindex)d" % var_infos

   315

   316

                str_completion["extern_located_variables_declaration"].append(

   317

                        "IEC_%(var_type)s *%(var_name)s;" % var_infos)

   318

                str_completion["entry_variables"].append(

   319

                        "    IEC_%(var_type)s *%(name)s;" % var_infos)

   320

                str_completion["init_entry_variables"].append(

   321

                        "    __CIA402Node_%(location)s.%(name)s = %(var_name)s;" % var_infos)

   322

   323

                self.CTNParent.FileGenerator.DeclareVariable(

   324

                        self.GetSlavePos(), var_infos["index"], var_infos["subindex"], 

   325

                        var_infos["var_type"], var_infos["dir"], var_infos["var_name"])

   326

   327

            for element in ["extern_located_variables_declaration", 

   328

                            "entry_variables", 

   329

                            "init_axis_params", 

   333

                str_completion[element] = "\n".join(str_completion[element])

   334

   335

            Gen_CIA402Nodefile_path = os.path.join(buildpath, "cia402node_%s.c"%location_str)

   336

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   337

            cia402nodefile.write(plc_cia402node_code % str_completion)

   338

            cia402nodefile.close()

   339

   340

            return [(Gen_CIA402Nodefile_path, '"-I%s"'%os.path.abspath(self.GetCTRoot().GetIECLibPath()))],"",True

   341

   342

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

   343

#                 Ethercat MASTER

   344

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

   345

   346

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

   347

   348

def ExtractHexDecValue(value):

   349

    try:

   350

        return int(value)

   351

    except:

   352

        pass

   353

    try:

   354

        return int(value.replace("#", "0"), 16)

   355

    except:

   356

        raise ValueError, "Invalid value for HexDecValue \"%s\"" % value

   357

   358

def GenerateHexDecValue(value, base=10):

   359

    if base == 10:

   360

        return str(value)

   361

    elif base == 16:

   362

        return "#x%.8x" % value

   363

    else:

   364

        raise ValueError, "Not supported base"

   365

   366

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

   367

if cls:

   368

   369

    def getType(self):

   370

        slave_info = self.getInfo()

   371

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

   372

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

   373

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

   374

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

   375

    setattr(cls, "getType", getType)

   376

   377

    def setType(self, type_infos):

   378

        slave_info = self.getInfo()

   379

        slave_info.setName(type_infos["device_type"])

   380

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

   381

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

   382

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

   383

    setattr(cls, "setType", setType)

   384

   385

class _EthercatCTN:

   386

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

   387

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

   388

      <xsd:element name="EtherlabNode">

   389

        <xsd:complexType>

   390

          <xsd:attribute name="MasterNumber" type="xsd:integer" use="optional" default="0"/>

   391

        </xsd:complexType>

   392

      </xsd:element>

   393

    </xsd:schema>

   394

    """

   395

   396

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

   397

    if HAS_MCL:

   398

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

   399

   400

    def __init__(self):

   401

        filepath = self.ConfigFileName()

   402

   403

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

   404

        if os.path.isfile(filepath):

   405

            xmlfile = open(filepath, 'r')

   406

            tree = minidom.parse(xmlfile)

   407

            xmlfile.close()

   408

   409

            for child in tree.childNodes:

   410

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

   411

                    self.Config.loadXMLTree(child)

   412

                    self.CreateConfigBuffer(True)

   413

        else:

   414

            self.CreateConfigBuffer(False)

   415

            self.OnCTNSave()

   416

   417

    def ExtractHexDecValue(self, value):

   418

        return ExtractHexDecValue(value)

   419

   420

    def GetSizeOfType(self, type):

   421

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

   422

   423

    def ConfigFileName(self):

   424

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

   425

   426

    def GetSlaves(self):

   427

        slaves = []

   428

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

   429

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

   430

        slaves.sort()

   431

        return slaves

   432

   433

    def GetSlave(self, slave_pos):

   434

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

   435

            slave_info = slave.getInfo()

   436

            if slave_info.getPhysAddr() == slave_pos:

   437

                return slave

   438

        return None

   439

   440

    def _ScanNetwork(self):

   441

        app_frame = self.GetCTRoot().AppFrame

   442

   443

        execute = True

   444

        if len(self.Children) > 0:

   445

            dialog = wx.MessageDialog(app_frame, 

   446

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

   447

                _("Scan Network"), 

   448

                wx.YES_NO|wx.ICON_QUESTION)

   449

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

   450

            dialog.Destroy()

   451

   452

        if execute:

   453

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

   454

            if error != 0:

   455

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

   456

                dialog.ShowModal()

   457

                dialog.Destroy()

   458

            elif returnVal is not None:

   459

                for child in self.IECSortedChildren():

   460

                    self._doRemoveChild(child)

   461

   462

                for slave in returnVal:

   463

                    type_infos = {

   464

                        "vendor": slave["vendor_id"],

   465

                        "product_code": slave["product_code"],

   466

                        "revision_number":slave["revision_number"],

   467

                    }

   468

                    device = self.GetModuleInfos(type_infos)

   469

                    if device is not None:

   470

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

   471

                            CTNType = "EthercatCIA402Slave"

   472

                        else:

   473

                            CTNType = "EthercatSlave"

   474

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

   475

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

   476

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

   477

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

   478

   479

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

   480

        """

   481

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

   482

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

   483

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

   484

        """

   485

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

   486

   487

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

   488

        if slave is None:

   489

            slave = EtherCATConfigClasses["Config_Slave"]()

   490

            slave_infos = slave.getInfo()

   491

            slave_infos.setName("undefined")

   492

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

   493