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

   182

        def GetIconPath(self):

   183

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

   184

   185

        def CTNGenerate_C(self, buildpath, locations):

   186

            """

   187

            Generate C code

   188

            @param current_location: Tupple containing confnode 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_cia402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_cia402node.c")

   203

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   204

            plc_cia402node_code = plc_cia402node_file.read()

   205

            plc_cia402node_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

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

   228

   229

                self.CTNParent.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.CTNParams[1].getElementInfos(self.CTNParams[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

                        "        __CIA402Node_%(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_CIA402Nodefile_path = os.path.join(buildpath, "cia402node_%s.c"%location_str)

   254

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   255

            cia402nodefile.write(plc_cia402node_code % str_completion)

   256

            cia402nodefile.close()

   257

   258

            return [(Gen_CIA402Nodefile_path, '"-I%s"'%os.path.abspath(self.GetCTRoot().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 _EthercatCTN:

   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

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

   316

    if HAS_MCL:

   317

        CTNChildrenTypes.append(("EthercatCIA402Slave", _EthercatCIA402SlaveCTN, "Ethercat CIA402 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)

   331

                    self.CreateConfigBuffer(True)

   332

        else:

   333

            self.CreateConfigBuffer(False)

   334

            self.OnCTNSave()

   335

   336

    def ExtractHexDecValue(self, value):

   337

        return ExtractHexDecValue(value)

   338

   339

    def GetSizeOfType(self, type):

   340

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

   341

   342

    def ConfigFileName(self):

   343

        return os.path.join(self.CTNPath(), "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

   359

    def _ScanNetwork(self):

   360

        app_frame = self.GetCTRoot().AppFrame

   361

   362

        execute = True

   363

        if len(self.Children) > 0:

   364

            dialog = wx.MessageDialog(app_frame, 

   365

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

   366

                _("Scan Network"), 

   367

                wx.YES_NO|wx.ICON_QUESTION)

   368

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

   369

            dialog.Destroy()

   370

   371

        if execute:

   372

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

   373

            if error != 0:

   374

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

   375

                dialog.ShowModal()

   376

                dialog.Destroy()

   377

            elif returnVal is not None:

   378

                for child in self.IECSortedChildren():

   379

                    self._doRemoveChild(child)

   380

   381

                for slave in returnVal:

   382

                    type_infos = {

   383

                        "vendor": slave["vendor_id"],

   384

                        "product_code": slave["product_code"],

   385

                        "revision_number":slave["revision_number"],

   386

                    }

   387

                    device = self.GetModuleInfos(type_infos)

   388

                    if device is not None:

   389

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

   390

                            CTNType = "EthercatCIA402Slave"

   391

                        else:

   392

                            CTNType = "EthercatSlave"

   393

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

   394

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

   395

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

   396

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

   397

   398

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

   399

        """

   400

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

   401

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

   402

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

   403

        """

   404

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

   405

   406

        slave = self.GetSlave(newConfNodeOpj.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(newConfNodeOpj.BaseParams.getIEC_Channel())

   412

            slave_infos.setAutoIncAddr(0)

   413

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

   414

            self.BufferConfig()

   415

            self.OnCTNSave()

   416

   417

        return newConfNodeOpj

   418

   419

    def _doRemoveChild(self, CTNInstance):

   420

        slave_pos = CTNInstance.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.OnCTNSave()

   428

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   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.CTNParent.GetModuleInfos(type_infos)

   494

   495

    def GetSlaveTypesLibrary(self, profile_filter=None):