1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     9

from ConfigTreeNode import ConfigTreeNode

    10

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

    11

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

    12

    13

try:

    14

    from MotionLibrary import Headers, AxisXSD

    15

    HAS_MCL = True

    16

except:

    17

    HAS_MCL = False

    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):

    53

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

    54

                break

    55

    slaves.append(slave)

    56

returnVal = slaves

    57

"""

    58

    59

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

    85

#                    Ethercat Node

    86

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

    87

    88

class _EthercatSlaveCTN:

    89

    90

    NODE_PROFILE = None

    91

    EditorType = NodeEditor

    92

    93

    def GetIconName(self):

    94

        return "Slave"

    95

    96

    def ExtractHexDecValue(self, value):

    97

        return ExtractHexDecValue(value)

    98

    99

    def GetSizeOfType(self, type):

   100

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

   101

   102

    def GetSlavePos(self):

   103

        return self.BaseParams.getIEC_Channel()

   104

   105

    def GetParamsAttributes(self, path = None):

   106

        if path:

   107

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

   108

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

   109

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

   110

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

   111

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

   112

        else:

   113

            params = []

   114

            if self.CTNParams:

   115

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

   116

            else:

   117

                params.append({

   118

                    'use': 'required', 

   119

                    'type': 'element', 

   120

                    'name': 'SlaveParams', 

   121

                    'value': None, 

   122

                    'children': []

   123

                })

   124

   125

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

   126

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

   127

                   {'use': 'optional', 

   128

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

   129

                    'name': 'Type', 

   130

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

   131

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

   132

                   {'use': 'optional', 

   133

                    'type': 'unsignedLong', 

   134

                    'name': 'Alias', 

   135

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

   136

            return params

   137

   138

    def SetParamsAttribute(self, path, value):

   139

        position = self.BaseParams.getIEC_Channel()

   140

   141

        if path == "SlaveParams.Type":

   142

            self.CTNParent.SetSlaveType(position, value)

   143

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

   144

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

   145

            if self._View is not None:

   146

                wx.CallAfter(self._View.RefreshSlaveInfos)

   147

            return value, True

   148

        elif path == "SlaveParams.Alias":

   149

            self.CTNParent.SetSlaveAlias(position, value)

   150

            return value, True

   151

   152

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

   153

   154

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   155

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

   156

            self.CTNParent.SetSlavePosition(position, value)

   157

   158

        return value, refresh

   159

   160

    def GetSlaveInfos(self):

   161

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

   162

   163

    def GetVariableLocationTree(self):

   164

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

   165

                 "type": LOCATION_CONFNODE,

   166

                 "location": self.GetFullIEC_Channel(),

   167

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

   168

        }

   169

   170

    def CTNGenerate_C(self, buildpath, locations):

   171

        """

   172

        Generate C code

   173

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

   174

        @param locations: List of complete variables locations \

   175

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

   176

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

   177

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

   178

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

   179

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

   180

            }, ...]

   181

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

   182

        """

   183

        return [],"",False

   184

   185

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

   186

#                 Ethercat CIA402 Node

   187

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

   188

   189

if HAS_MCL:

   190

   191

    NODE_VARIABLES = [

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

    ]

   199

   200

    DEFAULT_RETRIEVE = "    __CIA402Node_%(location)s.axis->%(name)s = *(__CIA402Node_%(location)s.%(name)s);"

   201

    DEFAULT_PUBLISH = "    *(__CIA402Node_%(location)s.%(name)s) = __CIA402Node_%(location)s.axis->%(name)s;"

   202

   203

    EXTRA_NODE_VARIABLES = [

   204

        ("DigitalInputs", [

   205

            {"description": ("DigitalInputs", 0x60FD, 0x00, "UDINT", "I"),

   206

             "publish": None}

   207

            ])

   208

    ]

   209

    EXTRA_NODE_VARIABLES_DICT = dict([("Enable" + name, value) for name, value in EXTRA_NODE_VARIABLES])

   210

   211

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   212

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

   213

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

   214

          <xsd:element name="CIA402SlaveParams">

   215

            <xsd:complexType>

   216

              %s

   217

            </xsd:complexType>

   218

          </xsd:element>

   219

        </xsd:schema>

   220

        """ % ("\n".join(['<xsd:attribute name="Enable%s" type="xsd:boolean" use="optional" default="false"/>' % category 

   221

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   222

   223

        NODE_PROFILE = 402

   224

        EditorType = CIA402NodeEditor

   225

   226

        ConfNodeMethods = [

   227

            {"bitmap" : "CIA402AxisRef",

   228

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

   229

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

   230

             "method" : "_getCIA402AxisRef",

   231

             "push": True},

   232

        ]

   233

   234

        def GetIconName(self):

   235

            return "CIA402Slave"

   236

   237

        def SetParamsAttribute(self, path, value):

   238

            if path == "CIA402SlaveParams.Type":

   239

                path = "SlaveParams.Type"

   240

            elif path == "CIA402SlaveParams.Alias":

   241

                path = "SlaveParams.Alias"

   242

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   243

   244

        def GetVariableLocationTree(self):

   245

            axis_name = self.CTNName()

   246

            current_location = self.GetCurrentLocation()

   247

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

   248

                         "type": LOCATION_VAR_INPUT,

   249

                         "size": "W",

   250

                         "IEC_type": "AXIS_REF",

   251

                         "var_name": axis_name,

   252

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

   253

                         "description": "",

   254

                         "children": []}]

   255

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

   256

            return  {"name": axis_name,

   257

                     "type": LOCATION_CONFNODE,

   258

                     "location": self.GetFullIEC_Channel(),

   259

                     "children": children,

   260

            }

   261

   262

        def _getCIA402AxisRef(self):

   263

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

   264

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

   265

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

   266

            dragSource.SetData(data)

   267

            dragSource.DoDragDrop()

   268

   269

        def CTNGenerate_C(self, buildpath, locations):

   270

            """

   271

            Generate C code

   272

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

   273

            @param locations: List of complete variables locations \

   274

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

   275

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

   276

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

   277

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

   278

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

   279

                }, ...]

   280

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

   281

            """

   282

            current_location = self.GetCurrentLocation()

   283

   284

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

   285

   286

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

   287

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   288

            plc_cia402node_code = plc_cia402node_file.read()

   289

            plc_cia402node_file.close()

   290

   291

            str_completion = {

   292

                "location": location_str,

   293

                "MCL_headers": Headers,

   294

                "extern_located_variables_declaration": [],

   295

                "entry_variables": [],

   296

                "init_axis_params": [],

   297

                "init_entry_variables": [],

   298

                "extra_variables_retrieve": [],

   299

                "extra_variables_publish": []

   300

            }

   301

   302

            variables = NODE_VARIABLES[:]

   303

   304

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

   305

            for param in params["children"]:

   306

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   307

                    if param["value"]:

   308

                        extra_variables = EXTRA_NODE_VARIABLES_DICT.get(param["name"])

   309

                        for variable_infos in extra_variables:

   310

                            var_infos = {

   311

                                "location": location_str,

   312

                                "name": variable_infos["description"][0]

   313

                            }

   314

                            variables.append(variable_infos["description"])

   315

                            retrieve_template = variable_infos.get("retrieve", DEFAULT_RETRIEVE)

   316

                            publish_template = variable_infos.get("publish", DEFAULT_PUBLISH)

   317

   318

                            if retrieve_template is not None:

   319

                                str_completion["extra_variables_retrieve"].append(

   320

                                    retrieve_template % var_infos)

   321

                            if publish_template is not None:

   322

                                str_completion["extra_variables_publish"].append(

   323

                                    publish_template % var_infos)

   324

                elif param["value"] is not None:

   325

                    param_infos = {

   326

                        "location": location_str,

   327

                        "param_name": param["name"],

   328

                    }

   329

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

   330

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

   331

                    else:

   332

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

   333

                    str_completion["init_axis_params"].append(

   334

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

   335

   336

            for variable in variables:

   337

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

   338

                var_infos["location"] = location_str

   339

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

   340

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

   341

   342

                str_completion["extern_located_variables_declaration"].append(

   343

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

   344

                str_completion["entry_variables"].append(

   345

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

   346

                str_completion["init_entry_variables"].append(

   347

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

   348

   349

                self.CTNParent.FileGenerator.DeclareVariable(

   350

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

   351

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

   352

   353

            for element in ["extern_located_variables_declaration", 

   354

                            "entry_variables", 

   355

                            "init_axis_params", 

   356

                            "init_entry_variables",

   357

                            "extra_variables_retrieve",

   358

                            "extra_variables_publish"]:

   359

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

   360

   361

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

   362

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   363

            cia402nodefile.write(plc_cia402node_code % str_completion)

   364

            cia402nodefile.close()

   365

   366

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

   367

   368

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

   369

#                 Ethercat MASTER

   370

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

   371

   372

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

   373

   374

def ExtractHexDecValue(value):

   375

    try:

   376

        return int(value)

   377

    except:

   378

        pass

   379

    try:

   380

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

   381

    except:

   382

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

   383

   384

def GenerateHexDecValue(value, base=10):

   385

    if base == 10:

   386

        return str(value)

   387

    elif base == 16:

   388

        return "#x%.8x" % value

   389

    else:

   390

        raise ValueError, "Not supported base"

   391

   392

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

   393

if cls:

   394

   395

    def getType(self):

   396

        slave_info = self.getInfo()

   397

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

   398

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

   399

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

   400

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

   401

    setattr(cls, "getType", getType)

   402

   403

    def setType(self, type_infos):

   404

        slave_info = self.getInfo()

   405

        slave_info.setName(type_infos["device_type"])

   406

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

   407

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

   408

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

   409

    setattr(cls, "setType", setType)

   410

   411

class _EthercatCTN:

   412

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

   413

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

   414

      <xsd:element name="EtherlabNode">

   415

        <xsd:complexType>

   416

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

   417

        </xsd:complexType>

   418

      </xsd:element>

   419

    </xsd:schema>

   420

    """

   421

   422

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

   423

    if HAS_MCL:

   424

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

   425

   426

    def __init__(self):

   427

        filepath = self.ConfigFileName()

   428

   429

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

   430

        if os.path.isfile(filepath):

   431

            xmlfile = open(filepath, 'r')

   432

            tree = minidom.parse(xmlfile)

   433

            xmlfile.close()

   434

   435

            for child in tree.childNodes:

   436

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

   437

                    self.Config.loadXMLTree(child)

   438

                    self.CreateConfigBuffer(True)

   439

        else:

   440

            self.CreateConfigBuffer(False)

   441

            self.OnCTNSave()

   442

   443

    def ExtractHexDecValue(self, value):

   444

        return ExtractHexDecValue(value)

   445

   446

    def GetSizeOfType(self, type):

   447

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

   448

   449

    def ConfigFileName(self):

   450

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

   451

   452

    def GetSlaves(self):

   453

        slaves = []

   454

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

   455

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

   456

        slaves.sort()

   457

        return slaves

   458

   459

    def GetSlave(self, slave_pos):

   460

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

   461

            slave_info = slave.getInfo()

   462

            if slave_info.getPhysAddr() == slave_pos:

   463

                return slave

   464

        return None

   465

   466

    def _ScanNetwork(self):

   467

        app_frame = self.GetCTRoot().AppFrame

   468

   469

        execute = True

   470

        if len(self.Children) > 0:

   471

            dialog = wx.MessageDialog(app_frame, 

   472

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

   473

                _("Scan Network"), 

   474

                wx.YES_NO|wx.ICON_QUESTION)

   475

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

   476

            dialog.Destroy()

   477

   478

        if execute:

   479

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

   480

            if error != 0:

   481

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

   482

                dialog.ShowModal()

   483

                dialog.Destroy()

   484

            elif returnVal is not None:

   485

                for child in self.IECSortedChildren():

   486

                    self._doRemoveChild(child)

   487

   488

                for slave in returnVal:

   489

                    type_infos = {

   490

                        "vendor": slave["vendor_id"],

   491

                        "product_code": slave["product_code"],

   492

                        "revision_number":slave["revision_number"],

   493

                    }