1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from ConfigTreeNode import ConfigTreeNode

     9

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

    10

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

    11

    12

try:

    13

    from MotionLibrary import Headers, AxisXSD

    14

    HAS_MCL = True

    15

except:

    16

    HAS_MCL = False

    17

    18

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

    19

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

    20

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

    21

    22

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

    23

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

    24

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

    25

    26

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

    27

    28

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

    29

#         Remote Exec Etherlab Commands

    30

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

    31

    32

SCAN_COMMAND = """

    33

import commands

    34

result = commands.getoutput("ethercat slaves")

    35

slaves = []

    36

for slave_line in result.splitlines():

    37

    chunks = slave_line.split()

    38

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

    39

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

    40

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

    41

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

    42

             "alias": int(alias),

    43

             "position": int(position),

    44

             "name": name}

    45

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

    46

    for details_line in details.splitlines():

    47

        details_line = details_line.strip()

    48

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

    49

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

    50

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

    51

            if details_line.startswith(header):

    52

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

    53

                break

    54

    slaves.append(slave)

    55

returnVal = slaves

    56

"""

    57

    58

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

    59

#                    Ethercat Node

    60

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

    61

    62

class _EthercatSlaveCTN:

    63

    64

    NODE_PROFILE = None

    65

    EditorType = NodeEditor

    66

    67

    def GetIconName(self):

    68

        return "Slave"

    69

    70

    def ExtractHexDecValue(self, value):

    71

        return ExtractHexDecValue(value)

    72

    73

    def GetSizeOfType(self, type):

    74

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

    75

    76

    def GetSlavePos(self):

    77

        return self.BaseParams.getIEC_Channel()

    78

    79

    def GetParamsAttributes(self, path = None):

    80

        if path:

    81

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

    82

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

    83

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

    84

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

    85

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

    86

        else:

    87

            params = []

    88

            if self.CTNParams:

    89

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

    90

            else:

    91

                params.append({

    92

                    'use': 'required', 

    93

                    'type': 'element', 

    94

                    'name': 'SlaveParams', 

    95

                    'value': None, 

    96

                    'children': []

    97

                })

    98

    99

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

   100

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

   101

                   {'use': 'optional', 

   102

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

   103

                    'name': 'Type', 

   104

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

   105

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

   106

                   {'use': 'optional', 

   107

                    'type': 'unsignedLong', 

   108

                    'name': 'Alias', 

   109

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

   110

            return params

   111

   112

    def SetParamsAttribute(self, path, value):

   113

        position = self.BaseParams.getIEC_Channel()

   114

   115

        if path == "SlaveParams.Type":

   116

            self.CTNParent.SetSlaveType(position, value)

   117

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

   118

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

   119

            if self._View is not None:

   120

                wx.CallAfter(self._View.RefreshSlaveInfos)

   121

            return value, True

   122

        elif path == "SlaveParams.Alias":

   123

            self.CTNParent.SetSlaveAlias(position, value)

   124

            return value, True

   125

   126

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

   127

   128

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   129

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

   130

            self.CTNParent.SetSlavePosition(position, value)

   131

   132

        return value, refresh

   133

   134

    def GetSlaveInfos(self):

   135

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

   136

   137

    def GetVariableLocationTree(self):

   138

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

   139

                 "type": LOCATION_CONFNODE,

   140

                 "location": self.GetFullIEC_Channel(),

   141

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

   142

        }

   143

   144

    def CTNGenerate_C(self, buildpath, locations):

   145

        """

   146

        Generate C code

   147

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

   148

        @param locations: List of complete variables locations \

   149

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

   150

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

   151

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

   152

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

   153

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

   154

            }, ...]

   155

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

   156

        """

   157

        return [],"",False

   158

   159

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

   160

#                 Ethercat CIA402 Node

   161

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

   162

   163

if HAS_MCL:

   164

   165

    NODE_VARIABLES = [

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

    ]

   173

   174

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   175

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

   176

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

   177

          <xsd:element name="CIA402SlaveParams">

   178

            <xsd:complexType>

   179

              %s

   180

            </xsd:complexType>

   181

          </xsd:element>

   182

        </xsd:schema>

   183

        """ % AxisXSD

   184

   185

        NODE_PROFILE = 402

   186

        EditorType = CIA402NodeEditor

   187

   188

        ConfNodeMethods = [

   189

            {"bitmap" : "CIA402AxisRef",

   190

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

   191

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

   192

             "method" : "_getCIA402AxisRef",

   193

             "push": True},

   194

        ]

   195

   196

        def GetIconName(self):

   197

            return "CIA402Slave"

   198

   199

        def SetParamsAttribute(self, path, value):

   200

            if path == "CIA402SlaveParams.Type":

   201

                path = "SlaveParams.Type"

   202

            elif path == "CIA402SlaveParams.Alias":

   203

                path = "SlaveParams.Alias"

   204

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   205

   206

        def GetVariableLocationTree(self):

   207

            axis_name = self.CTNName()

   208

            current_location = self.GetCurrentLocation()

   209

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

   210

                         "type": LOCATION_VAR_INPUT,

   211

                         "size": "W",

   212

                         "IEC_type": "INT",

   213

                         "var_name": axis_name,

   214

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

   215

                         "description": "",

   216

                         "children": []}]

   217

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

   218

            return  {"name": axis_name,

   219

                     "type": LOCATION_CONFNODE,

   220

                     "location": self.GetFullIEC_Channel(),

   221

                     "children": children,

   222

            }

   223

   224

        def _getCIA402AxisRef(self):

   225

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

   226

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

   227

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

   228

            dragSource.SetData(data)

   229

            dragSource.DoDragDrop()

   230

   231

        def CTNGenerate_C(self, buildpath, locations):

   232

            """

   233

            Generate C code

   234

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

   235

            @param locations: List of complete variables locations \

   236

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

   237

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

   238

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

   239

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

   240

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

   241

                }, ...]

   242

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

   243

            """

   244

            current_location = self.GetCurrentLocation()

   245

   246

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

   247

   248

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

   249

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   250

            plc_cia402node_code = plc_cia402node_file.read()

   251

            plc_cia402node_file.close()

   252

   253

            str_completion = {

   254

                "location": location_str,

   255

                "MCL_headers": Headers,

   256

                "extern_located_variables_declaration": [],

   257

                "entry_variables": [],

   258

                "init_axis_params": [],

   259

                "init_entry_variables": [],

   260

            }

   261

   262

            for variable in NODE_VARIABLES:

   263

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

   264

                var_infos["location"] = location_str

   265

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

   266

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

   267

   268

                str_completion["extern_located_variables_declaration"].append(

   269

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

   270

                str_completion["entry_variables"].append(

   271

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

   272

                str_completion["init_entry_variables"].append(

   273

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

   274

   275

                self.CTNParent.FileGenerator.DeclareVariable(

   276

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

   277

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

   278

   279

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

   280

            for param in params["children"]:

   281

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

   282

                    param_infos = {

   283

                        "location": location_str,

   284

                        "param_name": param["name"],

   285

                    }

   286

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

   287

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

   288

                    else:

   289

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

   290

                    str_completion["init_axis_params"].append(

   291

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

   292

   293

            for element in ["extern_located_variables_declaration", 

   294

                            "entry_variables", 

   295

                            "init_axis_params", 

   296

                            "init_entry_variables"]:

   297

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

   298

   299

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

   300

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   301

            cia402nodefile.write(plc_cia402node_code % str_completion)

   302

            cia402nodefile.close()

   303

   304

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

   305

   306

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

   307

#                 Ethercat MASTER

   308

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

   309

   310

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

   311

   312

def ExtractHexDecValue(value):

   313

    try:

   314

        return int(value)

   315

    except:

   316

        pass

   317

    try:

   318

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

   319

    except:

   320

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

   321

   322

def GenerateHexDecValue(value, base=10):

   323

    if base == 10:

   324

        return str(value)

   325

    elif base == 16:

   326

        return "#x%.8x" % value

   327

    else:

   328

        raise ValueError, "Not supported base"

   329

   330

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

   331

if cls:

   332

   333

    def getType(self):

   334

        slave_info = self.getInfo()

   335

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

   336

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

   337

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

   338

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

   339

    setattr(cls, "getType", getType)

   340

   341

    def setType(self, type_infos):

   342

        slave_info = self.getInfo()

   343

        slave_info.setName(type_infos["device_type"])

   344

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

   345

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

   346

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

   347

    setattr(cls, "setType", setType)

   348

   349

class _EthercatCTN:

   350

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

   351

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

   352

      <xsd:element name="EtherlabNode">

   353

        <xsd:complexType>

   354

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

   355

        </xsd:complexType>

   356

      </xsd:element>

   357

    </xsd:schema>

   358

    """

   359

   360

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

   361

    if HAS_MCL:

   362

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

   363

   364

    def __init__(self):

   365

        filepath = self.ConfigFileName()

   366

   367

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

   368

        if os.path.isfile(filepath):

   369

            xmlfile = open(filepath, 'r')

   370

            tree = minidom.parse(xmlfile)

   371

            xmlfile.close()

   372

   373

            for child in tree.childNodes:

   374

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

   375

                    self.Config.loadXMLTree(child)

   376

                    self.CreateConfigBuffer(True)

   377

        else:

   378

            self.CreateConfigBuffer(False)

   379

            self.OnCTNSave()

   380

   381

    def ExtractHexDecValue(self, value):

   382

        return ExtractHexDecValue(value)

   383

   384

    def GetSizeOfType(self, type):

   385

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

   386

   387

    def ConfigFileName(self):

   388

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

   389

   390

    def GetSlaves(self):

   391

        slaves = []

   392

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

   393

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

   394

        slaves.sort()

   395

        return slaves

   396

   397

    def GetSlave(self, slave_pos):

   398

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

   399

            slave_info = slave.getInfo()

   400

            if slave_info.getPhysAddr() == slave_pos:

   401

                return slave

   402

        return None

   403

   404

    def _ScanNetwork(self):

   405

        app_frame = self.GetCTRoot().AppFrame

   406

   407

        execute = True

   408

        if len(self.Children) > 0:

   409

            dialog = wx.MessageDialog(app_frame, 

   410

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

   411

                _("Scan Network"), 

   412

                wx.YES_NO|wx.ICON_QUESTION)

   413

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

   414

            dialog.Destroy()

   415

   416

        if execute:

   417

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

   418

            if error != 0:

   419

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

   420

                dialog.ShowModal()

   421

                dialog.Destroy()

   422

            elif returnVal is not None:

   423

                for child in self.IECSortedChildren():

   424

                    self._doRemoveChild(child)

   425

   426

                for slave in returnVal:

   427

                    type_infos = {

   428

                        "vendor": slave["vendor_id"],

   429

                        "product_code": slave["product_code"],

   430

                        "revision_number":slave["revision_number"],

   431

                    }

   432

                    device = self.GetModuleInfos(type_infos)

   433

                    if device is not None:

   434

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

   435

                            CTNType = "EthercatCIA402Slave"

   436

                        else:

   437

                            CTNType = "EthercatSlave"

   438

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

   439

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

   440

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

   441

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

   442

   443

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

   444

        """

   445

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

   446

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

   447

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

   448

        """

   449

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

   450

   451

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

   452

        if slave is None:

   453

            slave = EtherCATConfigClasses["Config_Slave"]()

   454

            slave_infos = slave.getInfo()

   455

            slave_infos.setName("undefined")

   456

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

   457

            slave_infos.setAutoIncAddr(0)

   458

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

   459

            self.BufferConfig()

   460

            self.OnCTNSave()

   461

   462

        return newConfNodeOpj

   463

   464

    def _doRemoveChild(self, CTNInstance):

   465

        slave_pos = CTNInstance.GetSlavePos()

   466

        config = self.Config.getConfig()

   467

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

   468

            slave_infos = slave.getInfo()

   469

            if slave_infos.getPhysAddr() == slave_pos:

   470

                config.removeSlave(idx)

   471

                self.BufferConfig()

   472

                self.OnCTNSave()

   473

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   474

   475

    def SetSlavePosition(self, slave_pos, new_pos):

   476

        slave = self.GetSlave(slave_pos)

   477

        if slave is not None:

   478

            slave_info = slave.getInfo()

   479

            slave_info.setPhysAddr(new_pos)

   480

            self.BufferConfig()

   481

   482

    def GetSlaveAlias(self, slave_pos):

   483

        slave = self.GetSlave(slave_pos)

   484

        if slave is not None:

   485

            slave_info = slave.getInfo()

   486

            return slave_info.getAutoIncAddr()

   487

        return None

   488

   489

    def SetSlaveAlias(self, slave_pos, alias):

   490

        slave = self.GetSlave(slave_pos)

   491

        if slave is not None:

   492

            slave_info = slave.getInfo()

   493

            slave_info.setAutoIncAddr(alias)