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"),

   199

    ]

   200

   201

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

   202

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

   203

   204

    EXTRA_NODE_VARIABLES = [

   205

        ("DigitalInputs", [

   206

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

   207

             "publish": None}

   208

            ])

   209

    ]

   210

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

   211

   212

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   213

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

   214

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

   215

          <xsd:element name="CIA402SlaveParams">

   216

            <xsd:complexType>

   217

              %s

   218

            </xsd:complexType>

   219

          </xsd:element>

   220

        </xsd:schema>

   221

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

   222

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   223

   224

        NODE_PROFILE = 402

   225

        EditorType = CIA402NodeEditor

   226

   227

        ConfNodeMethods = [

   228

            {"bitmap" : "CIA402AxisRef",

   229

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

   230

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

   231

             "method" : "_getCIA402AxisRef",

   232

             "push": True},

   233

        ]

   234

   235

        def GetIconName(self):

   236

            return "CIA402Slave"

   237

   238

        def SetParamsAttribute(self, path, value):

   239

            if path == "CIA402SlaveParams.Type":

   240

                path = "SlaveParams.Type"

   241

            elif path == "CIA402SlaveParams.Alias":

   242

                path = "SlaveParams.Alias"

   243

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   244

   245

        def GetVariableLocationTree(self):

   246

            axis_name = self.CTNName()

   247

            current_location = self.GetCurrentLocation()

   248

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

   249

                         "type": LOCATION_VAR_INPUT,

   250

                         "size": "W",

   251

                         "IEC_type": "AXIS_REF",

   252

                         "var_name": axis_name,

   253

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

   254

                         "description": "",

   255

                         "children": []}]

   256

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

   257

            return  {"name": axis_name,

   258

                     "type": LOCATION_CONFNODE,

   259

                     "location": self.GetFullIEC_Channel(),

   260

                     "children": children,

   261

            }

   262

   263

        def _getCIA402AxisRef(self):

   264

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

   265

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

   266

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

   267

            dragSource.SetData(data)

   268

            dragSource.DoDragDrop()

   269

   270

        def CTNGenerate_C(self, buildpath, locations):

   271

            """

   272

            Generate C code

   273

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

   274

            @param locations: List of complete variables locations \

   275

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

   276

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

   277

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

   278

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

   279

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

   280

                }, ...]

   281

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

   282

            """

   283

            current_location = self.GetCurrentLocation()

   284

   285

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

   286

   287

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

   288

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   289

            plc_cia402node_code = plc_cia402node_file.read()

   290

            plc_cia402node_file.close()

   291

   292

            str_completion = {

   293

                "slave_pos": self.GetSlavePos(),

   294

                "location": location_str,

   295

                "MCL_headers": Headers,

   296

                "extern_located_variables_declaration": [],

   297

                "entry_variables": [],

   298

                "init_axis_params": [],

   299

                "init_entry_variables": [],

   300

                "extra_variables_retrieve": [],

   301

                "extra_variables_publish": []

   302

            }

   303

   304

            variables = NODE_VARIABLES[:]

   305

   306

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

   307

            for param in params["children"]:

   308

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   309

                    if param["value"]:

   310

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

   311

                        for variable_infos in extra_variables:

   312

                            var_infos = {

   313

                                "location": location_str,

   314

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

   315

                            }

   316

                            variables.append(variable_infos["description"])

   317

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

   318

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

   319

   320

                            if retrieve_template is not None:

   321

                                str_completion["extra_variables_retrieve"].append(

   322

                                    retrieve_template % var_infos)

   323

                            if publish_template is not None:

   324

                                str_completion["extra_variables_publish"].append(

   325

                                    publish_template % var_infos)

   326

                elif param["value"] is not None:

   327

                    param_infos = {

   328

                        "location": location_str,

   329

                        "param_name": param["name"],

   330

                    }

   331

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

   332

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

   333

                    else:

   334

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

   335

                    str_completion["init_axis_params"].append(

   336

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

   337

   338

            for variable in variables:

   339

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

   340

                var_infos["location"] = location_str

   341

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

   342

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

   343

   344

                str_completion["extern_located_variables_declaration"].append(

   345

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

   346

                str_completion["entry_variables"].append(

   347

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

   348

                str_completion["init_entry_variables"].append(

   349

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

   350

   351

                self.CTNParent.FileGenerator.DeclareVariable(

   352

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

   353

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

   354

   355

            for element in ["extern_located_variables_declaration", 

   356

                            "entry_variables", 

   357

                            "init_axis_params", 

   358

                            "init_entry_variables",

   359

                            "extra_variables_retrieve",

   360

                            "extra_variables_publish"]:

   361

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

   362

   363

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

   364

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   365

            cia402nodefile.write(plc_cia402node_code % str_completion)

   366

            cia402nodefile.close()

   367

   368

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

   369

   370

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

   371

#                 Ethercat MASTER

   372

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

   373

   374

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

   375

   376

def ExtractHexDecValue(value):

   377

    try:

   378

        return int(value)

   379

    except:

   380

        pass

   381

    try:

   382

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

   383

    except:

   384

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

   385

   386

def GenerateHexDecValue(value, base=10):

   387

    if base == 10:

   388

        return str(value)

   389

    elif base == 16:

   390

        return "#x%.8x" % value

   391

    else:

   392

        raise ValueError, "Not supported base"

   393

   394

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

   395

if cls:

   396

   397

    def getType(self):

   398

        slave_info = self.getInfo()

   399

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

   400

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

   401

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

   402

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

   403

    setattr(cls, "getType", getType)

   404

   405

    def setType(self, type_infos):

   406

        slave_info = self.getInfo()

   407

        slave_info.setName(type_infos["device_type"])

   408

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

   409

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

   410

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

   411

    setattr(cls, "setType", setType)

   412

   413

class _EthercatCTN:

   414

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

   415

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

   416

      <xsd:element name="EtherlabNode">

   417

        <xsd:complexType>

   418

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

   419

        </xsd:complexType>

   420

      </xsd:element>

   421

    </xsd:schema>

   422

    """

   423

   424

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

   425

    if HAS_MCL:

   426

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

   427

   428

    def __init__(self):

   429

        filepath = self.ConfigFileName()

   430

   431

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

   432

        if os.path.isfile(filepath):

   433

            xmlfile = open(filepath, 'r')

   434

            tree = minidom.parse(xmlfile)

   435

            xmlfile.close()

   436

   437

            for child in tree.childNodes:

   438

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

   439

                    self.Config.loadXMLTree(child)

   440

                    self.CreateConfigBuffer(True)

   441

        else:

   442

            self.CreateConfigBuffer(False)

   443

            self.OnCTNSave()

   444

   445

    def ExtractHexDecValue(self, value):

   446

        return ExtractHexDecValue(value)

   447

   448

    def GetSizeOfType(self, type):

   449

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

   450

   451

    def ConfigFileName(self):

   452

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

   453

   454

    def GetSlaves(self):

   455

        slaves = []

   456

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

   457

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

   458

        slaves.sort()

   459

        return slaves

   460

   461

    def GetSlave(self, slave_pos):

   462

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

   463

            slave_info = slave.getInfo()

   464

            if slave_info.getPhysAddr() == slave_pos:

   465

                return slave

   466

        return None

   467

   468

    def _ScanNetwork(self):

   469

        app_frame = self.GetCTRoot().AppFrame

   470

   471

        execute = True

   472

        if len(self.Children) > 0:

   473

            dialog = wx.MessageDialog(app_frame, 

   474

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

   475

                _("Scan Network"), 

   476

                wx.YES_NO|wx.ICON_QUESTION)

   477

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

   478

            dialog.Destroy()

   479

   480

        if execute:

   481

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

   482

            if error != 0:

   483

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

   484

                dialog.ShowModal()

   485

                dialog.Destroy()

   486

            elif returnVal is not None:

   487

                for child in self.IECSortedChildren():

   488

                    self._doRemoveChild(child)

   489

   490

                for slave in returnVal:

   491

                    type_infos = {

   492

                        "vendor": slave["vendor_id"],

   493

                        "product_code": slave["product_code"],