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

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   127

        if path == "BaseParams.IEC_Channel":

   128

            self.CTNParent.SetSlavePosition(position, value)

   129

   130

        return ConfigTreeNode.SetParamsAttribute(self, path, value)

   131

   132

    def GetSlaveInfos(self):

   133

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

   134

   135

    def GetVariableLocationTree(self):

   136

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

   137

                 "type": LOCATION_CONFNODE,

   138

                 "location": self.GetFullIEC_Channel(),

   139

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

   140

        }

   141

   142

    def CTNGenerate_C(self, buildpath, locations):

   143

        """

   144

        Generate C code

   145

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

   146

        @param locations: List of complete variables locations \

   147

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

   148

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

   149

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

   150

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

   151

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

   152

            }, ...]

   153

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

   154

        """

   155

        return [],"",False

   156

   157

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

   158

#                 Ethercat CIA402 Node

   159

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

   160

   161

if HAS_MCL:

   162

   163

    NODE_VARIABLES = [

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

    ]

   171

   172

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   173

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

   174

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

   175

          <xsd:element name="CIA402SlaveParams">

   176

            <xsd:complexType>

   177

              %s

   178

            </xsd:complexType>

   179

          </xsd:element>

   180

        </xsd:schema>

   181

        """ % AxisXSD

   182

   183

        NODE_PROFILE = 402

   184

        EditorType = CIA402NodeEditor

   185

   186

        ConfNodeMethods = [

   187

            {"bitmap" : "CIA402AxisRef",

   188

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

   189

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

   190

             "method" : "_getCIA402AxisRef",

   191

             "push": True},

   192

        ]

   193

   194

        def GetIconName(self):

   195

            return "CIA402Slave"

   196

   197

        def SetParamsAttribute(self, path, value):

   198

            if path == "CIA402SlaveParams.Type":

   199

                path = "SlaveParams.Type"

   200

            elif path == "CIA402SlaveParams.Alias":

   201

                path = "SlaveParams.Alias"

   202

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   203

   204

        def GetVariableLocationTree(self):

   205

            axis_name = self.CTNName()

   206

            current_location = self.GetCurrentLocation()

   207

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

   208

                         "type": LOCATION_VAR_INPUT,

   209

                         "size": "W",

   210

                         "IEC_type": "INT",

   211

                         "var_name": axis_name,

   212

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

   213

                         "description": "",

   214

                         "children": []}]

   215

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

   216

            return  {"name": axis_name,

   217

                     "type": LOCATION_CONFNODE,

   218

                     "location": self.GetFullIEC_Channel(),

   219

                     "children": children,

   220

            }

   221

   222

        def _getCIA402AxisRef(self):

   223

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

   224

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

   225

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

   226

            dragSource.SetData(data)

   227

            dragSource.DoDragDrop()

   228

   229

        def CTNGenerate_C(self, buildpath, locations):

   230

            """

   231

            Generate C code

   232

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

   233

            @param locations: List of complete variables locations \

   234

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

   235

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

   236

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

   237

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

   238

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

   239

                }, ...]

   240

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

   241

            """

   242

            current_location = self.GetCurrentLocation()

   243

   244

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

   245

   246

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

   247

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   248

            plc_cia402node_code = plc_cia402node_file.read()

   249

            plc_cia402node_file.close()

   250

   251

            str_completion = {

   252

                "location": location_str,

   253

                "MCL_headers": Headers,

   254

                "extern_located_variables_declaration": [],

   255

                "entry_variables": [],

   256

                "init_axis_params": [],

   257

                "init_entry_variables": [],

   258

            }

   259

   260

            for variable in NODE_VARIABLES:

   261

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

   262

                var_infos["location"] = location_str

   263

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

   264

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

   265

   266

                str_completion["extern_located_variables_declaration"].append(

   267

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

   268

                str_completion["entry_variables"].append(

   269

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

   270

                str_completion["init_entry_variables"].append(

   271

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

   272

   273

                self.CTNParent.FileGenerator.DeclareVariable(

   274

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

   275

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

   276

   277

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

   278

            for param in params["children"]:

   279

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

   280

                    param_infos = {

   281

                        "location": location_str,

   282

                        "param_name": param["name"],

   283

                    }

   284

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

   285

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

   286

                    else:

   287

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

   288

                    str_completion["init_axis_params"].append(

   289

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

   290

   291

            for element in ["extern_located_variables_declaration", 

   292

                            "entry_variables", 

   293

                            "init_axis_params", 

   294

                            "init_entry_variables"]:

   295

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

   296

   297

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

   298

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   299

            cia402nodefile.write(plc_cia402node_code % str_completion)

   300

            cia402nodefile.close()

   301

   302

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

   303

   304

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

   305

#                 Ethercat MASTER

   306

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

   307

   308

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

   309

   310

def ExtractHexDecValue(value):

   311

    try:

   312

        return int(value)

   313

    except:

   314

        pass

   315

    try:

   316

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

   317

    except:

   318

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

   319

   320

def GenerateHexDecValue(value, base=10):

   321

    if base == 10:

   322

        return str(value)

   323

    elif base == 16:

   324

        return "#x%.8x" % value

   325

    else:

   326

        raise ValueError, "Not supported base"

   327

   328

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

   329

if cls:

   330

   331

    def getType(self):

   332

        slave_info = self.getInfo()

   333

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

   334

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

   335

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

   336

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

   337

    setattr(cls, "getType", getType)

   338

   339

    def setType(self, type_infos):

   340

        slave_info = self.getInfo()

   341

        slave_info.setName(type_infos["device_type"])

   342

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

   343

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

   344

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

   345

    setattr(cls, "setType", setType)

   346

   347

class _EthercatCTN:

   348

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

   349

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

   350

      <xsd:element name="EtherlabNode">

   351

        <xsd:complexType>

   352

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

   353

        </xsd:complexType>

   354

      </xsd:element>

   355

    </xsd:schema>

   356

    """

   357

   358

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

   359

    if HAS_MCL:

   360

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

   361

   362

    def __init__(self):

   363

        filepath = self.ConfigFileName()

   364

   365

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

   366

        if os.path.isfile(filepath):

   367

            xmlfile = open(filepath, 'r')

   368

            tree = minidom.parse(xmlfile)

   369

            xmlfile.close()

   370

   371

            for child in tree.childNodes:

   372

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

   373

                    self.Config.loadXMLTree(child)

   374

                    self.CreateConfigBuffer(True)

   375

        else:

   376

            self.CreateConfigBuffer(False)

   377

            self.OnCTNSave()

   378

   379

    def ExtractHexDecValue(self, value):

   380

        return ExtractHexDecValue(value)

   381

   382

    def GetSizeOfType(self, type):

   383

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

   384

   385

    def ConfigFileName(self):

   386

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

   387

   388

    def GetSlaves(self):

   389

        slaves = []

   390

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

   391

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

   392

        slaves.sort()

   393

        return slaves

   394

   395

    def GetSlave(self, slave_pos):

   396

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

   397

            slave_info = slave.getInfo()

   398

            if slave_info.getPhysAddr() == slave_pos:

   399

                return slave

   400

        return None

   401

   402

    def _ScanNetwork(self):

   403

        app_frame = self.GetCTRoot().AppFrame

   404

   405

        execute = True

   406

        if len(self.Children) > 0:

   407

            dialog = wx.MessageDialog(app_frame, 

   408

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

   409

                _("Scan Network"), 

   410

                wx.YES_NO|wx.ICON_QUESTION)

   411

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

   412

            dialog.Destroy()

   413

   414

        if execute:

   415

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

   416

            if error != 0:

   417

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

   418

                dialog.ShowModal()

   419

                dialog.Destroy()

   420

            elif returnVal is not None:

   421

                for child in self.IECSortedChildren():

   422

                    self._doRemoveChild(child)

   423

   424

                for slave in returnVal:

   425

                    type_infos = {

   426

                        "vendor": slave["vendor_id"],

   427

                        "product_code": slave["product_code"],

   428

                        "revision_number":slave["revision_number"],

   429

                    }

   430

                    device = self.GetModuleInfos(type_infos)

   431

                    if device is not None:

   432

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

   433

                            CTNType = "EthercatCIA402Slave"

   434

                        else:

   435

                            CTNType = "EthercatSlave"

   436

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

   437

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

   438

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

   439

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

   440

   441

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

   442

        """

   443

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

   444

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

   445

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

   446

        """

   447

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

   448

   449

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

   450

        if slave is None:

   451

            slave = EtherCATConfigClasses["Config_Slave"]()

   452

            slave_infos = slave.getInfo()

   453

            slave_infos.setName("undefined")

   454

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

   455

            slave_infos.setAutoIncAddr(0)

   456

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

   457

            self.BufferConfig()

   458

            self.OnCTNSave()

   459

   460

        return newConfNodeOpj

   461

   462

    def _doRemoveChild(self, CTNInstance):

   463

        slave_pos = CTNInstance.GetSlavePos()

   464

        config = self.Config.getConfig()

   465

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

   466

            slave_infos = slave.getInfo()

   467

            if slave_infos.getPhysAddr() == slave_pos:

   468

                config.removeSlave(idx)

   469

                self.BufferConfig()

   470

                self.OnCTNSave()

   471

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   472

   473

    def SetSlavePosition(self, slave_pos, new_pos):

   474

        slave = self.GetSlave(slave_pos)

   475

        if slave is not None:

   476

            slave_info = slave.getInfo()

   477

            slave_info.setPhysAddr(new_pos)

   478

            self.BufferConfig()

   479

   480

    def GetSlaveAlias(self, slave_pos):

   481

        slave = self.GetSlave(slave_pos)

   482

        if slave is not None:

   483

            slave_info = slave.getInfo()

   484

            return slave_info.getAutoIncAddr()

   485

        return None

   486

   487

    def SetSlaveAlias(self, slave_pos, alias):

   488

        slave = self.GetSlave(slave_pos)

   489

        if slave is not None:

   490

            slave_info = slave.getInfo()

   491

            slave_info.setAutoIncAddr(alias)

   492

            self.BufferConfig()

   493