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

CONFNODEFOLDER = os.path.split(os.path.realpath(__file__))[0]

    19

    20

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

    21

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

    22

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

    23

    24

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

    25

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

    26

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

    27

    28

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

    29

    30

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

    31

#         Remote Exec Etherlab Commands

    32

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

    33

    34

SCAN_COMMAND = """

    35

import commands

    36

result = commands.getoutput("ethercat slaves")

    37

slaves = []

    38

for slave_line in result.splitlines():

    39

    chunks = slave_line.split()

    40

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

    41

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

    42

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

    43

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

    44

             "alias": int(alias),

    45

             "position": int(position),

    46

             "name": name}

    47

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

    48

    for details_line in details.splitlines():

    49

        details_line = details_line.strip()

    50

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

    51

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

    52

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

    53

            if details_line.startswith(header):

    54

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

    55

                break

    56

    slaves.append(slave)

    57

returnVal = slaves

    58

"""

    59

    60

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

    61

#                    Ethercat Node

    62

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

    63

    64

class _EthercatSlaveCTN:

    65

    66

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

    67

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

    68

      <xsd:element name="SlaveParams">

    69

        <xsd:complexType>

    70

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

    71

        </xsd:complexType>

    72

      </xsd:element>

    73

    </xsd:schema>

    74

    """

    75

    76

    NODE_PROFILE = None

    77

    EditorType = NodeEditor

    78

    79

    def GetIconPath(self):

    80

        return os.path.join(CONFNODEFOLDER, "images", "Slave.png")

    81

    82

    def ExtractHexDecValue(self, value):

    83

        return ExtractHexDecValue(value)

    84

    85

    def GetSizeOfType(self, type):

    86

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

    87

    88

    def GetSlavePos(self):

    89

        return self.BaseParams.getIEC_Channel()

    90

    91

    def GetParamsAttributes(self, path = None):

    92

        if path:

    93

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

    94

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

    95

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

    96

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

    97

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

    98

        else:

    99

            params = []

   100

            if self.CTNParams:

   101

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

   102

            else:

   103

                params.append({

   104

                    'use': 'required', 

   105

                    'type': 'element', 

   106

                    'name': 'SlaveParams', 

   107

                    'value': None, 

   108

                    'children': []

   109

                })

   110

   111

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

   112

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

   113

                   {'use': 'optional', 

   114

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

   115

                    'name': 'Type', 

   116

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

   117

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

   118

                   {'use': 'optional', 

   119

                    'type': 'unsignedLong', 

   120

                    'name': 'Alias', 

   121

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

   122

            return params

   123

   124

    def SetParamsAttribute(self, path, value):

   125

        position = self.BaseParams.getIEC_Channel()

   126

   127

        if path == "SlaveParams.Type":

   128

            self.CTNParent.SetSlaveType(position, value)

   129

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

   130

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

   133

            return value, True

   134

        elif path == "SlaveParams.Alias":

   135

            self.CTNParent.SetSlaveAlias(position, value)

   136

            return value, True

   137

   138

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

   139

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   140

        if path == "BaseParams.IEC_Channel":

   141

            self.CTNParent.SetSlavePosition(position, value)

   142

   143

        return value, changed

   144

   145

    def GetSlaveInfos(self):

   146

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

   147

   148

    def GetVariableLocationTree(self):

   149

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

   150

                 "type": LOCATION_CONFNODE,

   151

                 "location": self.GetFullIEC_Channel(),

   152

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

   153

        }

   154

   155

    def CTNGenerate_C(self, buildpath, locations):

   156

        """

   157

        Generate C code

   158

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

   159

        @param locations: List of complete variables locations \

   160

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

   161

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

   162

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

   163

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

   164

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

   165

            }, ...]

   166

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

   167

        """

   168

        return [],"",False

   169

   170

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

   171

#                 Ethercat CIA402 Node

   172

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

   173

   174

if HAS_MCL:

   175

   176

    NODE_VARIABLES = [

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

    ]

   184

   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

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

   191

              %s

   192

            </xsd:complexType>

   193

          </xsd:element>

   194

        </xsd:schema>

   195

        """ % AxisXSD

   196

   197

        NODE_PROFILE = 402

   198

        EditorType = CIA402NodeEditor

   199

   200

        ConfNodeMethods = [

   201

            {"bitmap" : os.path.join(CONFNODEFOLDER, "images", "CIA402AxisRef.png"),

   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 GetIconPath(self):

   209

            return os.path.join(CONFNODEFOLDER, "images", "CIA402Slave.png")

   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": "INT",

   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": [],

   272

            }

   273

   274

            for variable in NODE_VARIABLES:

   275

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

   276

                var_infos["location"] = location_str

   277

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

   278

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

   279

   280

                str_completion["extern_located_variables_declaration"].append(

   281

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

   282

                str_completion["entry_variables"].append(

   283

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

   284

                str_completion["init_entry_variables"].append(

   285

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

   286

   287

                self.CTNParent.FileGenerator.DeclareVariable(

   288

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

   289

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

   290

   291

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

   292

            for param in params["children"]:

   293

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

   294

                    param_infos = {

   295

                        "location": location_str,

   296

                        "param_name": param["name"],

   297

                    }

   298

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

   299

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

   300

                    else:

   301

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

   302

                    str_completion["init_axis_params"].append(

   303

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

   304

   305

            for element in ["extern_located_variables_declaration", 

   306

                            "entry_variables", 

   307

                            "init_axis_params", 

   308

                            "init_entry_variables"]:

   309

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

   310

   311

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

   312

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   313

            cia402nodefile.write(plc_cia402node_code % str_completion)

   314

            cia402nodefile.close()

   315

   316

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

   317

   318

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

   319

#                 Ethercat MASTER

   320

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

   321

   322

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

   323

   324

def ExtractHexDecValue(value):

   325

    try:

   326

        return int(value)

   327

    except:

   328

        pass

   329

    try:

   330

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

   331

    except:

   332

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

   333

   334

def GenerateHexDecValue(value, base=10):

   335

    if base == 10:

   336

        return str(value)

   337

    elif base == 16:

   338

        return "#x%.8x" % value

   339

    else:

   340

        raise ValueError, "Not supported base"

   341

   342

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

   343

if cls:

   344

   345

    def getType(self):

   346

        slave_info = self.getInfo()

   347

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

   348

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

   349

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

   350

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

   351

    setattr(cls, "getType", getType)

   352

   353

    def setType(self, type_infos):

   354

        slave_info = self.getInfo()

   355

        slave_info.setName(type_infos["device_type"])

   356

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

   357

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

   358

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

   359

    setattr(cls, "setType", setType)

   360

   361

class _EthercatCTN:

   362

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

   363

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

   364

      <xsd:element name="EtherlabNode">

   365

        <xsd:complexType>

   366

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

   367

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

   368

        </xsd:complexType>

   369

      </xsd:element>

   370

    </xsd:schema>

   371

    """

   372

   373

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

   374

    if HAS_MCL:

   375

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

   376

   377

    def __init__(self):

   378

        filepath = self.ConfigFileName()

   379

   380

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

   381

        if os.path.isfile(filepath):

   382

            xmlfile = open(filepath, 'r')

   383

            tree = minidom.parse(xmlfile)

   384

            xmlfile.close()

   385

   386

            for child in tree.childNodes:

   387

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

   388

                    self.Config.loadXMLTree(child)

   389

                    self.CreateConfigBuffer(True)

   390

        else:

   391

            self.CreateConfigBuffer(False)

   392

            self.OnCTNSave()

   393

   394

    def ExtractHexDecValue(self, value):

   395

        return ExtractHexDecValue(value)

   396

   397

    def GetSizeOfType(self, type):

   398

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

   399

   400

    def ConfigFileName(self):

   401

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

   402

   403

    def GetSlaves(self):

   404

        slaves = []

   405

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

   406

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

   407

        slaves.sort()

   408

        return slaves

   409

   410

    def GetSlave(self, slave_pos):

   411

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

   412

            slave_info = slave.getInfo()

   413

            if slave_info.getPhysAddr() == slave_pos:

   414

                return slave

   415

        return None

   416

   417

    def _ScanNetwork(self):

   418

        app_frame = self.GetCTRoot().AppFrame

   419

   420

        execute = True

   421

        if len(self.Children) > 0:

   422

            dialog = wx.MessageDialog(app_frame, 

   423

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

   424

                _("Scan Network"), 

   425

                wx.YES_NO|wx.ICON_QUESTION)

   426

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

   427

            dialog.Destroy()

   428

   429

        if execute:

   430

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

   431

            if error != 0:

   432

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

   433

                dialog.ShowModal()

   434

                dialog.Destroy()

   435

            elif returnVal is not None:

   436

                for child in self.IECSortedChildren():

   437

                    self._doRemoveChild(child)

   438

   439

                for slave in returnVal:

   440

                    type_infos = {

   441

                        "vendor": slave["vendor_id"],

   442

                        "product_code": slave["product_code"],

   443

                        "revision_number":slave["revision_number"],

   444

                    }

   445

                    device = self.GetModuleInfos(type_infos)

   446

                    if device is not None:

   447

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

   448

                            CTNType = "EthercatCIA402Slave"

   449

                        else:

   450

                            CTNType = "EthercatSlave"

   451

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

   452

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

   453

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

   454

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

   455

   456

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

   457

        """

   458

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

   459

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

   460

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

   461

        """

   462

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

   463

   464

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

   465

        if slave is None:

   466

            slave = EtherCATConfigClasses["Config_Slave"]()

   467

            slave_infos = slave.getInfo()

   468

            slave_infos.setName("undefined")

   469

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

   470

            slave_infos.setAutoIncAddr(0)

   471

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

   472

            self.BufferConfig()

   473

            self.OnCTNSave()

   474

   475

        return newConfNodeOpj

   476

   477

    def _doRemoveChild(self, CTNInstance):

   478

        slave_pos = CTNInstance.GetSlavePos()

   479

        config = self.Config.getConfig()

   480

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

   481

            slave_infos = slave.getInfo()

   482

            if slave_infos.getPhysAddr() == slave_pos:

   483

                config.removeSlave(idx)

   484

                self.BufferConfig()

   485

                self.OnCTNSave()

   486

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   487

   488

    def SetSlavePosition(self, slave_pos, new_pos):

   489

        slave = self.GetSlave(slave_pos)

   490

        if slave is not None:

   491

            slave_info = slave.getInfo()

   492

            slave_info.setPhysAddr(new_pos)

   493

            self.BufferConfig()