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.BaseParams.getIEC_Channel(), 0)

    68

    69

    def GetSlaveTypeInfos(self):

    70

        slave_type = self.EtherlabDS402Slave.getNode_Type()

    71

    72

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

    73

            if module_type == slave_type:

    74

                return {"device_type": module_type,

    75

                        "vendor": GenerateHexDecValue(vendor_id),

    76

                        "product_code": GenerateHexDecValue(product_code, 16),

    77

                        "revision_number": GenerateHexDecValue(revision_number, 16)}

    78

    79

        return None

    80

    81

    def GetSlaveInfos(self):

    82

        slave_typeinfos = self.GetSlaveTypeInfos()

    83

        if slave_typeinfos is not None:

    84

            device = self.PlugParent.GetModuleInfos(slave_typeinfos)

    85

            if device is not None:

    86

                infos = slave_typeinfos.copy()

    87

                entries = device.GetEntriesList()

    88

                entries_list = entries.items()

    89

                entries_list.sort()

    90

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

    91

                              "sync_managers": device.GetSyncManagers(),

    92

                              "entries": [entry[1] for entry in entries_list]})

    93

                return infos

    94

        return None

    95

    96

    def GetVariableLocationTree(self):

    97

        slave_typeinfos = self.GetSlaveTypeInfos()

    98

        vars = []

    99

        if slave_typeinfos is not None:

   100

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

   101

   102

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

   103

                 "type": LOCATION_PLUGIN,

   104

                 "location": self.GetFullIEC_Channel(),

   105

                 "children": vars}

   106

   107

    PluginMethods = [

   108

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

   109

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

   110

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

   111

         "method" : "_OpenView"},

   112

    ]

   113

   114

   115

    def PlugGenerate_C(self, buildpath, locations):

   116

        """

   117

        Generate C code

   118

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

   119

        @param locations: List of complete variables locations \

   120

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

   121

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

   122

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

   123

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

   124

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

   125

            }, ...]

   126

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

   127

        """

   128

        current_location = self.GetCurrentLocation()

   129

   130

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

   131

   132

        slave_pos = current_location[-2:]

   133

   134

        slave_typeinfos = self.GetSlaveTypeInfos()

   135

        device = None

   136

        if slave_typeinfos is not None:

   137

            device = self.PlugParent.GetModuleInfos(slave_typeinfos)

   138

   139

        if device is None:

   140

            raise (ValueError, 

   141

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

   142

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

   143

   144

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

   145

   146

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

   147

        plc_ds402node_file = open(plc_ds402node_filepath, 'r')

   148

        plc_ds402node_code = plc_ds402node_file.read()

   149

        plc_ds402node_file.close()

   150

   151

        from plugins.motion import Headers

   152

   153

        str_completion = {

   154

            "location": location_str,

   155

            "MCL_headers": Headers,

   156

            "extern_located_variables_declaration": [],

   157

            "entry_variables": [],

   158

            "init_entry_variables": [],

   159

        }

   160

   161

        for variable in NODE_VARIABLES:

   162

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

   163

            var_infos["location"] = location_str

   164

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

   165

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

   166

   167

            str_completion["extern_located_variables_declaration"].append(

   168

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

   169

            str_completion["entry_variables"].append(

   170

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

   171

            str_completion["init_entry_variables"].append(

   172

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

   173

   174

            self.PlugParent.FileGenerator.DeclareVariable(

   175

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

   176

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

   177

   178

        for element in ["extern_located_variables_declaration", 

   179

                        "entry_variables", 

   180

                        "init_entry_variables"]:

   181

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

   182

   183

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

   184

        ds402nodefile = open(Gen_DS402Nodefile_path, 'w')

   185

        ds402nodefile.write(plc_ds402node_code % str_completion)

   186

        ds402nodefile.close()

   187

   188

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

   189

   190

   191

   192

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

   193

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

   194

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

   195

   196

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

   197

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

   198

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

   199

   200

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

   201

   202

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

   203

#                 Ethercat MASTER

   204

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

   205

   206

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

   207

   208

def ExtractHexDecValue(value):

   209

    try:

   210

        return int(value)

   211

    except:

   212

        pass

   213

    try:

   214

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

   215

    except:

   216

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

   217

   218

def GenerateHexDecValue(value, base=10):

   219

    if base == 10:

   220

        return str(value)

   221

    elif base == 16:

   222

        return "#x%.8x" % value

   223

    else:

   224

        raise ValueError, "Not supported base"

   225

   226

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

   227

if cls:

   228

   229

    def getType(self):

   230

        slave_info = self.getInfo()

   231

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

   232

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

   233

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

   234

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

   235

    setattr(cls, "getType", getType)

   236

   237

    def setType(self, type_infos):

   238

        slave_info = self.getInfo()

   239

        slave_info.setName(type_infos["device_type"])

   240

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

   241

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

   242

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

   243

    setattr(cls, "setType", setType)

   244

   245

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

   246

if cls:

   247

   248

    def getSlavePosition(self):

   249

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

   250

    setattr(cls, "getSlavePosition", getSlavePosition)

   251

   252

    def setSlavePosition(self, alias, pos):

   253

        self.setPhysAddr(alias)

   254

        self.setAutoIncAddr(pos)

   255

    setattr(cls, "setSlavePosition", setSlavePosition)

   256

   257

class _EthercatPlug:

   258

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

   259

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

   260

      <xsd:element name="EtherlabNode">

   261

        <xsd:complexType>

   262

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

   263

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

   264

        </xsd:complexType>

   265

      </xsd:element>

   266

    </xsd:schema>

   267

    """

   268

    EditorType = ConfigEditor

   269

   270

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

   271

   272

    def __init__(self):

   273

        filepath = self.ConfigFileName()

   274

   275

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

   276

        if os.path.isfile(filepath):

   277

            xmlfile = open(filepath, 'r')

   278

            tree = minidom.parse(xmlfile)

   279

            xmlfile.close()

   280

   281

            for child in tree.childNodes:

   282

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

   283

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

   284

                    self.CreateConfigBuffer(True)

   285

        else:

   286

            self.CreateConfigBuffer(False)

   287

            self.OnPlugSave()

   288

   289

    def ExtractHexDecValue(self, value):

   290

        return ExtractHexDecValue(value)

   291

   292

    def GetSizeOfType(self, type):

   293

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

   294

   295

    def ConfigFileName(self):

   296

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

   297

   298

    def GetSlaves(self):

   299

        slaves = []

   300

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

   301

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

   302

        slaves.sort()

   303

        return slaves

   304

   305

    def GetSlave(self, slave_pos):

   306

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

   307

            slave_info = slave.getInfo()

   308

            if slave_info.getSlavePosition() == slave_pos:

   309

                return slave

   310

        return None

   311

   312

    def AddSlave(self):

   313

        slaves = self.GetSlaves()

   314

        for PlugInstance in self.IterChilds():

   315

            slaves.append((PlugInstance.BaseParams.getIEC_Channel(), 0))

   316

        slaves.sort()

   317

        if len(slaves) > 0:

   318

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

   319

        else:

   320

            new_pos = (0, 0)

   321

        slave = EtherCATConfigClasses["Config_Slave"]()

   322

        slave_infos = slave.getInfo()

   323

        slave_infos.setName("undefined")

   324

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

   325

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

   326

        self.BufferConfig()

   327

        return new_pos

   328

   329

    def RemoveSlave(self, slave_pos):

   330

        config = self.Config.getConfig()

   331

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

   332

            slave_infos = slave.getInfo()

   333

            if slave_infos.getSlavePosition() == slave_pos:

   334

                config.removeSlave(idx)

   335

                self.BufferConfig()

   336

                return True

   337

        return False

   338

   339

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

   340

        for PlugInstance in self.IterChilds():

   341

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

   342

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

   343

        slave = self.GetSlave(slave_pos)

   344

        if slave is not None:

   345

            slave_info = slave.getInfo()

   346

            new_pos = slave_pos

   347

            if alias is not None:

   348

                new_pos = (alias, new_pos[1])

   349

            if position is not None:

   350

                new_pos = (new_pos[0], position)

   351

            if self.GetSlave(new_pos) is not None:

   352

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

   353

            slave_info.setSlavePosition(*new_pos)

   354

            self.BufferConfig()

   355

        return None

   356

   357

    def GetSlaveType(self, slave_pos):

   358

        slave = self.GetSlave(slave_pos)

   359

        if slave is not None:

   360

            return slave.getType()

   361

        return None

   362

   363

    def SetSlaveType(self, slave_pos, type_infos):

   364

        slave = self.GetSlave(slave_pos)

   365

        if slave is not None:

   366

            slave.setType(type_infos)

   367

            self.BufferConfig()

   368

        return None

   369

   370

    def GetSlaveInfos(self, slave_pos):

   371

        slave = self.GetSlave(slave_pos)

   372

        if slave is not None:

   373

            type_infos = slave.getType()

   374

            device = self.GetModuleInfos(type_infos)

   375

            if device is not None:

   376

                infos = type_infos.copy()

   377

                entries = device.GetEntriesList()

   378

                entries_list = entries.items()

   379

                entries_list.sort()

   380

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

   381

                              "sync_managers": device.GetSyncManagers(),

   382

                              "entries": [entry[1] for entry in entries_list]})

   383

                return infos

   384

        return None

   385

   386

    def GetModuleInfos(self, type_infos):

   387

        return self.PlugParent.GetModuleInfos(type_infos)

   388

   389

    def GetModulesByProfile(self, profile_type):

   390

        return self.PlugParent.GetModulesByProfile(profile_type)

   391

   392

    def GetSlaveTypesLibrary(self):

   393

        return self.PlugParent.GetModulesLibrary()

   394

   395

    def GetDeviceLocationTree(self, current_location, type_infos):

   396

        vars = []

   397

   398

        device = self.GetModuleInfos(type_infos)

   399

        if device is not None:

   400

            sync_managers = []

   401

            for sync_manager in device.getSm():

   402

                sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   403

                sync_manager_direction = sync_manager_control_byte & 0x0c

   404

                if sync_manager_direction:

   405

                    sync_managers.append(LOCATION_VAR_OUTPUT)

   406

                else:

   407

                    sync_managers.append(LOCATION_VAR_INPUT)

   408

   409

            entries = device.GetEntriesList().items()

   410

            entries.sort()

   411

            for (index, subindex), entry in entries:

   412

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

   413

                if var_size is not None:

   414

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

   415

                    if var_class is not None:

   416

                        if var_class == LOCATION_VAR_INPUT:

   417

                            var_dir = "%I"

   418

                        else:

   419

                            var_dir = "%Q"    

   420

   421

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

   422

                                     "type": var_class,

   423

                                     "size": var_size,

   424

                                     "IEC_type": entry["Type"],

   425

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

   426

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

   427

                                                                                                (index, subindex)))),

   428

                                     "description": "",

   429

                                     "children": []})

   430

   431

        return vars

   432

   433

    def GetVariableLocationTree(self):

   434

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

   435

   436

        current_location = self.GetCurrentLocation()

   437

   438

        groups = []

   439

        for slave_pos in self.GetSlaves():

   440

   441

            slave = self.GetSlave(slave_pos)

   442

            if slave is not None:

   443

                type_infos = slave.getType()

   444

   445

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

   446

                if len(vars) > 0:

   447

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

   448

                                   "type": LOCATION_GROUP,

   449

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

   450

                                   "children": vars})

   451

   452

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

   453

                 "type": LOCATION_PLUGIN,

   454

                 "location": self.GetFullIEC_Channel(),

   455

                 "children": groups}

   456

   457

    PluginMethods = [

   458

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

   459

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

   460

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

   461

         "method" : "_OpenView"},

   462

    ]

   463

   464

    def PlugTestModified(self):

   465

        return self.ChangesToSave or not self.ConfigIsSaved()    

   466

   467

    def OnPlugSave(self):

   468

        filepath = self.ConfigFileName()

   469

   470

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

   471

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

   472

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

   473

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

   474

   475

        xmlfile = open(filepath,"w")

   476

        xmlfile.write(text.encode("utf-8"))

   477

        xmlfile.close()

   478

   479

        self.ConfigBuffer.CurrentSaved()

   480

        return True

   481

   482

    def _Generate_C(self, buildpath, locations):

   483

        current_location = self.GetCurrentLocation()

   484

        # define a unique name for the generated C file

   485

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

   486

   487

        Gen_Ethercatfile_path = os.path.join(buildpath, "ethercat_%s.c"%location_str)

   488

   489

        self.FileGenerator = _EthercatCFileGenerator(self)

   490

   491

        LocationCFilesAndCFLAGS, LDFLAGS, extra_files = PlugTemplate._Generate_C(self, buildpath, locations)

   492

   493

        self.FileGenerator.GenerateCFile(Gen_Ethercatfile_path, location_str, self.EtherlabNode)

   494

   495

        LocationCFilesAndCFLAGS.append(

   496

            (current_location, 

   497

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

   498

             True))

   499

        LDFLAGS.append("-lethercat -lrtdm")

   500

   501

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   502

   503

    def PlugGenerate_C(self, buildpath, locations):

   504

        """

   505

        Generate C code

   506

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