1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

import csv

     7

     8

from xmlclass import *

     9

from POULibrary import POULibrary

    10

from ConfigTreeNode import ConfigTreeNode

    11

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

    12

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

    13

from dialogs import BrowseValuesLibraryDialog

    14

from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    15

    16

try:

    17

    from MotionLibrary import Headers, AxisXSD

    18

    HAS_MCL = True

    19

except:

    20

    HAS_MCL = False

    21

    22

TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",

    23

    "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", 

    24

    "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L"}

    25

    26

DATATYPECONVERSION = {"BOOL" : "BIT", "SINT" : "S8", "INT" : "S16", "DINT" : "S32", "LINT" : "S64",

    27

    "USINT" : "U8", "UINT" : "U16", "UDINT" : "U32", "ULINT" : "U64", 

    28

    "BYTE" : "U8", "WORD" : "U16", "DWORD" : "U32", "LWORD" : "U64"}

    29

    30

VARCLASSCONVERSION = {"T": LOCATION_VAR_INPUT, "R": LOCATION_VAR_OUTPUT, "RT": LOCATION_VAR_MEMORY}

    31

    32

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

    33

#         Remote Exec Etherlab Commands

    34

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

    35

    36

SCAN_COMMAND = """

    37

import commands

    38

result = commands.getoutput("ethercat slaves")

    39

slaves = []

    40

for slave_line in result.splitlines():

    41

    chunks = slave_line.split()

    42

    idx, pos, state, flag = chunks[:4]

    43

    name = " ".join(chunks[4:])

    44

    alias, position = pos.split(":")

    45

    slave = {"idx": int(idx),

    46

             "alias": int(alias),

    47

             "position": int(position),

    48

             "name": name}

    49

    details = commands.getoutput("ethercat slaves -p %d -v" % slave["idx"])

    50

    for details_line in details.splitlines():

    51

        details_line = details_line.strip()

    52

        for header, param in [("Vendor Id:", "vendor_id"),

    53

                              ("Product code:", "product_code"),

    54

                              ("Revision number:", "revision_number")]:

    55

            if details_line.startswith(header):

    56

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

    57

                break

    58

    slaves.append(slave)

    59

returnVal = slaves

    60

"""

    61

    62

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

    63

#      Etherlab Specific Blocks Library

    64

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

    65

    66

def GetLocalPath(filename):

    67

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

    68

    69

class EtherlabLibrary(POULibrary):

    70

    def GetLibraryPath(self):

    71

        return GetLocalPath("pous.xml")

    72

    73

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

    74

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

    75

        etherlab_ext_code = etherlab_ext_file.read()

    76

        etherlab_ext_file.close()

    77

    78

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

    79

        ethelabfile = open(Gen_etherlabfile_path,'w')

    80

        ethelabfile.write(etherlab_ext_code)

    81

        ethelabfile.close()

    82

    83

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

    84

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

    85

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

    86

    87

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

    88

#                    Ethercat Node

    89

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

    90

    91

class _EthercatSlaveCTN:

    92

    93

    NODE_PROFILE = None

    94

    EditorType = NodeEditor

    95

    96

    def GetIconName(self):

    97

        return "Slave"

    98

    99

    def ExtractHexDecValue(self, value):

   100

        return ExtractHexDecValue(value)

   101

   102

    def GetSizeOfType(self, type):

   103

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

   104

   105

    def GetSlavePos(self):

   106

        return self.BaseParams.getIEC_Channel()

   107

   108

    def GetParamsAttributes(self, path = None):

   109

        if path:

   110

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

   111

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

   112

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

   113

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

   114

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

   115

        else:

   116

            params = []

   117

            if self.CTNParams:

   118

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

   119

            else:

   120

                params.append({

   121

                    'use': 'required', 

   122

                    'type': 'element', 

   123

                    'name': 'SlaveParams', 

   124

                    'value': None, 

   125

                    'children': []

   126

                })

   127

   128

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

   129

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

   130

                   {'use': 'optional', 

   131

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

   132

                    'name': 'Type', 

   133

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

   134

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

   135

                   {'use': 'optional', 

   136

                    'type': 'unsignedLong', 

   137

                    'name': 'Alias', 

   138

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

   139

            return params

   140

   141

    def SetParamsAttribute(self, path, value):

   142

        position = self.BaseParams.getIEC_Channel()

   143

   144

        if path == "SlaveParams.Type":

   145

            self.CTNParent.SetSlaveType(position, value)

   146

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

   147

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

   148

            if self._View is not None:

   149

                wx.CallAfter(self._View.RefreshSlaveInfos)

   150

            return value, True

   151

        elif path == "SlaveParams.Alias":

   152

            self.CTNParent.SetSlaveAlias(position, value)

   153

            return value, True

   154

   155

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

   156

   157

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   158

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

   159

            self.CTNParent.SetSlavePosition(position, value)

   160

   161

        return value, refresh

   162

   163

    def GetSlaveInfos(self):

   164

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

   165

   166

    def GetSlaveVariables(self, limits):

   167

        return self.CTNParent.GetSlaveVariables(self.GetSlavePos(), limits)

   168

   169

    def GetVariableLocationTree(self):

   170

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

   171

                 "type": LOCATION_CONFNODE,

   172

                 "location": self.GetFullIEC_Channel(),

   173

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

   174

        }

   175

   176

    def CTNGenerate_C(self, buildpath, locations):

   177

        return [],"",False

   178

   179

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

   180

#                 Ethercat CIA402 Node

   181

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

   182

   183

if HAS_MCL:

   184

   185

    NODE_VARIABLES = [

   186

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

   187

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

   188

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

   189

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

   190

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

   191

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

   192

        ("ActualVelocity", 0x606C, 0x00, "DINT", "I"),

   193

    ]

   194

   195

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

   196

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

   197

   198

    EXTRA_NODE_VARIABLES = [

   199

        ("ErrorCode", [

   200

            {"description": ("ErrorCode", 0x603F, 0x00, "UINT", "I"),

   201

             "publish": None}

   202

            ]),

   203

        ("DigitalInputs", [

   204

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

   205

             "publish": None}

   206

            ]),

   207

        ("DigitalOutputs", [

   208

            {"description": ("DigitalOutputs", 0x60FE, 0x00, "UDINT", "Q"),

   209

             "retrieve": None}

   210

            ])

   211

    ]

   212

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

   213

   214

    BLOCK_INPUT_TEMPLATE = "    __SET_VAR(%(blockname)s->,%(input_name)s, %(input_value)s);"

   215

    BLOCK_OUTPUT_TEMPLATE = "    __SET_VAR(data__->,%(output_name)s, __GET_VAR(%(blockname)s->%(output_name)s));"

   216

   217

    BLOCK_FUNCTION_TEMPLATE = """

   218

extern void ETHERLAB%(ucase_blocktype)s_body__(ETHERLAB%(ucase_blocktype)s* data__);

   219

void __%(blocktype)s_%(location)s(MC_%(ucase_blocktype)s *data__) {

   220

    __DECLARE_GLOBAL_PROTOTYPE(ETHERLAB%(ucase_blocktype)s, %(blockname)s);

   221

    ETHERLAB%(ucase_blocktype)s* %(blockname)s = __GET_GLOBAL_%(blockname)s();

   222

%(extract_inputs)s

   223

    ETHERLAB%(ucase_blocktype)s_body__(%(blockname)s);

   224

%(return_outputs)s

   225

}

   226

"""

   227

   228

    BLOCK_FUNTION_DEFINITION_TEMPLATE = """    if (!__CIA402Node_%(location)s.axis->__mcl_func_MC_%(blocktype)s)

   229

    __CIA402Node_%(location)s.axis->__mcl_func_MC_%(blocktype)s = __%(blocktype)s_%(location)s;"""

   230

   231

    GLOBAL_INSTANCES = [

   232

        {"blocktype": "GetTorqueLimit", 

   233

         "inputs": [],

   234

         "outputs": [{"name": "TorqueLimitPos", "type": "UINT"},

   235

                     {"name": "TorqueLimitNeg", "type": "UINT"}]},

   236

        {"blocktype": "SetTorqueLimit", 

   237

         "inputs": [{"name": "TorqueLimitPos", "type": "UINT"},

   238

                    {"name": "TorqueLimitNeg", "type": "UINT"}],

   239

         "outputs": []},

   240

    ]

   241

   242

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   243

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

   244

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

   245

          <xsd:element name="CIA402SlaveParams">

   246

            <xsd:complexType>

   247

              %s

   248

            </xsd:complexType>

   249

          </xsd:element>

   250

        </xsd:schema>

   251

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

   252

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   253

   254

        NODE_PROFILE = 402

   255

        EditorType = CIA402NodeEditor

   256

   257

        ConfNodeMethods = [

   258

            {"bitmap" : "CIA402AxisRef",

   259

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

   260

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

   261

             "method" : "_getCIA402AxisRef",

   262

             "push": True},

   263

        ]

   264

   265

        def GetIconName(self):

   266

            return "CIA402Slave"

   267

   268

        def SetParamsAttribute(self, path, value):

   269

            if path == "CIA402SlaveParams.Type":

   270

                path = "SlaveParams.Type"

   271

            elif path == "CIA402SlaveParams.Alias":

   272

                path = "SlaveParams.Alias"

   273

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   274

   275

        def GetVariableLocationTree(self):

   276

            axis_name = self.CTNName()

   277

            current_location = self.GetCurrentLocation()

   278

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

   279

                         "type": LOCATION_VAR_INPUT,

   280

                         "size": "W",

   281

                         "IEC_type": "AXIS_REF",

   282

                         "var_name": axis_name,

   283

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

   284

                         "description": "",

   285

                         "children": []}]

   286

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

   287

            return  {"name": axis_name,

   288

                     "type": LOCATION_CONFNODE,

   289

                     "location": self.GetFullIEC_Channel(),

   290

                     "children": children,

   291

            }

   292

   293

        def CTNGlobalInstances(self):

   294

            current_location = self.GetCurrentLocation()

   295

            return [("%s_%s" % (block_infos["blocktype"], "_".join(map(str, current_location))),

   296

                     "EtherLab%s" % block_infos["blocktype"]) for block_infos in GLOBAL_INSTANCES]

   297

   298

        def _getCIA402AxisRef(self):

   299

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

   300

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

   301

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

   302

            dragSource.SetData(data)

   303

            dragSource.DoDragDrop()

   304

   305

        def CTNGenerate_C(self, buildpath, locations):

   306

            current_location = self.GetCurrentLocation()

   307

   308

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

   309

   310

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

   311

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   312

            plc_cia402node_code = plc_cia402node_file.read()

   313

            plc_cia402node_file.close()

   314

   315

            str_completion = {

   316

                "slave_pos": self.GetSlavePos(),

   317

                "location": location_str,

   318

                "MCL_headers": Headers,

   319

                "extern_located_variables_declaration": [],

   320

                "fieldbus_interface_declaration": [],

   321

                "fieldbus_interface_definition": [],

   322

                "entry_variables": [],

   323

                "init_axis_params": [],

   324

                "init_entry_variables": [],

   325

                "extra_variables_retrieve": [],

   326

                "extra_variables_publish": []

   327

            }

   328

   329

            for blocktype_infos in GLOBAL_INSTANCES:

   330

                texts = {

   331

                    "blocktype": blocktype_infos["blocktype"],

   332

                    "ucase_blocktype": blocktype_infos["blocktype"].upper(),

   333

                    "location": "_".join(map(str, current_location))

   334

                }

   335

                texts["blockname"] = "%(ucase_blocktype)s_%(location)s" % texts

   336

   337

                inputs = [{"input_name": "POS", "input_value": str(self.GetSlavePos())},

   338

                          {"input_name": "EXECUTE", "input_value": "__GET_VAR(data__->EXECUTE)"}] +\

   339

                         [{"input_name": input["name"].upper(), 

   340

                           "input_value": "__GET_VAR(data__->%s)" % input["name"].upper()}

   341

                          for input in blocktype_infos["inputs"]]

   342

                input_texts = []

   343

                for input_infos in inputs:

   344

                    input_infos.update(texts)

   345

                    input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   346

                texts["extract_inputs"] = "\n".join(input_texts)

   347

   348

                outputs = [{"output_name": output} for output in ["DONE", "BUSY", "ERROR"]] + \

   349

                          [{"output_name": output["name"].upper()} for output in blocktype_infos["outputs"]]

   350

                output_texts = []

   351

                for output_infos in outputs:

   352

                    output_infos.update(texts)

   353

                    output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   354

                texts["return_outputs"] = "\n".join(output_texts)

   355

   356

                str_completion["fieldbus_interface_declaration"].append(

   357

                        BLOCK_FUNCTION_TEMPLATE % texts)

   358

   359

                str_completion["fieldbus_interface_definition"].append(

   360

                        BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   361

   362

            variables = NODE_VARIABLES[:]

   363

   364

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

   365

            for param in params["children"]:

   366

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   367

                    if param["value"]:

   368

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

   369

                        for variable_infos in extra_variables:

   370

                            var_infos = {

   371

                                "location": location_str,

   372

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

   373

                            }

   374

                            variables.append(variable_infos["description"])

   375

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

   376

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

   377

   378

                            if retrieve_template is not None:

   379

                                str_completion["extra_variables_retrieve"].append(

   380

                                    retrieve_template % var_infos)

   381

                            if publish_template is not None:

   382

                                str_completion["extra_variables_publish"].append(

   383

                                    publish_template % var_infos)

   384

                elif param["value"] is not None:

   385

                    param_infos = {

   386

                        "location": location_str,

   387

                        "param_name": param["name"],

   388

                    }

   389

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

   390

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

   391

                    else:

   392

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

   393

                    str_completion["init_axis_params"].append(

   394

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

   395

   396

            for variable in variables:

   397

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

   398

                var_infos["location"] = location_str

   399

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

   400

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

   401

   402

                str_completion["extern_located_variables_declaration"].append(

   403

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

   404

                str_completion["entry_variables"].append(

   405

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

   406

                str_completion["init_entry_variables"].append(

   407

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

   408

   409

                self.CTNParent.FileGenerator.DeclareVariable(

   410

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

   411

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

   412

   413

            for element in ["extern_located_variables_declaration", 

   414

                            "fieldbus_interface_declaration",

   415

                            "fieldbus_interface_definition",

   416

                            "entry_variables", 

   417

                            "init_axis_params", 

   418

                            "init_entry_variables",

   419

                            "extra_variables_retrieve",

   420

                            "extra_variables_publish"]:

   421

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

   422

   423

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

   424

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   425

            cia402nodefile.write(plc_cia402node_code % str_completion)

   426

            cia402nodefile.close()

   427

   428

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

   429

   430

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

   431

#                 Ethercat MASTER

   432

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

   433

   434

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

   435

   436

def ExtractHexDecValue(value):

   437

    try:

   438

        return int(value)

   439

    except:

   440

        pass

   441

    try:

   442

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

   443

    except:

   444

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

   445

   446

def GenerateHexDecValue(value, base=10):

   447

    if base == 10:

   448

        return str(value)

   449

    elif base == 16:

   450

        return "#x%.8x" % value

   451

    else:

   452

        raise ValueError, "Not supported base"

   453

   454

def sort_commands(x, y):

   455

    if x["Index"] == y["Index"]:

   456

        return cmp(x["Subindex"], y["Subindex"])

   457

    return cmp(x["Index"], y["Index"])

   458

   459

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

   460

if cls:

   461

   462

    def getType(self):

   463

        slave_info = self.getInfo()

   464

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

   465

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

   466

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

   467

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

   468

    setattr(cls, "getType", getType)

   469

   470

    def setType(self, type_infos):

   471

        slave_info = self.getInfo()

   472

        slave_info.setName(type_infos["device_type"])

   473

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

   474

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

   475

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

   476

    setattr(cls, "setType", setType)

   477

   478

    def getInitCmds(self, create_default=False):

   479

        Mailbox = self.getMailbox()

   480

        if Mailbox is None:

   481

            if create_default:

   482

                self.addMailbox()

   483

                Mailbox = self.getMailbox()

   484

            else:

   485

                return None

   486

        CoE = Mailbox.getCoE()

   487

        if CoE is None:

   488

            if create_default:

   489

                Mailbox.addCoE()

   490

                CoE = Mailbox.getCoE()