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

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

    65

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

    66

      <xsd:element name="SlaveParams">

    67

        <xsd:complexType>

    68

          <xsd:attribute name="DynamicPDOs" type="xsd:boolean" use="optional" default="true"/>

    69

        </xsd:complexType>

    70

      </xsd:element>

    71

    </xsd:schema>

    72

    """

    73

    74

    NODE_PROFILE = None

    75

    EditorType = NodeEditor

    76

    77

    def GetIconName(self):

    78

        return "Slave"

    79

    80

    def ExtractHexDecValue(self, value):

    81

        return ExtractHexDecValue(value)

    82

    83

    def GetSizeOfType(self, type):

    84

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

    85

    86

    def GetSlavePos(self):

    87

        return self.BaseParams.getIEC_Channel()

    88

    89

    def GetParamsAttributes(self, path = None):

    90

        if path:

    91

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

    92

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

    93

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

    94

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

    95

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

    96

        else:

    97

            params = []

    98

            if self.CTNParams:

    99

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

   100

            else:

   101

                params.append({

   102

                    'use': 'required', 

   103

                    'type': 'element', 

   104

                    'name': 'SlaveParams', 

   105

                    'value': None, 

   106

                    'children': []

   107

                })

   108

   109

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

   110

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

   111

                   {'use': 'optional', 

   112

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

   113

                    'name': 'Type', 

   114

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

   115

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

   116

                   {'use': 'optional', 

   117

                    'type': 'unsignedLong', 

   118

                    'name': 'Alias', 

   119

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

   120

            return params

   121

   122

    def SetParamsAttribute(self, path, value):

   123

        position = self.BaseParams.getIEC_Channel()

   124

   125

        if path == "SlaveParams.Type":

   126

            self.CTNParent.SetSlaveType(position, value)

   127

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

   128

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

   129

            if self._View is not None:

   130

                wx.CallAfter(self._View.RefreshSlaveInfos)

   131

            return value, True

   132

        elif path == "SlaveParams.Alias":

   133

            self.CTNParent.SetSlaveAlias(position, value)

   134

            return value, True

   135

   136

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

   137

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   138

        if path == "BaseParams.IEC_Channel":

   139

            self.CTNParent.SetSlavePosition(position, value)

   140

   141

        return value, changed

   142

   143

    def GetSlaveInfos(self):

   144

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

   145

   146

    def GetVariableLocationTree(self):

   147

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

   148

                 "type": LOCATION_CONFNODE,

   149

                 "location": self.GetFullIEC_Channel(),

   150

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

   151

        }

   152

   153

    def CTNGenerate_C(self, buildpath, locations):

   154

        """

   155

        Generate C code

   156

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

   157

        @param locations: List of complete variables locations \

   158

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

   159

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

   160

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

   161

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

   162

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

   163

            }, ...]

   164

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

   165

        """

   166

        return [],"",False

   167

   168

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

   169

#                 Ethercat CIA402 Node

   170

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

   171

   172

if HAS_MCL:

   173

   174

    NODE_VARIABLES = [

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

    ]

   182

   183

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   184

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

   185

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

   186

          <xsd:element name="CIA402SlaveParams">

   187

            <xsd:complexType>

   188

              <xsd:attribute name="DynamicPDOs" type="xsd:boolean" use="optional" default="true"/>

   189

              %s

   190

            </xsd:complexType>

   191

          </xsd:element>

   192

        </xsd:schema>

   193

        """ % AxisXSD

   194

   195

        NODE_PROFILE = 402

   196

        EditorType = CIA402NodeEditor

   197

   198

        ConfNodeMethods = [

   199

            {"bitmap" : "CIA402AxisRef",

   200

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

   201

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

   202

             "method" : "_getCIA402AxisRef",

   203

             "push": True},

   204

        ]

   205

   206

        def GetIconName(self):

   207

            return "CIA402Slave"

   208

   209

        def SetParamsAttribute(self, path, value):

   210

            if path == "CIA402SlaveParams.Type":

   211

                path = "SlaveParams.Type"

   212

            elif path == "CIA402SlaveParams.Alias":

   213

                path = "SlaveParams.Alias"

   214

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   215

   216

        def GetVariableLocationTree(self):

   217

            axis_name = self.CTNName()

   218

            current_location = self.GetCurrentLocation()

   219

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

   220

                         "type": LOCATION_VAR_INPUT,

   221

                         "size": "W",

   222

                         "IEC_type": "INT",

   223

                         "var_name": axis_name,

   224

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

   225

                         "description": "",

   226

                         "children": []}]

   227

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

   228

            return  {"name": axis_name,

   229

                     "type": LOCATION_CONFNODE,

   230

                     "location": self.GetFullIEC_Channel(),

   231

                     "children": children,

   232

            }

   233

   234

        def _getCIA402AxisRef(self):

   236

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

   237

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

   238

            dragSource.SetData(data)

   239

            dragSource.DoDragDrop()

   240

   241

        def CTNGenerate_C(self, buildpath, locations):

   242

            """

   243

            Generate C code

   244

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

   245

            @param locations: List of complete variables locations \

   246

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

   247

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

   248

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

   249

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

   250

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

   251

                }, ...]

   252

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

   253

            """

   254

            current_location = self.GetCurrentLocation()

   255

   256

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

   257

   258

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

   259

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   260

            plc_cia402node_code = plc_cia402node_file.read()

   261

            plc_cia402node_file.close()

   262

   263

            str_completion = {

   264

                "location": location_str,

   265

                "MCL_headers": Headers,

   266

                "extern_located_variables_declaration": [],

   267

                "entry_variables": [],

   268

                "init_axis_params": [],

   269

                "init_entry_variables": [],

   270

            }

   271

   272

            for variable in NODE_VARIABLES:

   273

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

   274

                var_infos["location"] = location_str

   275

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

   276

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

   277

   278

                str_completion["extern_located_variables_declaration"].append(

   279

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

   280

                str_completion["entry_variables"].append(

   281

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

   282

                str_completion["init_entry_variables"].append(

   283

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

   284

   285

                self.CTNParent.FileGenerator.DeclareVariable(

   286

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

   287

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

   288

   289

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

   290

            for param in params["children"]:

   291

                if param["value"] is not None and param["name"] != "DynamicPDOs":

   292

                    param_infos = {

   293

                        "location": location_str,

   294

                        "param_name": param["name"],

   295

                    }

   296

                    if param["type"] == "boolean":

   297

                        param_infos["param_value"] = {True: "true", False: "false"}[param["value"]]

   298

                    else:

   299

                        param_infos["param_value"] = str(param["value"])

   300

                    str_completion["init_axis_params"].append(

   301

                        "        __CIA402Node_%(location)s.axis->%(param_name)s = %(param_value)s;" % param_infos)

   302

   303

            for element in ["extern_located_variables_declaration", 

   304

                            "entry_variables", 

   305

                            "init_axis_params", 

   306

                            "init_entry_variables"]:

   307

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

   308

   309

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

   310

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   311

            cia402nodefile.write(plc_cia402node_code % str_completion)

   312

            cia402nodefile.close()

   313

   314

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

   315

   316

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

   317

#                 Ethercat MASTER

   318

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

   319

   320

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

   321

   322

def ExtractHexDecValue(value):

   323

    try:

   324

        return int(value)

   325

    except:

   326

        pass

   327

    try:

   328

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

   329

    except:

   330

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

   331

   332

def GenerateHexDecValue(value, base=10):

   333

    if base == 10:

   334

        return str(value)

   335

    elif base == 16:

   336

        return "#x%.8x" % value

   337

    else:

   338

        raise ValueError, "Not supported base"

   339

   340

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

   341

if cls:

   342

   343

    def getType(self):

   344

        slave_info = self.getInfo()

   345

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

   346

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

   347

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

   348

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

   349

    setattr(cls, "getType", getType)

   350

   351

    def setType(self, type_infos):

   352

        slave_info = self.getInfo()

   353

        slave_info.setName(type_infos["device_type"])

   354

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

   355

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

   356

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

   357

    setattr(cls, "setType", setType)

   358

   359

class _EthercatCTN:

   360

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

   361

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

   362

      <xsd:element name="EtherlabNode">

   363

        <xsd:complexType>

   364

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

   365

          <xsd:attribute name="ConfigurePDOs" type="xsd:boolean" use="optional" default="true"/>

   366

        </xsd:complexType>

   367

      </xsd:element>

   368

    </xsd:schema>

   369

    """

   370

   371

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

   372

    if HAS_MCL:

   373

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

   374

   375

    def __init__(self):

   376

        filepath = self.ConfigFileName()

   377

   378

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

   379

        if os.path.isfile(filepath):

   380

            xmlfile = open(filepath, 'r')

   381

            tree = minidom.parse(xmlfile)

   382

            xmlfile.close()

   383

   384

            for child in tree.childNodes:

   385

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

   386

                    self.Config.loadXMLTree(child)

   387

                    self.CreateConfigBuffer(True)

   388

        else:

   389

            self.CreateConfigBuffer(False)

   390

            self.OnCTNSave()

   391

   392

    def ExtractHexDecValue(self, value):

   393

        return ExtractHexDecValue(value)

   394

   395

    def GetSizeOfType(self, type):

   396

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

   397

   398

    def ConfigFileName(self):

   399

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

   400

   401

    def GetSlaves(self):

   402

        slaves = []

   403

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

   404

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

   405

        slaves.sort()

   406

        return slaves

   407

   408

    def GetSlave(self, slave_pos):

   409

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

   410

            slave_info = slave.getInfo()

   411

            if slave_info.getPhysAddr() == slave_pos:

   412

                return slave

   413

        return None

   414

   415

    def _ScanNetwork(self):

   416

        app_frame = self.GetCTRoot().AppFrame

   417

   418

        execute = True

   419

        if len(self.Children) > 0:

   420

            dialog = wx.MessageDialog(app_frame, 

   421

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

   422

                _("Scan Network"), 

   423

                wx.YES_NO|wx.ICON_QUESTION)

   424

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

   425

            dialog.Destroy()

   426

   427

        if execute:

   428

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

   429

            if error != 0:

   430

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

   431

                dialog.ShowModal()

   432

                dialog.Destroy()

   433

            elif returnVal is not None:

   434

                for child in self.IECSortedChildren():

   435

                    self._doRemoveChild(child)

   436

   437

                for slave in returnVal:

   438

                    type_infos = {

   439

                        "vendor": slave["vendor_id"],

   440

                        "product_code": slave["product_code"],

   441

                        "revision_number":slave["revision_number"],

   442

                    }

   443

                    device = self.GetModuleInfos(type_infos)

   444

                    if device is not None:

   445

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

   446

                            CTNType = "EthercatCIA402Slave"

   447

                        else:

   448

                            CTNType = "EthercatSlave"

   449

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

   450

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

   451

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

   452

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

   453

   454

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

   455

        """

   456

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

   457

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

   458

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

   459

        """

   460

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

   461

   462

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

   463

        if slave is None:

   464

            slave = EtherCATConfigClasses["Config_Slave"]()

   465

            slave_infos = slave.getInfo()

   466

            slave_infos.setName("undefined")

   467

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

   468

            slave_infos.setAutoIncAddr(0)

   469

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

   470

            self.BufferConfig()

   471

            self.OnCTNSave()

   472

   473

        return newConfNodeOpj

   474

   475

    def _doRemoveChild(self, CTNInstance):

   476

        slave_pos = CTNInstance.GetSlavePos()

   477

        config = self.Config.getConfig()

   478

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

   479

            slave_infos = slave.getInfo()

   480

            if slave_infos.getPhysAddr() == slave_pos:

   481

                config.removeSlave(idx)

   482

                self.BufferConfig()

   483

                self.OnCTNSave()

   484

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   485

   486

    def SetSlavePosition(self, slave_pos, new_pos):

   487

        slave = self.GetSlave(slave_pos)

   488

        if slave is not None:

   489

            slave_info = slave.getInfo()

   490

            slave_info.setPhysAddr(new_pos)

   491

            self.BufferConfig()

   492

   493

    def GetSlaveAlias(self, slave_pos):