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

   212

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

   213

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

   214

   215

    BLOCK_FUNCTION_TEMPLATE = """

   218

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

   219

%(extract_inputs)s

   220

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

   221

%(return_outputs)s

   222

}

   223

"""

   224

   226

   227

    GLOBAL_INSTANCES = [

   228

        {"blocktype": "GetTorqueLimit", 

   229

         "inputs": [],

   230

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

   231

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

   232

        {"blocktype": "SetTorqueLimit", 

   233

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

   234

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

   235

         "outputs": []},

   236

    ]

   237

   238

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   239

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

   240

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

   241

          <xsd:element name="CIA402SlaveParams">

   242

            <xsd:complexType>

   243

              %s

   244

            </xsd:complexType>

   245

          </xsd:element>

   246

        </xsd:schema>

   247

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

   248

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   249

   250

        NODE_PROFILE = 402

   251

        EditorType = CIA402NodeEditor

   252

   253

        ConfNodeMethods = [

   254

            {"bitmap" : "CIA402AxisRef",

   255

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

   256

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

   257

             "method" : "_getCIA402AxisRef",

   258

             "push": True},

   259

        ]

   260

   261

        def GetIconName(self):

   262

            return "CIA402Slave"

   263

   264

        def SetParamsAttribute(self, path, value):

   265

            if path == "CIA402SlaveParams.Type":

   266

                path = "SlaveParams.Type"

   267

            elif path == "CIA402SlaveParams.Alias":

   268

                path = "SlaveParams.Alias"

   269

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   270

   271

        def GetVariableLocationTree(self):

   272

            axis_name = self.CTNName()

   273

            current_location = self.GetCurrentLocation()

   274

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

   275

                         "type": LOCATION_VAR_INPUT,

   276

                         "size": "W",

   277

                         "IEC_type": "AXIS_REF",

   278

                         "var_name": axis_name,

   279

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

   280

                         "description": "",

   281

                         "children": []}]

   282

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

   283

            return  {"name": axis_name,

   284

                     "type": LOCATION_CONFNODE,

   285

                     "location": self.GetFullIEC_Channel(),

   286

                     "children": children,

   287

            }

   288

   289

        def CTNGlobalInstances(self):

   290

            current_location = self.GetCurrentLocation()

   291

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

   292

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

   293

   294

        def _getCIA402AxisRef(self):

   295

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

   296

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

   297

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

   298

            dragSource.SetData(data)

   299

            dragSource.DoDragDrop()

   300

   301

        def CTNGenerate_C(self, buildpath, locations):

   302

            """

   303

            Generate C code

   304

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

   305

            @param locations: List of complete variables locations \

   306

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

   307

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

   308

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

   309

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

   310

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

   311

                }, ...]

   312

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

   313

            """

   314

            current_location = self.GetCurrentLocation()

   315

   316

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

   317

   318

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

   319

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   320

            plc_cia402node_code = plc_cia402node_file.read()

   321

            plc_cia402node_file.close()

   322

   323

            str_completion = {

   324

                "slave_pos": self.GetSlavePos(),

   325

                "location": location_str,

   326

                "MCL_headers": Headers,

   327

                "extern_located_variables_declaration": [],

   328

                "fieldbus_interface_declaration": [],

   329

                "fieldbus_interface_definition": [],

   330

                "entry_variables": [],

   331

                "init_axis_params": [],

   332

                "init_entry_variables": [],

   333

                "extra_variables_retrieve": [],

   334

                "extra_variables_publish": []

   335

            }

   336

   337

            for blocktype_infos in GLOBAL_INSTANCES:

   338

                texts = {

   339

                    "blocktype": blocktype_infos["blocktype"],

   340

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

   341

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

   342

                }

   343

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

   344

   345

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

   346

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

   347

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

   348

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

   349

                          for input in blocktype_infos["inputs"]]

   350

                input_texts = []

   351

                for input_infos in inputs:

   352

                    input_infos.update(texts)

   353

                    input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   354

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

   355

   356

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

   357

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

   358

                output_texts = []

   359

                for output_infos in outputs:

   360

                    output_infos.update(texts)

   361

                    output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   362

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

   363

   364

                str_completion["fieldbus_interface_declaration"].append(

   365

                        BLOCK_FUNCTION_TEMPLATE % texts)

   366

   367

                str_completion["fieldbus_interface_definition"].append(

   368

                        BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   369

   370

            variables = NODE_VARIABLES[:]

   371

   372

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

   373

            for param in params["children"]:

   374

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   375

                    if param["value"]:

   376

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

   377

                        for variable_infos in extra_variables:

   378

                            var_infos = {

   379

                                "location": location_str,

   380

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

   381

                            }

   382

                            variables.append(variable_infos["description"])

   383

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

   384

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

   385

   386

                            if retrieve_template is not None:

   387

                                str_completion["extra_variables_retrieve"].append(

   388

                                    retrieve_template % var_infos)

   389

                            if publish_template is not None:

   390

                                str_completion["extra_variables_publish"].append(

   391

                                    publish_template % var_infos)

   392

                elif param["value"] is not None:

   393

                    param_infos = {

   394

                        "location": location_str,

   395

                        "param_name": param["name"],

   396

                    }

   397

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

   398

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

   399

                    else:

   400

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

   401

                    str_completion["init_axis_params"].append(

   402

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

   403

   404

            for variable in variables:

   405

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

   406

                var_infos["location"] = location_str

   407

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

   408

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

   409

   410

                str_completion["extern_located_variables_declaration"].append(

   411

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

   412

                str_completion["entry_variables"].append(

   413

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

   414

                str_completion["init_entry_variables"].append(

   415

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

   416

   417

                self.CTNParent.FileGenerator.DeclareVariable(

   418

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

   419

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

   420

   421

            for element in ["extern_located_variables_declaration", 

   422

                            "fieldbus_interface_declaration",

   423

                            "fieldbus_interface_definition",

   424

                            "entry_variables", 

   425

                            "init_axis_params", 

   426

                            "init_entry_variables",

   427

                            "extra_variables_retrieve",

   428

                            "extra_variables_publish"]:

   429

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

   430

   431

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

   432

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   433

            cia402nodefile.write(plc_cia402node_code % str_completion)

   434

            cia402nodefile.close()

   435

   436

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

   437

   438

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

   439

#                 Ethercat MASTER

   440

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

   441

   442

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

   443

   444

def ExtractHexDecValue(value):

   445

    try:

   446

        return int(value)

   447

    except:

   448

        pass

   449

    try:

   450

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

   451

    except:

   452

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

   453

   454

def GenerateHexDecValue(value, base=10):

   455

    if base == 10:

   456

        return str(value)

   457

    elif base == 16:

   458

        return "#x%.8x" % value

   459

    else:

   460

        raise ValueError, "Not supported base"

   461

   462

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

   463

if cls:

   464

   465

    def getType(self):

   466

        slave_info = self.getInfo()

   467

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

   468

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

   469

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

   470

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

   471

    setattr(cls, "getType", getType)

   472

   473

    def setType(self, type_infos):

   474

        slave_info = self.getInfo()

   475

        slave_info.setName(type_infos["device_type"])

   476

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

   477

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

   478

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

   479

    setattr(cls, "setType", setType)

   480

   481

class _EthercatCTN:

   482

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

   483

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

   484

      <xsd:element name="EtherlabNode">

   485

        <xsd:complexType>

   486

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

   487

        </xsd:complexType>

   488

      </xsd:element>

   489

    </xsd:schema>

   490

    """

   491