1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     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

    13

    14

try:

    15

    from MotionLibrary import Headers, AxisXSD

    16

    HAS_MCL = True

    17

except:

    18

    HAS_MCL = False

    19

    20

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

    21

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

    22

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

    23

    24

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

    25

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

    26

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

    27

    28

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

    29

    30

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

    31

#         Remote Exec Etherlab Commands

    32

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

    33

    34

SCAN_COMMAND = """

    35

import commands

    36

result = commands.getoutput("ethercat slaves")

    37

slaves = []

    38

for slave_line in result.splitlines():

    39

    chunks = slave_line.split()

    40

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

    41

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

    42

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

    43

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

    44

             "alias": int(alias),

    45

             "position": int(position),

    46

             "name": name}

    47

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

    48

    for details_line in details.splitlines():

    49

        details_line = details_line.strip()

    50

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

    51

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

    52

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

    53

            if details_line.startswith(header):

    54

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

    55

                break

    56

    slaves.append(slave)

    57

returnVal = slaves

    58

"""

    59

    60

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

    61

#      Etherlab Specific Blocks Library

    62

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

    63

    64

def GetLocalPath(filename):

    65

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

    66

    67

class EtherlabLibrary(POULibrary):

    68

    def GetLibraryPath(self):

    69

        return GetLocalPath("pous.xml")

    70

    71

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

    72

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

    73

        etherlab_ext_code = etherlab_ext_file.read()

    74

        etherlab_ext_file.close()

    75

    76

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

    77

        ethelabfile = open(Gen_etherlabfile_path,'w')

    78

        ethelabfile.write(etherlab_ext_code)

    79

        ethelabfile.close()

    80

    81

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

    82

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

    83

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

    84

    85

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

    86

#                    Ethercat Node

    87

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

    88

    89

class _EthercatSlaveCTN:

    90

    91

    NODE_PROFILE = None

    92

    EditorType = NodeEditor

    93

    94

    def GetIconName(self):

    95

        return "Slave"

    96

    97

    def ExtractHexDecValue(self, value):

    98

        return ExtractHexDecValue(value)

    99

   100

    def GetSizeOfType(self, type):

   101

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

   102

   103

    def GetSlavePos(self):

   104

        return self.BaseParams.getIEC_Channel()

   105

   106

    def GetParamsAttributes(self, path = None):

   107

        if path:

   108

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

   109

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

   110

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

   111

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

   112

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

   113

        else:

   114

            params = []

   115

            if self.CTNParams:

   116

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

   117

            else:

   118

                params.append({

   119

                    'use': 'required', 

   120

                    'type': 'element', 

   121

                    'name': 'SlaveParams', 

   122

                    'value': None, 

   123

                    'children': []

   124

                })

   125

   126

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

   127

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

   128

                   {'use': 'optional', 

   129

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

   130

                    'name': 'Type', 

   131

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

   132

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

   133

                   {'use': 'optional', 

   134

                    'type': 'unsignedLong', 

   135

                    'name': 'Alias', 

   136

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

   137

            return params

   138

   139

    def SetParamsAttribute(self, path, value):

   140

        position = self.BaseParams.getIEC_Channel()

   141

   142

        if path == "SlaveParams.Type":

   143

            self.CTNParent.SetSlaveType(position, value)

   144

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

   145

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

   146

            if self._View is not None:

   147

                wx.CallAfter(self._View.RefreshSlaveInfos)

   148

            return value, True

   149

        elif path == "SlaveParams.Alias":

   150

            self.CTNParent.SetSlaveAlias(position, value)

   151

            return value, True

   152

   153

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

   154

   155

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   156

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

   157

            self.CTNParent.SetSlavePosition(position, value)

   158

   159

        return value, refresh

   160

   161

    def GetSlaveInfos(self):

   162

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

   163

   164

    def GetVariableLocationTree(self):

   165

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

   166

                 "type": LOCATION_CONFNODE,

   167

                 "location": self.GetFullIEC_Channel(),

   168

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

   169

        }

   170

   171

    def CTNGenerate_C(self, buildpath, locations):

   172

        """

   173

        Generate C code

   174

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

   175

        @param locations: List of complete variables locations \

   176

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

   177

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

   178

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

   179

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

   180

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

   181

            }, ...]

   182

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

   183

        """

   184

        return [],"",False

   185

   186

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

   187

#                 Ethercat CIA402 Node

   188

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

   189

   190

if HAS_MCL:

   191

   192

    NODE_VARIABLES = [

   193

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

   194

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

   195

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

   196

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

   197

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

   198

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

   199

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

   200

    ]

   201

   202

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

   203

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

   204

   205

    EXTRA_NODE_VARIABLES = [

   206

        ("ErrorCode", [

   207

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

   208

             "publish": None}

   209

            ]),

   210

        ("DigitalInputs", [

   211

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

   212

             "publish": None}

   213

            ]),

   214

        ("DigitalOutputs", [

   215

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

   216

             "retrieve": None}

   217

            ])

   218

    ]

   219

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

   220

   221

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

   222

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

   223

   224

    BLOCK_FUNCTION_TEMPLATE = """

   225

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

   226

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

   227

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

   228

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

   229

%(extract_inputs)s

   230

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

   231

%(return_outputs)s

   232

}

   233

"""

   234

   235

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

   236

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

   237

   238

    GLOBAL_INSTANCES = [

   239

        {"blocktype": "GetTorqueLimit", 

   240

         "inputs": [],

   241

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

   242

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

   243

        {"blocktype": "SetTorqueLimit", 

   244

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

   245

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

   246

         "outputs": []},

   247

    ]

   248

   249

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   250

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

   251

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

   252

          <xsd:element name="CIA402SlaveParams">

   253

            <xsd:complexType>

   254

              %s

   255

            </xsd:complexType>

   256

          </xsd:element>

   257

        </xsd:schema>

   258

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

   259

                          for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   260

   261

        NODE_PROFILE = 402

   262

        EditorType = CIA402NodeEditor

   263

   264

        ConfNodeMethods = [

   265

            {"bitmap" : "CIA402AxisRef",

   266

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

   267

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

   268

             "method" : "_getCIA402AxisRef",

   269

             "push": True},

   270

        ]

   271

   272

        def GetIconName(self):

   273

            return "CIA402Slave"

   274

   275

        def SetParamsAttribute(self, path, value):

   276

            if path == "CIA402SlaveParams.Type":

   277

                path = "SlaveParams.Type"

   278

            elif path == "CIA402SlaveParams.Alias":

   279

                path = "SlaveParams.Alias"

   280

            return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   281

   282

        def GetVariableLocationTree(self):

   283

            axis_name = self.CTNName()

   284

            current_location = self.GetCurrentLocation()

   285

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

   286

                         "type": LOCATION_VAR_INPUT,

   287

                         "size": "W",

   288

                         "IEC_type": "AXIS_REF",

   289

                         "var_name": axis_name,

   290

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

   291

                         "description": "",

   292

                         "children": []}]

   293

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

   294

            return  {"name": axis_name,

   295

                     "type": LOCATION_CONFNODE,

   296

                     "location": self.GetFullIEC_Channel(),

   297

                     "children": children,

   298

            }

   299

   300

        def CTNGlobalInstances(self):

   301

            current_location = self.GetCurrentLocation()

   302

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

   303

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

   304

   305

        def _getCIA402AxisRef(self):

   306

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

   307

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

   308

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

   309

            dragSource.SetData(data)

   310

            dragSource.DoDragDrop()

   311

   312

        def CTNGenerate_C(self, buildpath, locations):

   313

            """

   314

            Generate C code

   315

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

   316

            @param locations: List of complete variables locations \

   317

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

   318

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

   319

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

   320

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

   321

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

   322

                }, ...]

   323

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

   324

            """

   325

            current_location = self.GetCurrentLocation()

   326

   327

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

   328

   329

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

   330

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   331

            plc_cia402node_code = plc_cia402node_file.read()

   332

            plc_cia402node_file.close()

   333

   334

            str_completion = {

   335

                "slave_pos": self.GetSlavePos(),

   336

                "location": location_str,

   337

                "MCL_headers": Headers,

   338

                "extern_located_variables_declaration": [],

   339

                "fieldbus_interface_declaration": [],

   340

                "fieldbus_interface_definition": [],

   341

                "entry_variables": [],

   342

                "init_axis_params": [],

   343

                "init_entry_variables": [],

   344

                "extra_variables_retrieve": [],

   345

                "extra_variables_publish": []

   346

            }

   347

   348

            for blocktype_infos in GLOBAL_INSTANCES:

   349

                texts = {

   350

                    "blocktype": blocktype_infos["blocktype"],

   351

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

   352

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

   353

                }

   354

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

   355

   356

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

   357

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

   358

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

   359

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

   360

                          for input in blocktype_infos["inputs"]]

   361

                input_texts = []

   362

                for input_infos in inputs:

   363

                    input_infos.update(texts)

   364

                    input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   365

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

   366

   367

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

   368

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

   369

                output_texts = []

   370

                for output_infos in outputs:

   371

                    output_infos.update(texts)

   372

                    output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   373

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

   374

   375

                str_completion["fieldbus_interface_declaration"].append(

   376

                        BLOCK_FUNCTION_TEMPLATE % texts)

   377

   378

                str_completion["fieldbus_interface_definition"].append(

   379

                        BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   380

   381

            variables = NODE_VARIABLES[:]

   382

   383

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

   384

            for param in params["children"]:

   385

                if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   386

                    if param["value"]:

   387

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

   388

                        for variable_infos in extra_variables:

   389

                            var_infos = {

   390

                                "location": location_str,

   391

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

   392

                            }

   393

                            variables.append(variable_infos["description"])

   394

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

   395

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

   396

   397

                            if retrieve_template is not None:

   398

                                str_completion["extra_variables_retrieve"].append(

   399

                                    retrieve_template % var_infos)

   400

                            if publish_template is not None:

   401

                                str_completion["extra_variables_publish"].append(

   402

                                    publish_template % var_infos)

   403

                elif param["value"] is not None:

   404

                    param_infos = {

   405

                        "location": location_str,

   406

                        "param_name": param["name"],

   407

                    }

   408

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

   409

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

   410

                    else:

   411

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

   412

                    str_completion["init_axis_params"].append(

   413

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

   414

   415

            for variable in variables:

   416

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

   417

                var_infos["location"] = location_str

   418

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

   419

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

   420

   421

                str_completion["extern_located_variables_declaration"].append(

   422

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

   423

                str_completion["entry_variables"].append(

   424

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

   425

                str_completion["init_entry_variables"].append(

   426

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

   427

   428

                self.CTNParent.FileGenerator.DeclareVariable(

   429

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

   430

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

   431

   432

            for element in ["extern_located_variables_declaration", 

   433

                            "fieldbus_interface_declaration",

   434

                            "fieldbus_interface_definition",

   435

                            "entry_variables", 

   436

                            "init_axis_params", 

   437

                            "init_entry_variables",

   438

                            "extra_variables_retrieve",

   439

                            "extra_variables_publish"]:

   440

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

   441

   442

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

   443

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   444

            cia402nodefile.write(plc_cia402node_code % str_completion)

   445

            cia402nodefile.close()

   446

   447

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

   448

   449

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

   450

#                 Ethercat MASTER

   451

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

   452

   453

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

   454

   455

def ExtractHexDecValue(value):

   456

    try:

   457

        return int(value)

   458

    except:

   459

        pass

   460

    try:

   461

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

   462

    except:

   463

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

   464

   465

def GenerateHexDecValue(value, base=10):

   466

    if base == 10:

   467

        return str(value)

   468

    elif base == 16:

   469

        return "#x%.8x" % value

   470

    else:

   471

        raise ValueError, "Not supported base"

   472

   473

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

   474

if cls:

   475

   476

    def getType(self):

   477

        slave_info = self.getInfo()

   478

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

   479

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

   480

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

   481

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

   482

    setattr(cls, "getType", getType)

   483

   484

    def setType(self, type_infos):

   485

        slave_info = self.getInfo()

   486

        slave_info.setName(type_infos["device_type"])

   487

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

   488

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

   489

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

   490

    setattr(cls, "setType", setType)