1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from plugger import PlugTemplate

     9

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

    10

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

    11

    12

try:

    13

    from plugins.motion import Headers, AxisXSD

    14

    HAS_MCL = True

    15

except:

    16

    HAS_MCL = False

    17

    18

    19

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

    20

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

    21

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

    22

    23

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

    24

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

    25

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

    26

    27

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

    28

    29

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

    30

#         Remote Exec Etherlab Commands

    31

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

    32

    33

SCAN_COMMAND = """

    34

import commands

    35

result = commands.getoutput("ethercat slaves")

    36

slaves = []

    37

for slave_line in result.splitlines():

    38

    chunks = slave_line.split()

    39

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

    40

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

    41

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

    42

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

    43

             "alias": int(alias),

    44

             "position": int(position),

    45

             "name": name}

    46

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

    47

    for details_line in details.splitlines():

    48

        details_line = details_line.strip()

    49

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

    50

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

    51

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

    52

            if details_line.startswith(header):

    54

                break

    55

    slaves.append(slave)

    56

returnVal = slaves

    57

"""

    58

    59

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

    60

#                    Ethercat Node

    61

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

    62

    63

class _EthercatSlavePlug:

    64

    65

    NODE_PROFILE = None

    66

    EditorType = NodeEditor

    67

    68

    def ExtractHexDecValue(self, value):

    69

        return ExtractHexDecValue(value)

    70

    71

    def GetSizeOfType(self, type):

    72

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

    73

    74

    def GetSlavePos(self):

    75

        return self.BaseParams.getIEC_Channel()

    76

    77

    def GetParamsAttributes(self, path = None):

    78

        if path:

    79

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

    80

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

    81

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

    82

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

    83

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

    84

        else:

    85

            params = []

    86

            if wx.VERSION < (2, 8, 0) and self.MandatoryParams:

    87

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

    88

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

    89

            params.append({

    90

                'use': 'required', 

    91

                'type': 'element', 

    92

                'name': 'SlaveParams', 

    93

                'value': None, 

    94

                'children': [{

    95

                    'use': 'optional', 

    96

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

    97

                    'name': 'Type', 

    98

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

    99

                   {'use': 'optional', 

   100

                    'type': 'unsignedLong', 

   101

                    'name': 'Alias', 

   102

                    'value': self.PlugParent.GetSlaveAlias(self.GetSlavePos())}]

   103

            })

   104

            if self.PlugParams:

   105

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

   106

            return params

   107

   108

    def SetParamsAttribute(self, path, value):

   109

        position = self.BaseParams.getIEC_Channel()

   110

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

   111

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   112

        if path == "BaseParams.IEC_Channel":

   113

            self.PlugParent.SetSlavePosition(position, value)

   114

        elif path == "SlaveParams.Type":

   115

            self.PlugParent.SetSlaveType(position, value)

   116

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

   117

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

   118

            changed = True

   119

        elif path == "SlaveParams.Alias":

   120

            self.PlugParent.SetSlaveAlias(position, value)

   121

            changed = True

   122

        return value, changed

   123

   124

    def GetSlaveInfos(self):

   125

        return self.PlugParent.GetSlaveInfos(self.GetSlavePos())

   126

   127

    def GetVariableLocationTree(self):

   128

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

   129

                 "type": LOCATION_PLUGIN,

   130

                 "location": self.GetFullIEC_Channel(),

   131

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

   132

        }

   133

   134

    PluginMethods = [

   135

        {"bitmap" : os.path.join("images", "EditCfile"),

   136

         "name" : _("Edit Node"), 

   137

         "tooltip" : _("Edit Node"),

   138

         "method" : "_OpenView"},

   139

    ]

   140

   141

    def PlugGenerate_C(self, buildpath, locations):

   142

        """

   143

        Generate C code

   144

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

   145

        @param locations: List of complete variables locations \

   146

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

   147

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

   148

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

   149

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

   150

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

   151

            }, ...]

   152

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

   153

        """

   154

        return [],"",False

   155

   156

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

   157

#                 Ethercat DS402 Node

   158

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

   159

   160

if HAS_MCL:

   161

   162

    NODE_VARIABLES = [

   163

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

   164

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

   165

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

   166

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

   167

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

   168

        ("ErrorCode", 0x603f, 0x00, "UINT", "I"),

   169

    ]

   170

   171

    class _EthercatDS402SlavePlug(_EthercatSlavePlug):

   172

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

   173

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

   174

          <xsd:element name="DS402SlaveParams">

   175

            <xsd:complexType>

   176

              %s

   177

            </xsd:complexType>

   178

          </xsd:element>

   179

        </xsd:schema>

   180

        """ % AxisXSD

   181

   182

        NODE_PROFILE = 402

   183

        EditorType = DS402NodeEditor

   184

   185

        def PlugGenerate_C(self, buildpath, locations):

   186

            """

   187

            Generate C code

   188

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

   189

            @param locations: List of complete variables locations \

   190

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

   191

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

   192

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

   193

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

   194

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

   195

                }, ...]

   196

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

   197

            """

   198

            current_location = self.GetCurrentLocation()

   199

   200

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

   201

   202

            plc_ds402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_ds402node.c")

   203

            plc_ds402node_file = open(plc_ds402node_filepath, 'r')

   204

            plc_ds402node_code = plc_ds402node_file.read()

   205

            plc_ds402node_file.close()

   206

   207

            str_completion = {

   208

                "location": location_str,

   209

                "MCL_headers": Headers,

   210

                "extern_located_variables_declaration": [],

   211

                "entry_variables": [],

   212

                "init_axis_params": [],

   213

                "init_entry_variables": [],

   214

            }

   215

   216

            for variable in NODE_VARIABLES:

   217

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

   218

                var_infos["location"] = location_str

   219

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

   220

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

   221

   222

                str_completion["extern_located_variables_declaration"].append(

   223

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

   224

                str_completion["entry_variables"].append(

   225

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

   226

                str_completion["init_entry_variables"].append(

   227

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

   228

   229

                self.PlugParent.FileGenerator.DeclareVariable(

   230

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

   231

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

   232

   233

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

   234

            for param in params["children"]:

   235

                if param["value"] is not None:

   236

                    param_infos = {

   237

                        "location": location_str,

   238

                        "param_name": param["name"],

   239

                    }

   240

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

   241

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

   242

                    else:

   243

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

   244

                    str_completion["init_axis_params"].append(

   245

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

   246

   247

            for element in ["extern_located_variables_declaration", 

   248

                            "entry_variables", 

   249

                            "init_axis_params", 

   250

                            "init_entry_variables"]:

   251

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

   252

   253

            Gen_DS402Nodefile_path = os.path.join(buildpath, "ds402node_%s.c"%location_str)

   254

            ds402nodefile = open(Gen_DS402Nodefile_path, 'w')

   255

            ds402nodefile.write(plc_ds402node_code % str_completion)

   256

            ds402nodefile.close()

   257

   258

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

   259

   260

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

   261

#                 Ethercat MASTER

   262

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

   263

   264

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

   265

   266

def ExtractHexDecValue(value):

   267

    try:

   268

        return int(value)

   269

    except:

   270

        pass

   271

    try:

   272

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

   273

    except:

   274

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

   275

   276

def GenerateHexDecValue(value, base=10):

   277

    if base == 10:

   278

        return str(value)

   279

    elif base == 16:

   280

        return "#x%.8x" % value

   281

    else:

   282

        raise ValueError, "Not supported base"

   283

   284

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

   285

if cls:

   286

   287

    def getType(self):

   288

        slave_info = self.getInfo()

   289

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

   290

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

   291

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

   292

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

   293

    setattr(cls, "getType", getType)

   294

   295

    def setType(self, type_infos):

   296

        slave_info = self.getInfo()

   297

        slave_info.setName(type_infos["device_type"])

   298

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

   299

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

   300

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

   301

    setattr(cls, "setType", setType)

   302

   303

class _EthercatPlug:

   304

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

   305

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

   306

      <xsd:element name="EtherlabNode">

   307

        <xsd:complexType>

   308

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

   309

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

   310

        </xsd:complexType>

   311

      </xsd:element>

   312

    </xsd:schema>

   313

    """

   314

   315

    PlugChildsTypes = [("EthercatSlave", _EthercatSlavePlug, "Ethercat Slave")]

   316

    if HAS_MCL:

   317

        PlugChildsTypes.append(("EthercatDS402Slave", _EthercatDS402SlavePlug, "Ethercat DS402 Slave"))

   318

   319

    def __init__(self):

   320

        filepath = self.ConfigFileName()

   321

   322

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

   323

        if os.path.isfile(filepath):

   324

            xmlfile = open(filepath, 'r')

   325

            tree = minidom.parse(xmlfile)

   326

            xmlfile.close()

   327

   328

            for child in tree.childNodes:

   329

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

   330

                    self.Config.loadXMLTree(child, ["xmlns:xsi", "xsi:noNamespaceSchemaLocation"])

   331

                    self.CreateConfigBuffer(True)

   332

        else:

   333

            self.CreateConfigBuffer(False)

   334

            self.OnPlugSave()

   335

   336

    def ExtractHexDecValue(self, value):

   337

        return ExtractHexDecValue(value)

   338

   339

    def GetSizeOfType(self, type):

   340

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

   341

   342

    def ConfigFileName(self):

   343

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

   344

   345

    def GetSlaves(self):

   346

        slaves = []

   347

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

   348

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

   349

        slaves.sort()

   350

        return slaves

   351

   352

    def GetSlave(self, slave_pos):

   353

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

   354

            slave_info = slave.getInfo()

   355

            if slave_info.getPhysAddr() == slave_pos:

   356

                return slave

   357

        return None

   358

   398

    def PlugAddChild(self, PlugName, PlugType, IEC_Channel=0):

   399

        """

   400

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

   401

        @param PlugType: string desining the plugin class name (get name from PlugChildsTypes)

   402

        @param PlugName: string for the name of the plugin instance

   403

        """

   404

        newPluginOpj = PlugTemplate.PlugAddChild(self, PlugName, PlugType, IEC_Channel)

   405

   406

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

   407

        if slave is None:

   408

            slave = EtherCATConfigClasses["Config_Slave"]()

   409

            slave_infos = slave.getInfo()

   410

            slave_infos.setName("undefined")

   411

            slave_infos.setPhysAddr(newPluginOpj.BaseParams.getIEC_Channel())

   412

            slave_infos.setAutoIncAddr(0)

   413

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

   414

            self.BufferConfig()

   415

            self.OnPlugSave()

   416

   417

        return newPluginOpj

   418

   419

    def _doRemoveChild(self, PlugInstance):

   420

        slave_pos = PlugInstance.GetSlavePos()

   421

        config = self.Config.getConfig()

   422

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

   423

            slave_infos = slave.getInfo()

   424

            if slave_infos.getPhysAddr() == slave_pos:

   425

                config.removeSlave(idx)

   426

                self.BufferConfig()

   427

                self.OnPlugSave()

   428

        PlugTemplate._doRemoveChild(self, PlugInstance)

   429

   430

    def SetSlavePosition(self, slave_pos, new_pos):

   431

        slave = self.GetSlave(slave_pos)

   432

        if slave is not None:

   433

            slave_info = slave.getInfo()

   434

            slave_info.setPhysAddr(new_pos)

   435

            self.BufferConfig()

   436

   437

    def GetSlaveAlias(self, slave_pos):

   438

        slave = self.GetSlave(slave_pos)

   439

        if slave is not None:

   440

            slave_info = slave.getInfo()

   441

            return slave_info.getAutoIncAddr()

   442

        return None

   443

   444

    def SetSlaveAlias(self, slave_pos, alias):

   445

        slave = self.GetSlave(slave_pos)

   446

        if slave is not None:

   447

            slave_info = slave.getInfo()

   448

            slave_info.setAutoIncAddr(alias)

   449

            self.BufferConfig()

   450

   451

    def GetSlaveType(self, slave_pos):

   452

        slave = self.GetSlave(slave_pos)

   453

        if slave is not None:

   454

            return slave.getType()

   455

        return None

   456

   457

    def SetSlaveType(self, slave_pos, type_infos):

   458

        slave = self.GetSlave(slave_pos)

   459

        if slave is not None:

   460

            slave.setType(type_infos)

   461

            self.BufferConfig()

   462

   463

    def GetSlaveInfos(self, slave_pos):

   464

        slave = self.GetSlave(slave_pos)

   465

        if slave is not None:

   466

            type_infos = slave.getType()

   467

            device = self.GetModuleInfos(type_infos)

   468

            if device is not None:

   469

                infos = type_infos.copy()

   470

                entries = device.GetEntriesList()

   471

                entries_list = entries.items()

   472

                entries_list.sort()

   473

                entries = []

   474

                current_index = None

   475

                current_entry = None

   476

                for (index, subindex), entry in entries_list:

   477

                    entry["children"] = []

   478

                    if index != current_index:

   479

                        current_index = index

   480

                        current_entry = entry

   481

                        entries.append(entry)

   482

                    elif current_entry is not None:

   483

                        current_entry["children"].append(entry)

   484

                    else:

   485

                        entries.append(entry)

   486

                infos.update({"physics": device.getPhysics(),

   487

                              "sync_managers": device.GetSyncManagers(),

   488

                              "entries": entries})

   489

                return infos

   490

        return None

   491

   492

    def GetModuleInfos(self, type_infos):

   493

        return self.PlugParent.GetModuleInfos(type_infos)

   494

   495

    def GetSlaveTypesLibrary(self, profile_filter=None):

   496

        return self.PlugParent.GetModulesLibrary(profile_filter)

   497

   498

    def GetDeviceLocationTree(self, slave_pos, current_location, device_name):

   499

        slave = self.GetSlave(slave_pos)

   500

        if slave is not None:

   501

            type_infos = slave.getType()