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

        ("ActualVelocity", 0x606C, 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])

   236

   237

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   238

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

   239

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

   240

          <xsd:element name="CIA402SlaveParams">

   241

            <xsd:complexType>

   242

              %s

   243

            </xsd:complexType>

   244

          </xsd:element>

   245

        </xsd:schema>

   246

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

   247

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   248

   249

        NODE_PROFILE = 402

   250

        EditorType = CIA402NodeEditor

   251

   252

        ConfNodeMethods = [

   253

            {"bitmap" : "CIA402AxisRef",

   254

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

   255

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

   256

             "method" : "_getCIA402AxisRef",

   257

             "push": True},

   258

        ]

   259

   260

        def GetIconName(self):

   261

            return "CIA402Slave"

   262

   263

        def SetParamsAttribute(self, path, value):

   264

            if path == "CIA402SlaveParams.Type":

   265

                path = "SlaveParams.Type"

   266

            elif path == "CIA402SlaveParams.Alias":

   267

                path = "SlaveParams.Alias"

   268

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   269

   270

        def GetVariableLocationTree(self):

   271

            axis_name = self.CTNName()

   272

            current_location = self.GetCurrentLocation()

   273

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

   274

                         "type": LOCATION_VAR_INPUT,

   275

                         "size": "W",

   276

                         "IEC_type": "AXIS_REF",

   277

                         "var_name": axis_name,

   278

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

   279

                         "description": "",

   280

                         "children": []}]

   281

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

   282

            return  {"name": axis_name,

   283

                     "type": LOCATION_CONFNODE,

   284

                     "location": self.GetFullIEC_Channel(),

   285

                     "children": children,

   286

            }

   287

   293

        def _getCIA402AxisRef(self):

   294

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

   295

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

   296

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

   297

            dragSource.SetData(data)

   298

            dragSource.DoDragDrop()

   299

   300

        def CTNGenerate_C(self, buildpath, locations):

   301

            """

   302

            Generate C code

   303

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

   304

            @param locations: List of complete variables locations \

   305

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

   306

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

   307

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

   308

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

   309

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

   310

                }, ...]

   311

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

   312

            """

   313

            current_location = self.GetCurrentLocation()

   314

   315

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

   316

   317

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

   318

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   319

            plc_cia402node_code = plc_cia402node_file.read()

   320

            plc_cia402node_file.close()

   321

   322

            str_completion = {

   323

                "slave_pos": self.GetSlavePos(),

   324

                "location": location_str,

   325

                "MCL_headers": Headers,

   326

                "extern_located_variables_declaration": [],

   329

                "entry_variables": [],

   330

                "init_axis_params": [],

   331

                "init_entry_variables": [],

   332

                "extra_variables_retrieve": [],

   333

                "extra_variables_publish": []

   334

            }

   335

   369

            variables = NODE_VARIABLES[:]

   370

   371

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

   372

            for param in params["children"]:

   373

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   374

                    if param["value"]:

   375

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

   376

                        for variable_infos in extra_variables:

   377

                            var_infos = {

   378

                                "location": location_str,

   379

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

   380

                            }

   381

                            variables.append(variable_infos["description"])

   382

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

   383

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

   384

   385

                            if retrieve_template is not None:

   386

                                str_completion["extra_variables_retrieve"].append(

   387

                                    retrieve_template % var_infos)

   388

                            if publish_template is not None:

   389

                                str_completion["extra_variables_publish"].append(

   390

                                    publish_template % var_infos)

   391

                elif param["value"] is not None:

   392

                    param_infos = {

   393

                        "location": location_str,

   394

                        "param_name": param["name"],

   395

                    }

   396

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

   397

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

   398

                    else:

   399

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

   400

                    str_completion["init_axis_params"].append(

   401

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

   402

   403

            for variable in variables:

   404

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

   405

                var_infos["location"] = location_str

   406

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

   407

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

   408

   409

                str_completion["extern_located_variables_declaration"].append(

   410

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

   411

                str_completion["entry_variables"].append(

   412

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

   413

                str_completion["init_entry_variables"].append(

   414

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

   415

   416

                self.CTNParent.FileGenerator.DeclareVariable(

   417

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

   418

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

   419

   420

            for element in ["extern_located_variables_declaration", 

   423

                            "entry_variables", 

   424

                            "init_axis_params", 

   425

                            "init_entry_variables",

   426

                            "extra_variables_retrieve",

   427

                            "extra_variables_publish"]:

   428

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

   429

   430

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

   431

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   432

            cia402nodefile.write(plc_cia402node_code % str_completion)

   433

            cia402nodefile.close()

   434

   435

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

   436

   437

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

   438

#                 Ethercat MASTER

   439

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

   440

   441

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

   442

   443

def ExtractHexDecValue(value):

   444

    try:

   445

        return int(value)

   446

    except:

   447

        pass

   448

    try:

   449

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

   450

    except:

   451

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

   452

   453

def GenerateHexDecValue(value, base=10):

   454

    if base == 10:

   455

        return str(value)

   456

    elif base == 16:

   457

        return "#x%.8x" % value

   458

    else:

   459

        raise ValueError, "Not supported base"

   460

   461

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

   462

if cls:

   463

   464

    def getType(self):

   465

        slave_info = self.getInfo()

   466

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

   467

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

   468

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

   469

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

   470

    setattr(cls, "getType", getType)

   471

   472

    def setType(self, type_infos):

   473

        slave_info = self.getInfo()

   474

        slave_info.setName(type_infos["device_type"])

   475

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

   476

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

   477

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

   478

    setattr(cls, "setType", setType)

   479

   480

class _EthercatCTN:

   481

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

   482

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

   483

      <xsd:element name="EtherlabNode">

   484

        <xsd:complexType>

   485

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

   486

        </xsd:complexType>

   487

      </xsd:element>

   488

    </xsd:schema>

   489

    """

   490

   491

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

   492