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])

   211

   214

   215

    BLOCK_FUNCTION_TEMPLATE = """

   216

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

   217

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

   220

%(extract_inputs)s

   222

%(return_outputs)s

   223

}

   224

"""

   225

   228

   229

    GLOBAL_INSTANCES = [

   230

        {"blocktype": "GetTorqueLimit", 

   231

         "inputs": [],

   232

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

   233

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

   234

        {"blocktype": "SetTorqueLimit", 

   235

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

   236

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

   237

         "outputs": []},

   238

    ]

   239

   240

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   241

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

   242

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

   243

          <xsd:element name="CIA402SlaveParams">

   244

            <xsd:complexType>

   245

              %s

   246

            </xsd:complexType>

   247

          </xsd:element>

   248

        </xsd:schema>

   249

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

   250

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   251

   252

        NODE_PROFILE = 402

   253

        EditorType = CIA402NodeEditor

   254

   255

        ConfNodeMethods = [

   256

            {"bitmap" : "CIA402AxisRef",

   257

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

   258

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

   259

             "method" : "_getCIA402AxisRef",

   260

             "push": True},

   261

        ]

   262

   263

        def GetIconName(self):

   264

            return "CIA402Slave"

   265

   266

        def SetParamsAttribute(self, path, value):

   267

            if path == "CIA402SlaveParams.Type":

   268

                path = "SlaveParams.Type"

   269

            elif path == "CIA402SlaveParams.Alias":

   270

                path = "SlaveParams.Alias"

   271

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   272

   273

        def GetVariableLocationTree(self):

   274

            axis_name = self.CTNName()

   275

            current_location = self.GetCurrentLocation()

   276

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

   277

                         "type": LOCATION_VAR_INPUT,

   278

                         "size": "W",

   279

                         "IEC_type": "AXIS_REF",

   280

                         "var_name": axis_name,

   281

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

   282

                         "description": "",

   283

                         "children": []}]

   284

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

   285

            return  {"name": axis_name,

   286

                     "type": LOCATION_CONFNODE,

   287

                     "location": self.GetFullIEC_Channel(),

   288

                     "children": children,

   289

            }

   290

   291

        def CTNGlobalInstances(self):

   292

            current_location = self.GetCurrentLocation()

   293

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

   294

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

   295

   296

        def _getCIA402AxisRef(self):

   297

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

   298

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

   299

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

   300

            dragSource.SetData(data)

   301

            dragSource.DoDragDrop()

   302

   303

        def CTNGenerate_C(self, buildpath, locations):

   304

            """

   305

            Generate C code

   306

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

   307

            @param locations: List of complete variables locations \

   308

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

   309

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

   310

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

   311

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

   312

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

   313

                }, ...]

   314

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

   315

            """

   316

            current_location = self.GetCurrentLocation()

   317

   318

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

   319

   320

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

   321

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   322

            plc_cia402node_code = plc_cia402node_file.read()

   323

            plc_cia402node_file.close()

   324

   325

            str_completion = {

   326

                "slave_pos": self.GetSlavePos(),

   327

                "location": location_str,

   328

                "MCL_headers": Headers,

   329

                "extern_located_variables_declaration": [],

   330

                "fieldbus_interface_declaration": [],

   331

                "fieldbus_interface_definition": [],

   332

                "entry_variables": [],

   333

                "init_axis_params": [],

   334

                "init_entry_variables": [],

   335

                "extra_variables_retrieve": [],

   336

                "extra_variables_publish": []

   337

            }

   338

   339

            for blocktype_infos in GLOBAL_INSTANCES:

   340

                texts = {

   341

                    "blocktype": blocktype_infos["blocktype"],

   342

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

   343

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

   344

                }

   345

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

   346

   347

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

   348

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

   349

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

   350

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

   351

                          for input in blocktype_infos["inputs"]]

   352

                input_texts = []

   353

                for input_infos in inputs:

   354

                    input_infos.update(texts)

   355

                    input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   356

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

   357

   358

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

   359

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

   360

                output_texts = []

   361

                for output_infos in outputs:

   362

                    output_infos.update(texts)

   363

                    output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   364

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

   365

   366

                str_completion["fieldbus_interface_declaration"].append(

   367

                        BLOCK_FUNCTION_TEMPLATE % texts)

   368

   369

                str_completion["fieldbus_interface_definition"].append(

   370

                        BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   371

   372

            variables = NODE_VARIABLES[:]

   373

   374

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

   375

            for param in params["children"]:

   376

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   377

                    if param["value"]:

   378

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

   379

                        for variable_infos in extra_variables:

   380

                            var_infos = {

   381

                                "location": location_str,

   382

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

   383

                            }

   384

                            variables.append(variable_infos["description"])

   385

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

   386

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

   387

   388

                            if retrieve_template is not None:

   389

                                str_completion["extra_variables_retrieve"].append(

   390

                                    retrieve_template % var_infos)

   391

                            if publish_template is not None:

   392

                                str_completion["extra_variables_publish"].append(

   393

                                    publish_template % var_infos)

   394

                elif param["value"] is not None:

   395

                    param_infos = {

   396

                        "location": location_str,

   397

                        "param_name": param["name"],

   398

                    }

   399

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

   400

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

   401

                    else:

   402

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

   403

                    str_completion["init_axis_params"].append(

   404

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

   405

   406

            for variable in variables:

   407

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

   408

                var_infos["location"] = location_str

   409

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

   410

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

   411

   412

                str_completion["extern_located_variables_declaration"].append(

   413

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

   414

                str_completion["entry_variables"].append(

   415

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

   416

                str_completion["init_entry_variables"].append(

   417

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

   418

   419

                self.CTNParent.FileGenerator.DeclareVariable(

   420

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

   421

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

   422

   423

            for element in ["extern_located_variables_declaration", 

   424

                            "fieldbus_interface_declaration",

   425

                            "fieldbus_interface_definition",

   426

                            "entry_variables", 

   427

                            "init_axis_params", 

   428

                            "init_entry_variables",

   429

                            "extra_variables_retrieve",

   430

                            "extra_variables_publish"]:

   431

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

   432

   433

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

   434

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   435

            cia402nodefile.write(plc_cia402node_code % str_completion)

   436

            cia402nodefile.close()

   437

   438

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

   439

   440

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

   441

#                 Ethercat MASTER

   442

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

   443

   444

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

   445

   446

def ExtractHexDecValue(value):

   447

    try:

   448

        return int(value)

   449

    except:

   450

        pass

   451

    try:

   452

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

   453

    except:

   454

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

   455

   456

def GenerateHexDecValue(value, base=10):

   457

    if base == 10:

   458

        return str(value)

   459

    elif base == 16:

   460

        return "#x%.8x" % value

   461

    else:

   462

        raise ValueError, "Not supported base"

   463

   464

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

   465

if cls:

   466

   467

    def getType(self):

   468

        slave_info = self.getInfo()

   469

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

   470

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

   471

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

   472

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

   473

    setattr(cls, "getType", getType)

   474

   475

    def setType(self, type_infos):

   476

        slave_info = self.getInfo()

   477

        slave_info.setName(type_infos["device_type"])

   478

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

   479

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

   480

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

   481

    setattr(cls, "setType", setType)

   482

   483

class _EthercatCTN:

   484

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

   485

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

   486

      <xsd:element name="EtherlabNode">

   487

        <xsd:complexType>

   488

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

   489

        </xsd:complexType>

   490

      </xsd:element>

   491

    </xsd:schema>