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

    NODE_PROFILE = None

    67

    EditorType = NodeEditor

    68

    69

    def GetIconPath(self):

    70

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

    71

    72

    def ExtractHexDecValue(self, value):

    73

        return ExtractHexDecValue(value)

    74

    75

    def GetSizeOfType(self, type):

    76

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

    77

    78

    def GetSlavePos(self):

    79

        return self.BaseParams.getIEC_Channel()

    80

    81

    def GetParamsAttributes(self, path = None):

    82

        if path:

    83

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

    84

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

    85

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

    86

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

    87

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

    88

        else:

    89

            params = []

    90

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

    91

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

    92

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

    93

            params.append({

    94

                'use': 'required', 

    95

                'type': 'element', 

    96

                'name': 'SlaveParams', 

    97

                'value': None, 

    98

                'children': [{

    99

                    'use': 'optional', 

   100

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

   101

                    'name': 'Type', 

   102

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

   103

                   {'use': 'optional', 

   104

                    'type': 'unsignedLong', 

   105

                    'name': 'Alias', 

   106

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

   107

            })

   108

            if self.CTNParams:

   109

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

   110

            return params

   111

   112

    def SetParamsAttribute(self, path, value):

   113

        position = self.BaseParams.getIEC_Channel()

   114

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

   115

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   116

        if path == "BaseParams.IEC_Channel":

   117

            self.CTNParent.SetSlavePosition(position, value)

   118

        elif path == "SlaveParams.Type":

   119

            self.CTNParent.SetSlaveType(position, value)

   120

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

   121

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

   122

            changed = True

   123

        elif path == "SlaveParams.Alias":

   124

            self.CTNParent.SetSlaveAlias(position, value)

   125

            changed = True

   126

        return value, changed

   127

   128

    def GetSlaveInfos(self):

   129

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

   130

   131

    def GetVariableLocationTree(self):

   132

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

   133

                 "type": LOCATION_CONFNODE,

   134

                 "location": self.GetFullIEC_Channel(),

   135

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

   136

        }

   137

   138

    def CTNGenerate_C(self, buildpath, locations):

   139

        """

   140

        Generate C code

   141

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

   142

        @param locations: List of complete variables locations \

   143

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

   144

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

   145

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

   146

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

   147

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

   148

            }, ...]

   149

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

   150

        """

   151

        return [],"",False

   152

   153

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

   154

#                 Ethercat CIA402 Node

   155

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

   156

   157

if HAS_MCL:

   158

   159

    NODE_VARIABLES = [

   160

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

   161

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

   163

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

   164

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

   165

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

   166

    ]

   167

   168

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   169

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

   170

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

   171

          <xsd:element name="CIA402SlaveParams">

   172

            <xsd:complexType>

   173

              %s

   174

            </xsd:complexType>

   175

          </xsd:element>

   176

        </xsd:schema>

   177

        """ % AxisXSD

   178

   179

        NODE_PROFILE = 402

   180

        EditorType = CIA402NodeEditor

   181

   189

        def GetIconPath(self):

   190

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

   191

   212

        def CTNGenerate_C(self, buildpath, locations):

   213

            """

   214

            Generate C code

   215

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

   216

            @param locations: List of complete variables locations \

   217

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

   218

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

   219

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

   220

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

   221

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

   222

                }, ...]

   223

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

   224

            """

   225

            current_location = self.GetCurrentLocation()

   226

   227

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

   228

   229

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

   230

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   231

            plc_cia402node_code = plc_cia402node_file.read()

   232

            plc_cia402node_file.close()

   233

   234

            str_completion = {

   235

                "location": location_str,

   236

                "MCL_headers": Headers,

   237

                "extern_located_variables_declaration": [],

   238

                "entry_variables": [],

   239

                "init_axis_params": [],

   240

                "init_entry_variables": [],

   241

            }

   242

   243

            for variable in NODE_VARIABLES:

   244

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

   245

                var_infos["location"] = location_str

   246

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

   247

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

   248

   249

                str_completion["extern_located_variables_declaration"].append(

   250

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

   251

                str_completion["entry_variables"].append(

   252

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

   253

                str_completion["init_entry_variables"].append(

   254

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

   255

   256

                self.CTNParent.FileGenerator.DeclareVariable(

   257

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

   258

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

   259

   260

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

   261

            for param in params["children"]:

   262

                if param["value"] is not None:

   263

                    param_infos = {

   264

                        "location": location_str,

   265

                        "param_name": param["name"],

   266

                    }

   267

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

   268

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

   269

                    else:

   270

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

   271

                    str_completion["init_axis_params"].append(

   272

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

   273

   274

            for element in ["extern_located_variables_declaration", 

   275

                            "entry_variables", 

   276

                            "init_axis_params", 

   277

                            "init_entry_variables"]:

   278

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

   279

   280

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

   281

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   282

            cia402nodefile.write(plc_cia402node_code % str_completion)

   283

            cia402nodefile.close()

   284

   285

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

   286

   287

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

   288

#                 Ethercat MASTER

   289

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

   290

   291

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

   292

   293

def ExtractHexDecValue(value):

   294

    try:

   295

        return int(value)

   296

    except:

   297

        pass

   298

    try:

   299

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

   300

    except:

   301

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

   302

   303

def GenerateHexDecValue(value, base=10):

   304

    if base == 10:

   305

        return str(value)

   306

    elif base == 16:

   307

        return "#x%.8x" % value

   308

    else:

   309

        raise ValueError, "Not supported base"

   310

   311

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

   312

if cls:

   313

   314

    def getType(self):

   315

        slave_info = self.getInfo()

   316

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

   317

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

   318

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

   319

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

   320

    setattr(cls, "getType", getType)

   321

   322

    def setType(self, type_infos):

   323

        slave_info = self.getInfo()

   324

        slave_info.setName(type_infos["device_type"])

   325

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

   326

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

   327

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

   328

    setattr(cls, "setType", setType)

   329

   330

class _EthercatCTN:

   331

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

   332

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

   333

      <xsd:element name="EtherlabNode">

   334

        <xsd:complexType>

   335

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

   336

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

   338

        </xsd:complexType>

   339

      </xsd:element>

   340

    </xsd:schema>

   341

    """

   342

   343

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

   344

    if HAS_MCL:

   345

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

   346

   347

    def __init__(self):

   348

        filepath = self.ConfigFileName()

   349

   350

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

   351

        if os.path.isfile(filepath):

   352

            xmlfile = open(filepath, 'r')

   353

            tree = minidom.parse(xmlfile)

   354

            xmlfile.close()

   355

   356

            for child in tree.childNodes:

   357

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

   358

                    self.Config.loadXMLTree(child)

   359

                    self.CreateConfigBuffer(True)

   360

        else:

   361

            self.CreateConfigBuffer(False)

   362

            self.OnCTNSave()

   363

   364

    def ExtractHexDecValue(self, value):

   365

        return ExtractHexDecValue(value)

   366

   367

    def GetSizeOfType(self, type):

   368

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

   369

   370

    def ConfigFileName(self):

   371

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

   372

   373

    def GetSlaves(self):

   374

        slaves = []

   375

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

   376

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

   377

        slaves.sort()

   378

        return slaves

   379

   380

    def GetSlave(self, slave_pos):

   381

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

   382

            slave_info = slave.getInfo()

   383

            if slave_info.getPhysAddr() == slave_pos:

   384

                return slave

   385

        return None

   386

   387

    def _ScanNetwork(self):

   388

        app_frame = self.GetCTRoot().AppFrame

   389

   390

        execute = True

   391

        if len(self.Children) > 0:

   392

            dialog = wx.MessageDialog(app_frame, 

   393

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

   394

                _("Scan Network"), 

   395

                wx.YES_NO|wx.ICON_QUESTION)

   396

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

   397

            dialog.Destroy()

   398

   399

        if execute:

   400

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

   401

            if error != 0:

   402

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

   403

                dialog.ShowModal()

   404

                dialog.Destroy()

   405

            elif returnVal is not None:

   406

                for child in self.IECSortedChildren():

   407

                    self._doRemoveChild(child)

   408

   409

                for slave in returnVal:

   410

                    type_infos = {

   411

                        "vendor": slave["vendor_id"],

   412

                        "product_code": slave["product_code"],

   413

                        "revision_number":slave["revision_number"],

   414

                    }

   415

                    device = self.GetModuleInfos(type_infos)

   416

                    if device is not None:

   417

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

   418

                            CTNType = "EthercatCIA402Slave"

   419

                        else:

   420

                            CTNType = "EthercatSlave"

   421

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

   422

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

   423

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

   424

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

   425

   426

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

   427

        """

   428

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

   429

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

   430

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

   431

        """

   432

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

   433

   434

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

   435

        if slave is None:

   436

            slave = EtherCATConfigClasses["Config_Slave"]()

   437

            slave_infos = slave.getInfo()

   438

            slave_infos.setName("undefined")

   439

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

   440

            slave_infos.setAutoIncAddr(0)

   441

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

   442

            self.BufferConfig()

   443

            self.OnCTNSave()

   444

   445

        return newConfNodeOpj

   446

   447

    def _doRemoveChild(self, CTNInstance):

   448

        slave_pos = CTNInstance.GetSlavePos()

   449

        config = self.Config.getConfig()

   450

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

   451

            slave_infos = slave.getInfo()

   452

            if slave_infos.getPhysAddr() == slave_pos:

   453

                config.removeSlave(idx)

   454

                self.BufferConfig()

   455

                self.OnCTNSave()

   456

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   457

   458

    def SetSlavePosition(self, slave_pos, new_pos):

   459

        slave = self.GetSlave(slave_pos)

   460

        if slave is not None:

   461

            slave_info = slave.getInfo()

   462

            slave_info.setPhysAddr(new_pos)

   463

            self.BufferConfig()

   464

   465

    def GetSlaveAlias(self, slave_pos):

   466

        slave = self.GetSlave(slave_pos)

   467

        if slave is not None:

   468

            slave_info = slave.getInfo()

   469

            return slave_info.getAutoIncAddr()

   470

        return None

   471

   472

    def SetSlaveAlias(self, slave_pos, alias):

   473

        slave = self.GetSlave(slave_pos)

   474

        if slave is not None:

   475

            slave_info = slave.getInfo()

   476

            slave_info.setAutoIncAddr(alias)

   477

            self.BufferConfig()

   478

   479

    def GetSlaveType(self, slave_pos):

   480

        slave = self.GetSlave(slave_pos)

   481

        if slave is not None:

   482

            return slave.getType()

   483

        return None

   484

   485

    def SetSlaveType(self, slave_pos, type_infos):

   486

        slave = self.GetSlave(slave_pos)

   487

        if slave is not None:

   488

            slave.setType(type_infos)

   489

            self.BufferConfig()

   490

   491

    def GetSlaveInfos(self, slave_pos):

   492

        slave = self.GetSlave(slave_pos)

   493

        if slave is not None:

   494

            type_infos = slave.getType()

   495