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

        """

    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

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

    94

                              "sync_managers": device.GetSyncManagers(),

    95

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

    96

                return infos

    97

        return None

    98

    99

    def GetVariableLocationTree(self):

   100

        slave_typeinfos = self.GetSlaveTypeInfos()

   101

        vars = []

   102

        if slave_typeinfos is not None:

   103

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

   104

   105

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

   106

                 "type": LOCATION_PLUGIN,

   107

                 "location": self.GetFullIEC_Channel(),

   108

                 "children": vars}

   109

   110

    PluginMethods = [

   111

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

   112

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

   113

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

   114

         "method" : "_OpenView"},

   115

    ]

   116

   117

   118

    def PlugGenerate_C(self, buildpath, locations):

   119

        """

   120

        Generate C code

   121

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

   122

        @param locations: List of complete variables locations \

   123

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

   124

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

   125

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

   126

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

   127

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

   128

            }, ...]

   129

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

   130

        """

   131

        current_location = self.GetCurrentLocation()

   132

   133

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

   134

   135

        slave_pos = current_location[-2:]

   136

   137

        slave_typeinfos = self.GetSlaveTypeInfos()

   138

        device = None

   139

        if slave_typeinfos is not None:

   140

            device = self.PlugParent.GetModuleInfos(slave_typeinfos)

   141

   142

        if device is None:

   143

            raise (ValueError, 

   144

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

   145

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

   146

   147

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

   148

   149

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

   150

        plc_ds402node_file = open(plc_ds402node_filepath, 'r')

   151

        plc_ds402node_code = plc_ds402node_file.read()

   152

        plc_ds402node_file.close()

   153

   154

        from plugins.motion import Headers

   155

   156

        str_completion = {

   157

            "location": location_str,

   158

            "MCL_headers": Headers,

   159

            "extern_located_variables_declaration": [],

   160

            "entry_variables": [],

   161

            "init_entry_variables": [],

   162

        }

   163

   164

        for variable in NODE_VARIABLES:

   165

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

   166

            var_infos["location"] = location_str

   167

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

   168

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

   169

   170

            str_completion["extern_located_variables_declaration"].append(

   171

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

   172

            str_completion["entry_variables"].append(

   173

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

   174

            str_completion["init_entry_variables"].append(

   175

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

   176

   177

            self.PlugParent.FileGenerator.DeclareVariable(

   178

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

   179

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

   180

   181

        for element in ["extern_located_variables_declaration", 

   182

                        "entry_variables", 

   183

                        "init_entry_variables"]:

   184

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

   185

   186

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

   187

        ds402nodefile = open(Gen_DS402Nodefile_path, 'w')

   188

        ds402nodefile.write(plc_ds402node_code % str_completion)

   189

        ds402nodefile.close()

   190

   191

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

   192

   193

   194

   195

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

   196

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

   197

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

   198

   199

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

   200

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

   201

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

   202

   203

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

   204

   205

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

   206

#                 Ethercat MASTER

   207

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

   208

   209

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

   210

   211

def ExtractHexDecValue(value):

   212

    try:

   213

        return int(value)

   214

    except:

   215

        pass

   216

    try:

   217

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

   218

    except:

   219

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

   220

   221

def GenerateHexDecValue(value, base=10):

   222

    if base == 10:

   223

        return str(value)

   224

    elif base == 16:

   225

        return "#x%.8x" % value

   226

    else:

   227

        raise ValueError, "Not supported base"

   228

   229

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

   230

if cls:

   231

   232

    def getType(self):

   233

        slave_info = self.getInfo()

   234

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

   235

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

   236

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

   237

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

   238

    setattr(cls, "getType", getType)

   239

   240

    def setType(self, type_infos):

   241

        slave_info = self.getInfo()

   242

        slave_info.setName(type_infos["device_type"])

   243

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

   244

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

   245

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

   246

    setattr(cls, "setType", setType)

   247

   248

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

   249

if cls:

   250

   251

    def getSlavePosition(self):

   252

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

   253

    setattr(cls, "getSlavePosition", getSlavePosition)

   254

   255

    def setSlavePosition(self, alias, pos):

   256

        self.setPhysAddr(alias)

   257

        self.setAutoIncAddr(pos)

   258

    setattr(cls, "setSlavePosition", setSlavePosition)

   259

   260

class _EthercatPlug:

   261

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

   262

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

   263

      <xsd:element name="EtherlabNode">

   264

        <xsd:complexType>

   265

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

   266

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

   267

        </xsd:complexType>

   268

      </xsd:element>

   269

    </xsd:schema>

   270

    """

   271

    EditorType = ConfigEditor

   272

   273

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

   274

   275

    def __init__(self):

   276

        filepath = self.ConfigFileName()

   277

   278

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

   279

        if os.path.isfile(filepath):

   280

            xmlfile = open(filepath, 'r')

   281

            tree = minidom.parse(xmlfile)

   282

            xmlfile.close()

   283

   284

            for child in tree.childNodes:

   285

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

   286

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

   287

                    self.CreateConfigBuffer(True)

   288

        else:

   289

            self.CreateConfigBuffer(False)

   290

            self.OnPlugSave()

   291

   292

    def ExtractHexDecValue(self, value):

   293

        return ExtractHexDecValue(value)

   294

   295

    def GetSizeOfType(self, type):

   296

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

   297

   298

    def ConfigFileName(self):

   299

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

   300

   301

    def GetSlaves(self):

   302

        slaves = []

   303

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

   304

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

   305

        slaves.sort()

   306

        return slaves

   307

   308

    def GetSlave(self, slave_pos):

   309

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

   310

            slave_info = slave.getInfo()

   311

            if slave_info.getSlavePosition() == slave_pos:

   312

                return slave

   313

        return None

   314

   315

    def AddSlave(self):

   316

        slaves = self.GetSlaves()

   317

        for PlugInstance in self.IterChilds():

   319

        slaves.sort()

   320

        if len(slaves) > 0:

   321

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

   322

        else:

   323

            new_pos = (0, 0)

   324

        slave = EtherCATConfigClasses["Config_Slave"]()

   325

        slave_infos = slave.getInfo()

   326

        slave_infos.setName("undefined")

   327

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

   328

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

   329

        self.BufferConfig()

   330

        return new_pos

   331

   332

    def RemoveSlave(self, slave_pos):

   333

        config = self.Config.getConfig()

   334

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

   335

            slave_infos = slave.getInfo()

   336

            if slave_infos.getSlavePosition() == slave_pos:

   337

                config.removeSlave(idx)

   338

                self.BufferConfig()

   339

                return True

   340

        return False

   341

   342

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

   343

        for PlugInstance in self.IterChilds():

   344

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

   345

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

   346

        slave = self.GetSlave(slave_pos)

   347

        if slave is not None:

   348

            slave_info = slave.getInfo()

   349

            new_pos = slave_pos

   350

            if alias is not None:

   351

                new_pos = (alias, new_pos[1])

   352

            if position is not None:

   353

                new_pos = (new_pos[0], position)

   354

            if self.GetSlave(new_pos) is not None:

   355

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

   356

            slave_info.setSlavePosition(*new_pos)

   357

            self.BufferConfig()

   358

        return None

   359

   360

    def GetSlaveType(self, slave_pos):

   361

        slave = self.GetSlave(slave_pos)

   362

        if slave is not None:

   363

            return slave.getType()

   364

        return None

   365

   366

    def SetSlaveType(self, slave_pos, type_infos):

   367

        slave = self.GetSlave(slave_pos)

   368

        if slave is not None:

   369

            slave.setType(type_infos)

   370

            self.BufferConfig()

   371

        return None

   372

   373

    def GetSlaveInfos(self, slave_pos):

   374

        slave = self.GetSlave(slave_pos)

   375

        if slave is not None:

   376

            type_infos = slave.getType()

   377

            device = self.GetModuleInfos(type_infos)

   378

            if device is not None:

   379

                infos = type_infos.copy()

   380

                entries = device.GetEntriesList()

   381

                entries_list = entries.items()

   382

                entries_list.sort()

   383

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

   384

                              "sync_managers": device.GetSyncManagers(),

   385

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

   386

                return infos

   387

        return None

   388

   389

    def GetModuleInfos(self, type_infos):

   390

        return self.PlugParent.GetModuleInfos(type_infos)

   391

   392

    def GetModulesByProfile(self, profile_type):

   393

        return self.PlugParent.GetModulesByProfile(profile_type)

   394

   395

    def GetSlaveTypesLibrary(self):

   396

        return self.PlugParent.GetModulesLibrary()

   397

   398

    def GetDeviceLocationTree(self, current_location, type_infos):

   399

        vars = []

   400

   401

        device = self.GetModuleInfos(type_infos)

   402

        if device is not None:

   403

            sync_managers = []

   404

            for sync_manager in device.getSm():

   405

                sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   406

                sync_manager_direction = sync_manager_control_byte & 0x0c

   407

                if sync_manager_direction:

   408

                    sync_managers.append(LOCATION_VAR_OUTPUT)

   409

                else:

   410

                    sync_managers.append(LOCATION_VAR_INPUT)

   411

   412

            entries = device.GetEntriesList().items()

   413

            entries.sort()

   414

            for (index, subindex), entry in entries:

   415

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

   416

                if var_size is not None:

   417

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

   418

                    if var_class is not None:

   419

                        if var_class == LOCATION_VAR_INPUT:

   420

                            var_dir = "%I"

   421

                        else:

   422

                            var_dir = "%Q"    

   423

   424

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

   425

                                     "type": var_class,

   426

                                     "size": var_size,

   427

                                     "IEC_type": entry["Type"],

   429

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

   430

                                                                                                (index, subindex)))),

   431

                                     "description": "",

   432

                                     "children": []})

   433

   434

        return vars

   435

   436

    def GetVariableLocationTree(self):

   437

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

   438

   439

        current_location = self.GetCurrentLocation()

   440

   441

        groups = []

   442

        for slave_pos in self.GetSlaves():

   443

   444

            slave = self.GetSlave(slave_pos)

   445

            if slave is not None:

   446

                type_infos = slave.getType()

   447

   448

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

   449

                if len(vars) > 0:

   450

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

   451

                                   "type": LOCATION_GROUP,

   452

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

   453

                                   "children": vars})

   454

   455

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

   456

                 "type": LOCATION_PLUGIN,

   457

                 "location": self.GetFullIEC_Channel(),

   458

                 "children": groups}

   459

   460

    PluginMethods = [

   461

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

   462

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

   463

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

   464

         "method" : "_OpenView"},

   465

    ]

   466

   467

    def PlugTestModified(self):

   468

        return self.ChangesToSave or not self.ConfigIsSaved()    

   469

   470

    def OnPlugSave(self):

   471

        filepath = self.ConfigFileName()

   472

   473

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

   474

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

   475

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

   476

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

   477

   478

        xmlfile = open(filepath,"w")

   479

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

   480

        xmlfile.close()

   481

   482

        self.ConfigBuffer.CurrentSaved()

   483

        return True

   484

   485

    def _Generate_C(self, buildpath, locations):

   486

        current_location = self.GetCurrentLocation()

   487

        # define a unique name for the generated C file

   488

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

   489

   490

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

   491

   492

        self.FileGenerator = _EthercatCFileGenerator(self)

   493

   494

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

   495

   496

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

   497

   498

        LocationCFilesAndCFLAGS.append(

   499

            (current_location, 

   500

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

   501

             True))

   502

        LDFLAGS.append("-lethercat -lrtdm")

   503

   504

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   505