1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from ConfigTreeNode import ConfigTreeNode

     9

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

    10

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

    11

    12

try:

    13

    from MotionLibrary import Headers, AxisXSD

    14

    HAS_MCL = True

    15

except:

    16

    HAS_MCL = False

    17

    18

CONFNODEFOLDER = os.path.split(os.path.realpath(__file__))[0]

    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

#                    Ethercat Node

    62

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

    63

    64

class _EthercatSlaveCTN:

    76

    NODE_PROFILE = None

    77

    EditorType = NodeEditor

    78

    79

    def GetIconPath(self):

    80

        return os.path.join(CONFNODEFOLDER, "images", "Slave.png")

    81

    82

    def ExtractHexDecValue(self, value):

    83

        return ExtractHexDecValue(value)

    84

    85

    def GetSizeOfType(self, type):

    86

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

    87

    88

    def GetSlavePos(self):

    89

        return self.BaseParams.getIEC_Channel()

    90

    91

    def GetParamsAttributes(self, path = None):

    92

        if path:

    93

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

    94

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

    95

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

    96

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

    97

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

    98

        else:

    99

            params = []

   111

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

   114

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

   115

                    'name': 'Type', 

   118

                   {'use': 'optional', 

   119

                    'type': 'unsignedLong', 

   120

                    'name': 'Alias', 

   122

            return params

   123

   124

    def SetParamsAttribute(self, path, value):

   134

        position = self.BaseParams.getIEC_Channel()

   135

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

   136

        # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   137

        if path == "BaseParams.IEC_Channel":

   138

            self.CTNParent.SetSlavePosition(position, value)

   140

        return value, changed

   141

   142

    def GetSlaveInfos(self):

   143

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

   144

   145

    def GetVariableLocationTree(self):

   146

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

   147

                 "type": LOCATION_CONFNODE,

   148

                 "location": self.GetFullIEC_Channel(),

   149

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

   150

        }

   151

   152

    def CTNGenerate_C(self, buildpath, locations):

   153

        """

   154

        Generate C code

   155

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

   156

        @param locations: List of complete variables locations \

   157

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

   158

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

   159

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

   160

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

   161

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

   162

            }, ...]

   163

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

   164

        """

   165

        return [],"",False

   166

   167

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

   168

#                 Ethercat CIA402 Node

   169

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

   170

   171

if HAS_MCL:

   172

   173

    NODE_VARIABLES = [

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

    ]

   181

   182

    class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

   183

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

   184

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

   185

          <xsd:element name="CIA402SlaveParams">

   186

            <xsd:complexType>

   188

              %s

   189

            </xsd:complexType>

   190

          </xsd:element>

   191

        </xsd:schema>

   192

        """ % AxisXSD

   193

   194

        NODE_PROFILE = 402

   195

        EditorType = CIA402NodeEditor

   196

   197

        ConfNodeMethods = [

   199

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

   200

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

   203

        ]

   204

   205

        def GetIconPath(self):

   206

            return os.path.join(CONFNODEFOLDER, "images", "CIA402Slave.png")

   207

   216

            axis_name = self.CTNName()

   232

   233

        def _getCIA402AxisRef(self):

   234

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

   235

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

   236

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

   237

            dragSource.SetData(data)

   238

            dragSource.DoDragDrop()

   239

   240

        def CTNGenerate_C(self, buildpath, locations):

   241

            """

   242

            Generate C code

   243

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

   244

            @param locations: List of complete variables locations \

   245

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

   246

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

   247

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

   248

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

   249

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

   250

                }, ...]

   251

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

   252

            """

   253

            current_location = self.GetCurrentLocation()

   254

   255

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

   256

   257

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

   258

            plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   259

            plc_cia402node_code = plc_cia402node_file.read()

   260

            plc_cia402node_file.close()

   261

   262

            str_completion = {

   263

                "location": location_str,

   264

                "MCL_headers": Headers,

   265

                "extern_located_variables_declaration": [],

   266

                "entry_variables": [],

   267

                "init_axis_params": [],

   268

                "init_entry_variables": [],

   269

            }

   270

   271

            for variable in NODE_VARIABLES:

   272

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

   273

                var_infos["location"] = location_str

   274

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

   275

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

   276

   277

                str_completion["extern_located_variables_declaration"].append(

   278

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

   279

                str_completion["entry_variables"].append(

   280

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

   281

                str_completion["init_entry_variables"].append(

   282

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

   283

   284

                self.CTNParent.FileGenerator.DeclareVariable(

   285

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

   286

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

   287

   288

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

   289

            for param in params["children"]:

   290

                if param["value"] is not None:

   291

                    param_infos = {

   292

                        "location": location_str,

   293

                        "param_name": param["name"],

   294

                    }

   295

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

   296

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

   297

                    else:

   298

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

   299

                    str_completion["init_axis_params"].append(

   300

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

   301

   302

            for element in ["extern_located_variables_declaration", 

   303

                            "entry_variables", 

   304

                            "init_axis_params", 

   305

                            "init_entry_variables"]:

   306

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

   307

   308

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

   309

            cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   310

            cia402nodefile.write(plc_cia402node_code % str_completion)

   311

            cia402nodefile.close()

   312

   313

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

   314

   315

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

   316

#                 Ethercat MASTER

   317

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

   318

   319

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

   320

   321

def ExtractHexDecValue(value):

   322

    try:

   323

        return int(value)

   324

    except:

   325

        pass

   326

    try:

   327

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

   328

    except:

   329

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

   330

   331

def GenerateHexDecValue(value, base=10):

   332

    if base == 10:

   333

        return str(value)

   334

    elif base == 16:

   335

        return "#x%.8x" % value

   336

    else:

   337

        raise ValueError, "Not supported base"

   338

   339

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

   340

if cls:

   341

   342

    def getType(self):

   343

        slave_info = self.getInfo()

   344

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

   345

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

   346

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

   347

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

   348

    setattr(cls, "getType", getType)

   349

   350

    def setType(self, type_infos):

   351

        slave_info = self.getInfo()

   352

        slave_info.setName(type_infos["device_type"])

   353

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

   354

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

   355

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

   356

    setattr(cls, "setType", setType)

   357

   358

class _EthercatCTN:

   359

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

   360

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

   361

      <xsd:element name="EtherlabNode">

   362

        <xsd:complexType>

   363

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

   364

          <xsd:attribute name="ConfigurePDOs" type="xsd:boolean" use="optional" default="true"/>

   365

        </xsd:complexType>

   366

      </xsd:element>

   367

    </xsd:schema>

   368

    """

   369

   370

    CTNChildrenTypes = [("EthercatSlave", _EthercatSlaveCTN, "Ethercat Slave")]

   371

    if HAS_MCL:

   372

        CTNChildrenTypes.append(("EthercatCIA402Slave", _EthercatCIA402SlaveCTN, "Ethercat CIA402 Slave"))

   373

   374

    def __init__(self):

   375

        filepath = self.ConfigFileName()

   376

   377

        self.Config = EtherCATConfigClasses["EtherCATConfig"]()

   378

        if os.path.isfile(filepath):

   379

            xmlfile = open(filepath, 'r')

   380

            tree = minidom.parse(xmlfile)

   381

            xmlfile.close()

   382

   383

            for child in tree.childNodes:

   384

                if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "EtherCATConfig":

   385

                    self.Config.loadXMLTree(child)

   386

                    self.CreateConfigBuffer(True)

   387

        else:

   388

            self.CreateConfigBuffer(False)

   389

            self.OnCTNSave()

   390

   391

    def ExtractHexDecValue(self, value):

   392

        return ExtractHexDecValue(value)

   393

   394

    def GetSizeOfType(self, type):

   395

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

   396

   397

    def ConfigFileName(self):

   398

        return os.path.join(self.CTNPath(), "config.xml")

   399

   400

    def GetSlaves(self):

   401

        slaves = []

   402

        for slave in self.Config.getConfig().getSlave():

   403

            slaves.append(slave.getInfo().getPhysAddr())

   404

        slaves.sort()

   405

        return slaves

   406

   407

    def GetSlave(self, slave_pos):

   408

        for slave in self.Config.getConfig().getSlave():

   409

            slave_info = slave.getInfo()

   410

            if slave_info.getPhysAddr() == slave_pos:

   411

                return slave

   412

        return None

   413

   414

    def _ScanNetwork(self):

   415

        app_frame = self.GetCTRoot().AppFrame

   416

   417

        execute = True

   418

        if len(self.Children) > 0:

   419

            dialog = wx.MessageDialog(app_frame, 

   420

                _("The current network configuration will be deleted.\nDo you want to continue?"), 

   421

                _("Scan Network"), 

   422

                wx.YES_NO|wx.ICON_QUESTION)

   423

            execute = dialog.ShowModal() == wx.ID_YES

   424

            dialog.Destroy()

   425

   426

        if execute:

   427

            error, returnVal = self.RemoteExec(SCAN_COMMAND, returnVal = None)

   428

            if error != 0:

   429

                dialog = wx.MessageDialog(app_frame, returnVal, "Error", wx.OK|wx.ICON_ERROR)

   430

                dialog.ShowModal()

   431

                dialog.Destroy()

   432

            elif returnVal is not None:

   433

                for child in self.IECSortedChildren():

   434

                    self._doRemoveChild(child)

   435

   436

                for slave in returnVal:

   437

                    type_infos = {

   438

                        "vendor": slave["vendor_id"],

   439

                        "product_code": slave["product_code"],

   440

                        "revision_number":slave["revision_number"],

   441

                    }

   442

                    device = self.GetModuleInfos(type_infos)

   443

                    if device is not None:

   444

                        if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

   445

                            CTNType = "EthercatCIA402Slave"

   446

                        else:

   447

                            CTNType = "EthercatSlave"

   448

                        self.CTNAddChild("slave%s" % slave["idx"], CTNType, slave["idx"])

   449

                        self.SetSlaveAlias(slave["idx"], slave["alias"])

   450

                        type_infos["device_type"] = device.getType().getcontent()

   451

                        self.SetSlaveType(slave["idx"], type_infos)

   452

   453

    def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   454

        """

   455

        Create the confnodes that may be added as child to this node self

   456

        @param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)

   457

        @param CTNName: string for the name of the confnode instance

   458

        """

   459

        newConfNodeOpj = ConfigTreeNode.CTNAddChild(self, CTNName, CTNType, IEC_Channel)

   460

   461

        slave = self.GetSlave(newConfNodeOpj.BaseParams.getIEC_Channel())

   462

        if slave is None:

   463

            slave = EtherCATConfigClasses["Config_Slave"]()

   464

            slave_infos = slave.getInfo()

   465

            slave_infos.setName("undefined")

   466

            slave_infos.setPhysAddr(newConfNodeOpj.BaseParams.getIEC_Channel())

   467

            slave_infos.setAutoIncAddr(0)

   468

            self.Config.getConfig().appendSlave(slave)

   469

            self.BufferConfig()

   470

            self.OnCTNSave()

   471

   472

        return newConfNodeOpj

   473

   474

    def _doRemoveChild(self, CTNInstance):

   475

        slave_pos = CTNInstance.GetSlavePos()

   476

        config = self.Config.getConfig()

   477

        for idx, slave in enumerate(config.getSlave()):

   478

            slave_infos = slave.getInfo()

   479

            if slave_infos.getPhysAddr() == slave_pos:

   480

                config.removeSlave(idx)

   481

                self.BufferConfig()

   482

                self.OnCTNSave()

   483

        ConfigTreeNode._doRemoveChild(self, CTNInstance)

   484

   485

    def SetSlavePosition(self, slave_pos, new_pos):

   486

        slave = self.GetSlave(slave_pos)

   487

        if slave is not None:

   488

            slave_info = slave.getInfo()

   489

            slave_info.setPhysAddr(new_pos)

   490

            self.BufferConfig()

   491

   492

    def GetSlaveAlias(self, slave_pos):

   493

        slave = self.GetSlave(slave_pos)