1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from POULibrary import POULibrary

     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

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

    60

#      Etherlab Specific Blocks Library

    61

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

    62

    63

def GetLocalPath(filename):

    64

    return os.path.join(os.path.split(__file__)[0], filename)

    65

    66

class EtherlabLibrary(POULibrary):

    67

    def GetLibraryPath(self):

    68

        return GetLocalPath("pous.xml")

    69

    70

    def Generate_C(self, buildpath, varlist, IECCFLAGS):

    71

        etherlab_ext_file = open(GetLocalPath("etherlab_ext.c"), 'r')

    72

        etherlab_ext_code = etherlab_ext_file.read()

    73

        etherlab_ext_file.close()

    74

    75

        Gen_etherlabfile_path = os.path.join(buildpath, "etherlab_ext.c")

    76

        ethelabfile = open(Gen_etherlabfile_path,'w')

    77

        ethelabfile.write(etherlab_ext_code)

    78

        ethelabfile.close()

    79

    80

        runtimefile_path = os.path.join(os.path.split(__file__)[0], "runtime_etherlab.py")

    81

        return ((["etherlab_ext"], [(Gen_etherlabfile_path, IECCFLAGS)], True), "", 

    82

                ("runtime_etherlab.py", file(GetLocalPath("runtime_etherlab.py"))))

    83

    84

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

    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 = {

   293

                "location": location_str,

   294

                "MCL_headers": Headers,

   295

                "extern_located_variables_declaration": [],

   296

                "entry_variables": [],

   297

                "init_axis_params": [],

   298

                "init_entry_variables": [],

   299

                "extra_variables_retrieve": [],

   300

                "extra_variables_publish": []

   301

            }

   302

   303

            variables = NODE_VARIABLES[:]

   304

   305

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

   306

            for param in params["children"]:

   307

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   308

                    if param["value"]:

   309

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

   310

                        for variable_infos in extra_variables:

   311

                            var_infos = {

   312

                                "location": location_str,

   313

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

   314

                            }

   315

                            variables.append(variable_infos["description"])

   316

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

   317

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

   318

   319

                            if retrieve_template is not None:

   320

                                str_completion["extra_variables_retrieve"].append(

   321

                                    retrieve_template % var_infos)

   322

                            if publish_template is not None:

   323

                                str_completion["extra_variables_publish"].append(

   324

                                    publish_template % var_infos)

   325

                elif param["value"] is not None:

   326

                    param_infos = {

   327

                        "location": location_str,

   328

                        "param_name": param["name"],

   329

                    }

   330

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

   331

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

   332

                    else:

   333

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

   334

                    str_completion["init_axis_params"].append(

   335

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

   336

   337

            for variable in variables:

   338

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

   339

                var_infos["location"] = location_str

   340

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

   341

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

   342

   343

                str_completion["extern_located_variables_declaration"].append(

   344

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

   345

                str_completion["entry_variables"].append(

   346

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

   347

                str_completion["init_entry_variables"].append(

   348

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

   349

   350

                self.CTNParent.FileGenerator.DeclareVariable(

   351

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

   352

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

   353

   354

            for element in ["extern_located_variables_declaration", 

   355

                            "entry_variables", 

   356

                            "init_axis_params", 

   357

                            "init_entry_variables",

   358

                            "extra_variables_retrieve",

   359

                            "extra_variables_publish"]:

   360

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

   361

   362

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

   363

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   364

            cia402nodefile.write(plc_cia402node_code % str_completion)

   365

            cia402nodefile.close()

   366

   367

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

   368

   369

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

   370

#                 Ethercat MASTER

   371

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

   372

   373

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

   374

   375

def ExtractHexDecValue(value):

   376

    try:

   377

        return int(value)

   378

    except:

   379

        pass

   380

    try:

   381

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

   382

    except:

   383

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

   384

   385

def GenerateHexDecValue(value, base=10):

   386

    if base == 10:

   387

        return str(value)

   388

    elif base == 16:

   389

        return "#x%.8x" % value

   390

    else:

   391

        raise ValueError, "Not supported base"

   392

   393

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

   394

if cls:

   395

   396

    def getType(self):

   397

        slave_info = self.getInfo()

   398

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

   399

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

   400

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

   401

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

   402

    setattr(cls, "getType", getType)

   403

   404

    def setType(self, type_infos):

   405

        slave_info = self.getInfo()

   406

        slave_info.setName(type_infos["device_type"])

   407

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

   408

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

   409

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

   410

    setattr(cls, "setType", setType)

   411

   412

class _EthercatCTN:

   413

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

   414

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

   415

      <xsd:element name="EtherlabNode">

   416

        <xsd:complexType>

   417

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

   418

        </xsd:complexType>

   419

      </xsd:element>

   420

    </xsd:schema>

   421

    """

   422

   423

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

   424

    if HAS_MCL:

   425

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

   426

   427

    def __init__(self):

   428

        filepath = self.ConfigFileName()

   429

   430

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

   431

        if os.path.isfile(filepath):

   432

            xmlfile = open(filepath, 'r')

   433

            tree = minidom.parse(xmlfile)

   434

            xmlfile.close()

   435

   436

            for child in tree.childNodes:

   437

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

   438

                    self.Config.loadXMLTree(child)

   439

                    self.CreateConfigBuffer(True)

   440

        else:

   441

            self.CreateConfigBuffer(False)

   442

            self.OnCTNSave()

   443

   444

    def ExtractHexDecValue(self, value):

   445

        return ExtractHexDecValue(value)

   446

   447

    def GetSizeOfType(self, type):

   448

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

   449

   450

    def ConfigFileName(self):

   451

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

   452

   453

    def GetSlaves(self):

   454

        slaves = []

   455

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

   456

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

   457

        slaves.sort()

   458

        return slaves

   459

   460

    def GetSlave(self, slave_pos):

   461

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

   462

            slave_info = slave.getInfo()

   463

            if slave_info.getPhysAddr() == slave_pos:

   464

                return slave

   465

        return None

   466

   467

    def _ScanNetwork(self):

   468

        app_frame = self.GetCTRoot().AppFrame

   469

   470

        execute = True

   471

        if len(self.Children) > 0:

   472

            dialog = wx.MessageDialog(app_frame, 

   473

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

   474

                _("Scan Network"), 

   475

                wx.YES_NO|wx.ICON_QUESTION)

   476

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

   477

            dialog.Destroy()

   478

   479

        if execute:

   480

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

   481

            if error != 0:

   482

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

   483

                dialog.ShowModal()

   484

                dialog.Destroy()

   485

            elif returnVal is not None:

   486

                for child in self.IECSortedChildren():

   487

                    self._doRemoveChild(child)

   488

   489

                for slave in returnVal:

   490

                    type_infos = {

   491

                        "vendor": slave["vendor_id"],

   492

                        "product_code": slave["product_code"],

   493

                        "revision_number":slave["revision_number"],