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

        """

   178

        Generate C code

   179

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

   180

        @param locations: List of complete variables locations \

   181

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

   182

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

   183

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

   184

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

   185

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

   186

            }, ...]

   187

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

   188

        """

   189

        return [],"",False

   190

   191

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

   192

#                 Ethercat CIA402 Node

   193

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

   194

   195

if HAS_MCL:

   196

   197

    NODE_VARIABLES = [

   198

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

   199

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

   200

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

   201

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

   202

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

   203

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

   204

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

   205

    ]

   206

   207

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

   208

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

   209

   210

    EXTRA_NODE_VARIABLES = [

   211

        ("ErrorCode", [

   212

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

   213

             "publish": None}

   214

            ]),

   215

        ("DigitalInputs", [

   216

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

   217

             "publish": None}

   218

            ]),

   219

        ("DigitalOutputs", [

   220

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

   221

             "retrieve": None}

   222

            ])

   223

    ]

   224

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

   225

   226

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

   227

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

   228

   229

    BLOCK_FUNCTION_TEMPLATE = """

   230

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

   231

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

   232

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

   233

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

   234

%(extract_inputs)s

   235

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

   236

%(return_outputs)s

   237

}

   238

"""

   239

   240

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

   241

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

   242

   243

    GLOBAL_INSTANCES = [

   244

        {"blocktype": "GetTorqueLimit", 

   245

         "inputs": [],

   246

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

   247

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

   248

        {"blocktype": "SetTorqueLimit", 

   249

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

   250

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

   251

         "outputs": []},

   252

    ]

   253

   254

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   255

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

   256

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

   257

          <xsd:element name="CIA402SlaveParams">

   258

            <xsd:complexType>

   259

              %s

   260

            </xsd:complexType>

   261

          </xsd:element>

   262

        </xsd:schema>

   263

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

   264

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   265

   266

        NODE_PROFILE = 402

   267

        EditorType = CIA402NodeEditor

   268

   269

        ConfNodeMethods = [

   270

            {"bitmap" : "CIA402AxisRef",

   271

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

   272

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

   273

             "method" : "_getCIA402AxisRef",

   274

             "push": True},

   275

        ]

   276

   277

        def GetIconName(self):

   278

            return "CIA402Slave"

   279

   280

        def SetParamsAttribute(self, path, value):

   281

            if path == "CIA402SlaveParams.Type":

   282

                path = "SlaveParams.Type"

   283

            elif path == "CIA402SlaveParams.Alias":

   284

                path = "SlaveParams.Alias"

   285

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   286

   287

        def GetVariableLocationTree(self):

   288

            axis_name = self.CTNName()

   289

            current_location = self.GetCurrentLocation()

   290

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

   291

                         "type": LOCATION_VAR_INPUT,

   292

                         "size": "W",

   293

                         "IEC_type": "AXIS_REF",

   294

                         "var_name": axis_name,

   295

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

   296

                         "description": "",

   297

                         "children": []}]

   298

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

   299

            return  {"name": axis_name,

   300

                     "type": LOCATION_CONFNODE,

   301

                     "location": self.GetFullIEC_Channel(),

   302

                     "children": children,

   303

            }

   304

   305

        def CTNGlobalInstances(self):

   306

            current_location = self.GetCurrentLocation()

   307

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

   308

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

   309

   310

        def _getCIA402AxisRef(self):

   311

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

   312

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

   313

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

   314

            dragSource.SetData(data)

   315

            dragSource.DoDragDrop()

   316

   317

        def CTNGenerate_C(self, buildpath, locations):

   318

            """

   319

            Generate C code

   320

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

   321

            @param locations: List of complete variables locations \

   322

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

   323

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

   324

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

   325

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

   326

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

   327

                }, ...]

   328

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

   329

            """

   330

            current_location = self.GetCurrentLocation()

   331

   332

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

   333

   334

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

   335

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   336

            plc_cia402node_code = plc_cia402node_file.read()

   337

            plc_cia402node_file.close()

   338

   339

            str_completion = {

   340

                "slave_pos": self.GetSlavePos(),

   341

                "location": location_str,

   342

                "MCL_headers": Headers,

   343

                "extern_located_variables_declaration": [],

   344

                "fieldbus_interface_declaration": [],

   345

                "fieldbus_interface_definition": [],

   346

                "entry_variables": [],

   347

                "init_axis_params": [],

   348

                "init_entry_variables": [],

   349

                "extra_variables_retrieve": [],

   350

                "extra_variables_publish": []

   351

            }

   352

   353

            for blocktype_infos in GLOBAL_INSTANCES:

   354

                texts = {

   355

                    "blocktype": blocktype_infos["blocktype"],

   356

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

   357

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

   358

                }

   359

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

   360

   361

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

   362

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

   363

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

   364

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

   365

                          for input in blocktype_infos["inputs"]]

   366

                input_texts = []

   367

                for input_infos in inputs:

   368

                    input_infos.update(texts)

   369

                    input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   370

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

   371

   372

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

   373

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

   374

                output_texts = []

   375

                for output_infos in outputs:

   376

                    output_infos.update(texts)

   377

                    output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   378

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

   379

   380

                str_completion["fieldbus_interface_declaration"].append(

   381

                        BLOCK_FUNCTION_TEMPLATE % texts)

   382

   383

                str_completion["fieldbus_interface_definition"].append(

   384

                        BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   385

   386

            variables = NODE_VARIABLES[:]

   387

   388

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

   389

            for param in params["children"]:

   390

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   391

                    if param["value"]:

   392

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

   393

                        for variable_infos in extra_variables:

   394

                            var_infos = {

   395

                                "location": location_str,

   396

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

   397

                            }

   398

                            variables.append(variable_infos["description"])

   399

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

   400

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

   401

   402

                            if retrieve_template is not None:

   403

                                str_completion["extra_variables_retrieve"].append(

   404

                                    retrieve_template % var_infos)

   405

                            if publish_template is not None:

   406

                                str_completion["extra_variables_publish"].append(

   407

                                    publish_template % var_infos)

   408

                elif param["value"] is not None:

   409

                    param_infos = {

   410

                        "location": location_str,

   411

                        "param_name": param["name"],

   412

                    }

   413

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

   414

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

   415

                    else:

   416

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

   417

                    str_completion["init_axis_params"].append(

   418

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

   419

   420

            for variable in variables:

   421

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

   422

                var_infos["location"] = location_str

   423

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

   424

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

   425

   426

                str_completion["extern_located_variables_declaration"].append(

   427

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

   428

                str_completion["entry_variables"].append(

   429

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

   430

                str_completion["init_entry_variables"].append(

   431

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

   432

   433

                self.CTNParent.FileGenerator.DeclareVariable(

   434

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

   435

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

   436

   437

            for element in ["extern_located_variables_declaration", 

   438

                            "fieldbus_interface_declaration",

   439

                            "fieldbus_interface_definition",

   440

                            "entry_variables", 

   441

                            "init_axis_params", 

   442

                            "init_entry_variables",

   443

                            "extra_variables_retrieve",

   444

                            "extra_variables_publish"]:

   445

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

   446

   447

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

   448

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   449

            cia402nodefile.write(plc_cia402node_code % str_completion)

   450

            cia402nodefile.close()

   451

   452

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

   453

   454

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

   455

#                 Ethercat MASTER

   456

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

   457

   458

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

   459

   460

def ExtractHexDecValue(value):

   461

    try:

   462

        return int(value)

   463

    except:

   464

        pass

   465

    try:

   466

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

   467

    except:

   468

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

   469

   470

def GenerateHexDecValue(value, base=10):

   471

    if base == 10:

   472

        return str(value)

   473

    elif base == 16:

   474

        return "#x%.8x" % value

   475

    else:

   476

        raise ValueError, "Not supported base"

   477

   478

def sort_commands(x, y):

   479

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

   480

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

   481

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

   482

   483

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

   484

if cls:

   485

   486

    def getType(self):

   487

        slave_info = self.getInfo()

   488

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

   489

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