1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

from plugger import PlugTemplate

     9

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

    10

from ConfigEditor import ConfigEditor, DS402NodeEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    11

    12

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

    13

#                 Ethercat DS402 Node

    14

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

    15

    16

NODE_VARIABLES = [

    17

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

    18

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

    19

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

    20

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

    21

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

    22

    ("ErrorCode", 0x603f, 0x00, "UINT", "I"),

    23

]

    24

    25

class _EthercatDS402SlavePlug:

    26

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

    27

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

    28

      <xsd:element name="EtherlabDS402Slave">

    29

        <xsd:complexType>

    30

          <xsd:attribute name="Node_Type" type="xsd:string" use="optional"/>

    31

        </xsd:complexType>

    32

      </xsd:element>

    33

    </xsd:schema>

    34

    """

    35

    EditorType = DS402NodeEditor

    36

    37

    def ExtractHexDecValue(self, value):

    38

        return ExtractHexDecValue(value)

    39

    40

    def GetSizeOfType(self, type):

    41

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

    42

    43

    def _GetChildBySomething(self, something, toks):

    44

        return self

    45

    46

    def GetParamsAttributes(self, path = None):

    47

        infos = PlugTemplate.GetParamsAttributes(self, path = None)

    48

        for element in infos:

    49

            if element["name"] == "EtherlabDS402Slave":

    50

                for child in element["children"]:

    51

                    if child["name"] == "Node_Type":

    52

                        child["type"] = [module[0] for module in self.PlugParent.GetModulesByProfile(402)]

    53

        return infos

    54

    55

    def GetAllChannels(self):

    56

        AllChannels = PlugTemplate.GetAllChannels(self)

    57

        for slave_pos in self.PlugParent.GetSlaves():

    58

            if slave_pos[0] not in AllChannels:

    59

                AllChannels.append(slave_pos[0])

    60

        AllChannels.sort()

    61

        return AllChannels

    62

    63

    def GetCurrentLocation(self):

    64

        """

    65

        @return:  Tupple containing plugin IEC location of current plugin : %I0.0.4.5 => (0,0,4,5)

    66

        """

    67

        return self.PlugParent.GetCurrentLocation() + self.GetSlavePos()

    68

    69

    def GetSlavePos(self):

    70

        return self.BaseParams.getIEC_Channel(), 0

    71

    72

    def GetSlaveTypeInfos(self):

    73

        slave_type = self.EtherlabDS402Slave.getNode_Type()

    74

    75

        for module_type, vendor_id, product_code, revision_number in self.PlugParent.GetModulesByProfile(402):

    76

            if module_type == slave_type:

    77

                return {"device_type": module_type,

    78

                        "vendor": GenerateHexDecValue(vendor_id),

    79

                        "product_code": GenerateHexDecValue(product_code, 16),

    80

                        "revision_number": GenerateHexDecValue(revision_number, 16)}

    81

    82

        return None

    83

    84

    def GetSlaveInfos(self):

    85

        slave_typeinfos = self.GetSlaveTypeInfos()

    86

        if slave_typeinfos is not None:

    87

            device = self.PlugParent.GetModuleInfos(slave_typeinfos)

    88

            if device is not None:

    89

                infos = slave_typeinfos.copy()

    90

                entries = device.GetEntriesList()

    91

                entries_list = entries.items()

    92

                entries_list.sort()

    93

                entries = []

    94

                current_index = None

    95

                current_entry = None

    96

                for (index, subindex), entry in entries_list:

    97

                    entry["children"] = []

    98

                    if index != current_index:

    99

                        current_index = index

   100

                        current_entry = entry

   101

                        entries.append(entry)

   102

                    elif current_entry is not None:

   103

                        current_entry["children"].append(entry)

   104

                    else:

   105

                        entries.append(entry)

   106

                infos.update({"physics": device.getPhysics(),

   107

                              "sync_managers": device.GetSyncManagers(),

   108

                              "entries": entries})

   109

                return infos

   110

        return None

   111

   112

    def GetVariableLocationTree(self):

   113

        slave_typeinfos = self.GetSlaveTypeInfos()

   114

        vars = []

   115

        if slave_typeinfos is not None:

   116

            vars = self.PlugParent.GetDeviceLocationTree(self.GetCurrentLocation(), slave_typeinfos) 

   117

   118

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

   119

                 "type": LOCATION_PLUGIN,

   120

                 "location": self.GetFullIEC_Channel(),

   121

                 "children": vars}

   122

   123

    PluginMethods = [

   124

        {"bitmap" : os.path.join("images", "EditCfile"),

   125

         "name" : _("Edit Node"), 

   126

         "tooltip" : _("Edit Node"),

   127

         "method" : "_OpenView"},

   128

    ]

   129

   130

   131

    def PlugGenerate_C(self, buildpath, locations):

   132

        """

   133

        Generate C code

   134

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

   135

        @param locations: List of complete variables locations \

   136

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

   137

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

   138

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

   139

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

   140

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

   141

            }, ...]

   142

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

   143

        """

   144

        current_location = self.GetCurrentLocation()

   145

   146

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

   147

   148

        slave_pos = current_location[-2:]

   149

   150

        slave_typeinfos = self.GetSlaveTypeInfos()

   151

        device = None

   152

        if slave_typeinfos is not None:

   153

            device = self.PlugParent.GetModuleInfos(slave_typeinfos)

   154

   155

        if device is None:

   156

            raise (ValueError, 

   157

                   _("No information found for DS402 node \"%s\" at location %s!") % (

   158

                      slave_typeinfos["device_type"], ".".join(current_location)))

   159

   160

        self.PlugParent.FileGenerator.DeclareSlave(slave_pos, slave_typeinfos)

   161

   162

        plc_ds402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_ds402node.c")

   163

        plc_ds402node_file = open(plc_ds402node_filepath, 'r')

   164

        plc_ds402node_code = plc_ds402node_file.read()

   165

        plc_ds402node_file.close()

   166

   167

        from plugins.motion import Headers

   168

   169

        str_completion = {

   170

            "location": location_str,

   171

            "MCL_headers": Headers,

   172

            "extern_located_variables_declaration": [],

   173

            "entry_variables": [],

   174

            "init_entry_variables": [],

   175

        }

   176

   177

        for variable in NODE_VARIABLES:

   178

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

   179

            var_infos["location"] = location_str

   180

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

   181

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

   182

   183

            str_completion["extern_located_variables_declaration"].append(

   184

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

   185

            str_completion["entry_variables"].append(

   186

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

   187

            str_completion["init_entry_variables"].append(

   188

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

   189

   190

            self.PlugParent.FileGenerator.DeclareVariable(

   191

                    slave_pos, var_infos["index"], var_infos["subindex"], 

   192

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

   193

   194

        for element in ["extern_located_variables_declaration", 

   195

                        "entry_variables", 

   196

                        "init_entry_variables"]:

   197

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

   198

   199

        Gen_DS402Nodefile_path = os.path.join(buildpath, "ds402node_%s.c"%location_str)

   200

        ds402nodefile = open(Gen_DS402Nodefile_path, 'w')

   201

        ds402nodefile.write(plc_ds402node_code % str_completion)

   202

        ds402nodefile.close()

   203

   204

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

   205

   206

   207

   208

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

   209

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

   210

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

   211

   212

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

   213

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

   214

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

   215

   216

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

   217

   218

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

   219

#                 Ethercat MASTER

   220

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

   221

   222

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

   223

   224

def ExtractHexDecValue(value):

   225

    try:

   226

        return int(value)

   227

    except:

   228

        pass

   229

    try:

   230

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

   231

    except:

   232

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

   233

   234

def GenerateHexDecValue(value, base=10):

   235

    if base == 10:

   236

        return str(value)

   237

    elif base == 16:

   238

        return "#x%.8x" % value

   239

    else:

   240

        raise ValueError, "Not supported base"

   241

   242

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

   243

if cls:

   244

   245

    def getType(self):

   246

        slave_info = self.getInfo()

   247

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

   248

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

   249

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

   250

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

   251

    setattr(cls, "getType", getType)

   252

   253

    def setType(self, type_infos):

   254

        slave_info = self.getInfo()

   255

        slave_info.setName(type_infos["device_type"])

   256

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

   257

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

   258

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

   259

    setattr(cls, "setType", setType)

   260

   261

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

   262

if cls:

   263

   264

    def getSlavePosition(self):

   265

        return self.getPhysAddr(), self.getAutoIncAddr()

   266

    setattr(cls, "getSlavePosition", getSlavePosition)

   267

   268

    def setSlavePosition(self, alias, pos):

   269

        self.setPhysAddr(alias)

   270

        self.setAutoIncAddr(pos)

   271

    setattr(cls, "setSlavePosition", setSlavePosition)

   272

   273

class _EthercatPlug:

   274

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

   275

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

   276

      <xsd:element name="EtherlabNode">

   277

        <xsd:complexType>

   278

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

   279

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

   280

        </xsd:complexType>

   281

      </xsd:element>

   282

    </xsd:schema>

   283

    """

   284

    EditorType = ConfigEditor

   285

   286

    PlugChildsTypes = [("EthercatDS402Slave", _EthercatDS402SlavePlug, "Ethercat DS402 Slave")]

   287

   288

    def __init__(self):

   289

        filepath = self.ConfigFileName()

   290

   291

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

   292

        if os.path.isfile(filepath):

   293

            xmlfile = open(filepath, 'r')

   294

            tree = minidom.parse(xmlfile)

   295

            xmlfile.close()

   296

   297

            for child in tree.childNodes:

   298

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

   299

                    self.Config.loadXMLTree(child, ["xmlns:xsi", "xsi:noNamespaceSchemaLocation"])

   300

                    self.CreateConfigBuffer(True)

   301

        else:

   302

            self.CreateConfigBuffer(False)

   303

            self.OnPlugSave()

   304

   305

    def ExtractHexDecValue(self, value):

   306

        return ExtractHexDecValue(value)

   307

   308

    def GetSizeOfType(self, type):

   309

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

   310

   311

    def ConfigFileName(self):

   312

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

   313

   314

    def GetSlaves(self):

   315

        slaves = []

   316

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

   317

            slaves.append(slave.getInfo().getSlavePosition())

   318

        slaves.sort()

   319

        return slaves

   320

   321

    def GetSlave(self, slave_pos):

   322

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

   323

            slave_info = slave.getInfo()

   324

            if slave_info.getSlavePosition() == slave_pos:

   325

                return slave

   326

        return None

   327

   328

    def AddSlave(self):

   329

        slaves = self.GetSlaves()

   330

        for PlugInstance in self.IterChilds():

   331

            slaves.append(PlugInstance.GetSlavePos())

   332

        slaves.sort()

   333

        if len(slaves) > 0:

   334

            new_pos = (slaves[-1][0] + 1, 0)

   335

        else:

   336

            new_pos = (0, 0)

   337

        slave = EtherCATConfigClasses["Config_Slave"]()

   338

        slave_infos = slave.getInfo()

   339

        slave_infos.setName("undefined")

   340

        slave_infos.setSlavePosition(new_pos[0], new_pos[1])

   341

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

   342

        self.BufferConfig()

   343

        return new_pos

   344

   345

    def RemoveSlave(self, slave_pos):

   346

        config = self.Config.getConfig()

   347

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

   348

            slave_infos = slave.getInfo()

   349

            if slave_infos.getSlavePosition() == slave_pos:

   350

                config.removeSlave(idx)

   351

                self.BufferConfig()

   352

                return True

   353

        return False

   354

   355

    def SetSlavePos(self, slave_pos, alias=None, position=None):

   356

        for PlugInstance in self.IterChilds():

   357

            if PlugInstance.BaseParams.getIEC_Channel() == alias:

   358

                return _("Slave with alias \"%d\" already exists!" % alias)

   359

        slave = self.GetSlave(slave_pos)

   360

        if slave is not None:

   361

            slave_info = slave.getInfo()

   362

            new_pos = slave_pos

   363

            if alias is not None:

   364

                new_pos = (alias, new_pos[1])

   365

            if position is not None:

   366

                new_pos = (new_pos[0], position)

   367

            if self.GetSlave(new_pos) is not None:

   368

                return _("Slave with position \"%d:%d\" already exists!" % new_pos)

   369

            slave_info.setSlavePosition(*new_pos)

   370

            self.BufferConfig()

   371

        return None

   372

   373

    def GetSlaveType(self, slave_pos):

   374

        slave = self.GetSlave(slave_pos)

   375

        if slave is not None:

   376

            return slave.getType()

   377

        return None

   378

   379

    def SetSlaveType(self, slave_pos, type_infos):

   380

        slave = self.GetSlave(slave_pos)

   381

        if slave is not None:

   382

            slave.setType(type_infos)

   383

            self.BufferConfig()

   384

        return None

   385

   386

    def GetSlaveInfos(self, slave_pos):

   387

        slave = self.GetSlave(slave_pos)

   388

        if slave is not None:

   389

            type_infos = slave.getType()

   390

            device = self.GetModuleInfos(type_infos)

   391

            if device is not None:

   392

                infos = type_infos.copy()

   393

                entries = device.GetEntriesList()

   394

                entries_list = entries.items()

   395

                entries_list.sort()

   396

                entries = []

   397

                current_index = None

   398

                current_entry = None

   399

                for (index, subindex), entry in entries_list:

   400

                    entry["children"] = []

   401

                    if index != current_index:

   402

                        current_index = index

   403

                        current_entry = entry

   404

                        entries.append(entry)

   405

                    elif current_entry is not None:

   406

                        current_entry["children"].append(entry)

   407

                    else:

   408

                        entries.append(entry)

   409

                infos.update({"physics": device.getPhysics(),

   410

                              "sync_managers": device.GetSyncManagers(),

   411

                              "entries": entries})

   412

                return infos

   413

        return None

   414

   415

    def GetModuleInfos(self, type_infos):

   416

        return self.PlugParent.GetModuleInfos(type_infos)

   417

   418

    def GetModulesByProfile(self, profile_type):

   419

        return self.PlugParent.GetModulesByProfile(profile_type)

   420

   421

    def GetSlaveTypesLibrary(self):

   422

        return self.PlugParent.GetModulesLibrary()

   423

   424

    def GetDeviceLocationTree(self, current_location, type_infos):

   425

        vars = []

   426

   427

        device = self.GetModuleInfos(type_infos)

   428

        if device is not None:

   429

            sync_managers = []

   430

            for sync_manager in device.getSm():

   431

                sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   432

                sync_manager_direction = sync_manager_control_byte & 0x0c

   433

                if sync_manager_direction:

   434

                    sync_managers.append(LOCATION_VAR_OUTPUT)

   435

                else:

   436

                    sync_managers.append(LOCATION_VAR_INPUT)

   437

   438

            entries = device.GetEntriesList().items()

   439

            entries.sort()

   440

            for (index, subindex), entry in entries:

   441

                var_size = self.GetSizeOfType(entry["Type"])

   442

                if var_size is not None:

   443

                    var_class = VARCLASSCONVERSION.get(entry["PDOMapping"], None)

   444

                    if var_class is not None:

   445

                        if var_class == LOCATION_VAR_INPUT:

   446

                            var_dir = "%I"

   447

                        else:

   448

                            var_dir = "%Q"    

   449

   450

                        vars.append({"name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry["Name"]),

   451

                                     "type": var_class,

   452

                                     "size": var_size,

   453

                                     "IEC_type": entry["Type"],

   454

                                     "var_name": "%s_%4.4x_%2.2x" % ("_".join(type_infos["device_type"].split()), index, subindex),

   455

                                     "location": "%s%s%s"%(var_dir, var_size, ".".join(map(str, current_location + 

   456

                                                                                                (index, subindex)))),

   457

                                     "description": "",

   458

                                     "children": []})

   459

   460

        return vars

   461

   462

    def GetVariableLocationTree(self):

   463

        '''See PlugTemplate.GetVariableLocationTree() for a description.'''

   464

   465

        current_location = self.GetCurrentLocation()

   466

   467

        groups = []

   468

        for slave_pos in self.GetSlaves():

   469

   470

            slave = self.GetSlave(slave_pos)

   471

            if slave is not None:

   472

                type_infos = slave.getType()

   473

   474

                vars = self.GetDeviceLocationTree(current_location + slave_pos, type_infos)

   475

                if len(vars) > 0:

   476

                    groups.append({"name": "%s (%d,%d)" % ((type_infos["device_type"],) + slave_pos),

   477

                                   "type": LOCATION_GROUP,

   478

                                   "location": ".".join(map(str, current_location + slave_pos)) + ".x",

   479

                                   "children": vars})

   480

   481

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

   482

                 "type": LOCATION_PLUGIN,

   483

                 "location": self.GetFullIEC_Channel(),

   484

                 "children": groups}

   485

   486

    PluginMethods = [

   487

        {"bitmap" : os.path.join("images", "EditCfile"),

   488

         "name" : _("Edit Config"), 

   489

         "tooltip" : _("Edit Config"),

   490

         "method" : "_OpenView"},

   491

    ]

   492

   493

    def PlugTestModified(self):

   494

        return self.ChangesToSave or not self.ConfigIsSaved()    

   495

   496

    def OnPlugSave(self):

   497

        filepath = self.ConfigFileName()

   498

   499

        text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"

   500

        extras = {"xmlns:xsi":"http://www.w3.org/2001/XMLSchema-instance",

   501

                  "xsi:noNamespaceSchemaLocation" : "EtherCATInfo.xsd"}

   502

        text += self.Config.generateXMLText("EtherCATConfig", 0, extras)

   503

   504

        xmlfile = open(filepath,"w")

   505