1

import os, shutil

     2

import cPickle

     3

from xml.dom import minidom

     4

     5

import wx

     6

     7

from xmlclass import *

     8

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

     9

from ConfigEditor import ConfigEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    10

    11

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

    12

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

    13

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

    14

    15

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

    16

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

    17

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

    18

    19

VARCLASSCONVERSION = {"ro": LOCATION_VAR_INPUT, "wo": LOCATION_VAR_OUTPUT, "rw": LOCATION_VAR_MEMORY}

    20

    21

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

    22

#                 Ethercat MASTER

    23

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

    24

    25

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

    26

    27

def ExtractHexDecValue(value):

    28

    try:

    29

        return int(value)

    30

    except:

    31

        pass

    32

    try:

    33

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

    34

    except:

    35

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

    36

    37

def GenerateHexDecValue(value, base=10):

    38

    if base == 10:

    39

        return str(value)

    40

    elif base == 16:

    41

        return "#x%.8x" % value

    42

    else:

    43

        raise ValueError, "Not supported base"

    44

    45

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

    46

if cls:

    47

    48

    def getType(self):

    49

        slave_info = self.getInfo()

    50

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

    51

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

    52

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

    53

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

    54

    setattr(cls, "getType", getType)

    55

    56

    def setType(self, type_infos):

    57

        slave_info = self.getInfo()

    58

        slave_info.setName(type_infos["device_type"])

    59

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

    60

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

    61

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

    62

    setattr(cls, "setType", setType)

    63

    64

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

    65

if cls:

    66

    67

    def getSlavePosition(self):

    68

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

    69

    setattr(cls, "getSlavePosition", getSlavePosition)

    70

    71

    def setSlavePosition(self, alias, pos):

    72

        self.setPhysAddr(alias)

    73

        self.setAutoIncAddr(pos)

    74

    setattr(cls, "setSlavePosition", setSlavePosition)

    75

    76

class _EthercatPlug:

    77

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

    78

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

    79

      <xsd:element name="EtherlabNode">

    80

        <xsd:complexType>

    81

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

    82

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

    83

        </xsd:complexType>

    84

      </xsd:element>

    85

    </xsd:schema>

    86

    """

    87

    EditorType = ConfigEditor

    88

    89

    def __init__(self):

    90

        filepath = self.ConfigFileName()

    91

    92

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

    93

        if os.path.isfile(filepath):

    94

            xmlfile = open(filepath, 'r')

    95

            tree = minidom.parse(xmlfile)

    96

            xmlfile.close()

    97

    98

            for child in tree.childNodes:

    99

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

   100

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

   101

                    self.CreateConfigBuffer(True)

   102

        else:

   103

            self.CreateConfigBuffer(False)

   104

            self.OnPlugSave()

   105

   106

    def ExtractHexDecValue(self, value):

   107

        return ExtractHexDecValue(value)

   108

   109

    def GetSizeOfType(self, type):

   110

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

   111

   112

    def ConfigFileName(self):

   113

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

   114

   115

    def GetSlaves(self):

   116

        slaves = []

   117

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

   118

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

   119

        slaves.sort()

   120

        return slaves

   121

   122

    def GetSlave(self, slave_pos):

   123

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

   124

            slave_info = slave.getInfo()

   125

            if slave_info.getSlavePosition() == slave_pos:

   126

                return slave

   127

        return None

   128

   129

    def AddSlave(self):

   130

        slaves = self.GetSlaves()

   131

        if len(slaves) > 0:

   132

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

   133

        else:

   134

            new_pos = (0, 0)

   135

        slave = EtherCATConfigClasses["Config_Slave"]()

   136

        slave_infos = slave.getInfo()

   137

        slave_infos.setName("undefined")

   138

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

   139

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

   140

        self.BufferConfig()

   141

        return new_pos

   142

   143

    def RemoveSlave(self, slave_pos):

   144

        config = self.Config.getConfig()

   145

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

   146

            slave_infos = slave.getInfo()

   147

            if slave_infos.getSlavePosition() == slave_pos:

   148

                config.removeSlave(idx)

   149

                self.BufferConfig()

   150

                return True

   151

        return False

   152

   153

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

   154

        slave = self.GetSlave(slave_pos)

   155

        if slave is not None:

   156

            slave_info = slave.getInfo()

   157

            new_pos = slave_pos

   158

            if alias is not None:

   159

                new_pos = (alias, new_pos[1])

   160

            if position is not None:

   161

                new_pos = (new_pos[0], position)

   162

            if self.GetSlave(new_pos) is not None:

   163

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

   164

            slave_info.setSlavePosition(*new_pos)

   165

            self.BufferConfig()

   166

        return None

   167

   168

    def GetSlaveType(self, slave_pos):

   169

        slave = self.GetSlave(slave_pos)

   170

        if slave is not None:

   171

            return slave.getType()

   172

        return None

   173

   174

    def SetSlaveType(self, slave_pos, type_infos):

   175

        slave = self.GetSlave(slave_pos)

   176

        if slave is not None:

   177

            slave.setType(type_infos)

   178

            self.BufferConfig()

   179

        return None

   180

   181

    def GetSlaveInfos(self, slave_pos):

   182

        slave = self.GetSlave(slave_pos)

   183

        if slave is not None:

   184

            type_infos = slave.getType()

   185

            device = self.GetModuleInfos(type_infos)

   186

            if device is not None:

   187

                infos = type_infos.copy()

   188

                entries = device.GetEntriesList()

   189

                entries_list = entries.items()

   190

                entries_list.sort()

   191

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

   192

                              "sync_managers": device.GetSyncManagers(),

   193

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

   194

                return infos

   195

        return None

   196

   197

    def GetModuleInfos(self, type_infos):

   198

        return self.PlugParent.GetModuleInfos(type_infos)

   199

   200

    def GetSlaveTypesLibrary(self):

   201

        return self.PlugParent.GetModulesLibrary()

   202

   203

    def GetVariableLocationTree(self):

   204

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

   205

   206

        current_location = self.GetCurrentLocation()

   207

   208

        groups = []

   209

        for slave_pos in self.GetSlaves():

   210

   211

            slave = self.GetSlave(slave_pos)

   212

            if slave is not None:

   213

                type_infos = slave.getType()

   214

   215

                device = self.GetModuleInfos(type_infos)

   216

                if device is not None:

   217

                    vars = []

   218

   219

                    sync_managers = []

   220

                    for sync_manager in device.getSm():

   221

                        sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   222

                        sync_manager_direction = sync_manager_control_byte & 0x0c

   223

                        if sync_manager_direction:

   224

                            sync_managers.append(LOCATION_VAR_OUTPUT)

   225

                        else:

   226

                            sync_managers.append(LOCATION_VAR_INPUT)

   227

   228

                    entries = device.GetEntriesList().items()

   229

                    entries.sort()

   230

                    for (index, subindex), entry in entries:

   231

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

   232

                        if var_size is not None:

   233

                            var_class = VARCLASSCONVERSION.get(entry["Access"], LOCATION_VAR_MEMORY)

   234

                            if var_class == LOCATION_VAR_INPUT:

   235

                                var_dir = "%I"

   236

                            else:

   237

                                var_dir = "%Q"    

   238

   239

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

   240

                                         "type": var_class,

   241

                                         "size": var_size,

   242

                                         "IEC_type": entry["Type"],

   243

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

   244

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

   245

                                                                                                    slave_pos + 

   246

                                                                                                    (index, subindex)))),

   247

                                         "description": "",

   248

                                         "children": []})

   249

   250

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

   251

                                   "type": LOCATION_GROUP,

   252

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

   253

                                   "children": vars})

   254

   255

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

   256

                 "type": LOCATION_PLUGIN,

   257

                 "location": self.GetFullIEC_Channel(),

   258

                 "children": groups}

   259

   260

    PluginMethods = [

   261

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

   262

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

   263

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

   264

         "method" : "_OpenView"},

   265

    ]

   266

   267

    def PlugTestModified(self):

   268

        return self.ChangesToSave or not self.ConfigIsSaved()    

   269

   270

    def OnPlugSave(self):

   271

        filepath = self.ConfigFileName()

   272

   273

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

   274

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

   275

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

   276

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

   277

   278

        xmlfile = open(filepath,"w")

   279

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

   280

        xmlfile.close()

   281

   282

        self.ConfigBuffer.CurrentSaved()

   283

        return True

   284

   285

    def PlugGenerate_C(self, buildpath, locations):

   286

        """

   287

        Generate C code

   288

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

   289

        @param locations: List of complete variables locations \

   290

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

   291

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

   292

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

   293

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

   294

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

   295

            }, ...]

   296

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

   297

        """

   298

        current_location = self.GetCurrentLocation()

   299

        # define a unique name for the generated C file

   300

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

   301

   302

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

   303

   304

        file_generator = _EthercatCFileGenerator(self, Gen_Ethercatfile_path)

   305

   306

        for location in locations:

   307

            loc = location["LOC"][len(current_location):]

   308

            file_generator.DeclareVariable(loc[:2], loc[2], loc[3], location["IEC_TYPE"], location["DIR"], location["NAME"])

   309

   310

        file_generator.GenerateCFile()

   311

   312

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

   313

   314

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

   315

#                      Current Buffering Management Functions

   316

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

   317

   318

    """

   319

    Return a copy of the config

   320

    """

   321

    def Copy(self, model):

   322

        return cPickle.loads(cPickle.dumps(model))

   323

   324

    def CreateConfigBuffer(self, saved):

   325

        self.ConfigBuffer = UndoBuffer(cPickle.dumps(self.Config), saved)

   326

   327

    def BufferConfig(self):

   328

        self.ConfigBuffer.Buffering(cPickle.dumps(self.Config))

   329

   330

    def ConfigIsSaved(self):

   331

        if self.ConfigBuffer is not None:

   332

            return self.ConfigBuffer.IsCurrentSaved()

   333

        else:

   334

            return True

   335

   336

    def LoadPrevious(self):

   337

        self.Config = cPickle.loads(self.ConfigBuffer.Previous())

   338

   339

    def LoadNext(self):

   340

        self.Config = cPickle.loads(self.ConfigBuffer.Next())

   341

   342

    def GetBufferState(self):

   343

        first = self.ConfigBuffer.IsFirst()

   344

        last = self.ConfigBuffer.IsLast()

   345

        return not first, not last

   346

   347

   348

SLAVE_PDOS_CONFIGURATION_DECLARATION = """

   349

/* Slave %(slave)d, "%(device_type)s"

   350

 * Vendor ID:       0x%(vendor).8x

   351

 * Product code:    0x%(product_code).8x

   352

 * Revision number: 0x%(revision_number).8x

   353

 */

   354

   355

ec_pdo_entry_info_t slave_%(slave)d_pdo_entries[] = {

   356

%(pdos_entries_infos)s

   357

};

   358

   359

ec_pdo_info_t slave_%(slave)d_pdos[] = {

   360

%(pdos_infos)s

   361

};

   362

   363

ec_sync_info_t slave_%(slave)d_syncs[] = {

   364

%(pdos_sync_infos)s

   365

    {0xff}

   366

};

   367

"""

   368

   369

SLAVE_CONFIGURATION_TEMPLATE = """

   370

    if (!(slave%(slave)d = ecrt_master_slave_config(master, %(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x))) {

   371

        fprintf(stderr, "Failed to get slave %(device_type)s configuration at alias %(alias)d and position %(position)d.\\n");

   372

        return -1;

   373

    }

   374

   375

    if (ecrt_slave_config_pdos(slave%(slave)d, EC_END, slave_%(slave)d_syncs)) {

   376

        fprintf(stderr, "Failed to configure PDOs for slave %(device_type)s at alias %(alias)d and position %(position)d.\\n");

   377

        return -1;

   378

    }

   379

"""

   380

   381

def ConfigureVariable(entry_infos, str_completion):

   382

    data_type = DATATYPECONVERSION.get(entry_infos["var_type"], None)

   383

    if data_type is None:

   384

        raise ValueError, _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]

   386

    str_completion["located_variables_declaration"].extend(

   387

        ["IEC_%(var_type)s beremiz%(var_name)s;" % entry_infos,

   388

         "IEC_%(var_type)s *%(var_name)s = &beremiz%(var_name)s;" % entry_infos])

   389

   390

    if data_type == "BIT":

   391

        str_completion["used_pdo_entry_offset_variables_declaration"].extend(

   392

            ["static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos,

   393

             "static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % entry_infos])

   394

   395

        str_completion["used_pdo_entry_configuration"].append(

   396

             ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, " + 

   397

              "0x%(index).4x, %(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   398

              "&slave%(slave)d_%(index).4x_%(subindex).2x_bit},") % entry_infos)

   399

   400

        if entry_infos["dir"] == "I":

   401

            str_completion["retrieve_variables"].append(

   402

              ("    beremiz%(name)s = EC_READ_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   403

               "slave%(slave)d_%(index).4x_%(subindex).2x_bit);") % entry_infos)

   404

        elif entry_infos["dir"] == "Q":

   405

            str_completion["publish_variables"].append(

   406

              ("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 

   407

               "slave%(slave)d_%(index).4x_%(subindex).2x_bit, beremiz%(var_name)s);") % entry_infos)

   408

   409

    else:

   410

        entry_infos["data_type"] = data_type

   411

   412

        str_completion["used_pdo_entry_offset_variables_declaration"].append(

   413

            "static unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos)

   414

   415

        str_completion["used_pdo_entry_configuration"].append(

   416

            ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, 0x%(index).4x, " + 

   417

             "%(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x},") % entry_infos)

   418

   419

        if entry_infos["dir"] == "I":

   420

            str_completion["retrieve_variables"].append(

   422

                 "slave%(slave)d_%(index).4x_%(subindex).2x);") % entry_infos)

   423

        elif entry_infos["dir"] == "Q":

   424

            str_completion["publish_variables"].append(

   426

                 "beremiz%(var_name)s);") % entry_infos)

   427

   428

   429

class _EthercatCFileGenerator:

   430

   431

    def __init__(self, controler, filepath):

   432

        self.Controler = controler

   433

        self.FilePath = filepath

   434

   435

        self.UsedVariables = {}

   436

   437

    def __del__(self):

   438

        self.Controler = None

   439

   440

    def DeclareVariable(self, slave_identifier, index, subindex, iec_type, dir, name):

   441

        slave_variables = self.UsedVariables.setdefault(slave_identifier, {})

   442

   443

        entry_infos = slave_variables.get((index, subindex), None)

   444

        if entry_infos is None:

   445

            slave_variables[(index, subindex)] = {

   446

                "infos": (iec_type, dir, name),

   447

                "mapped": False}

   448

        elif entry_infos["infos"] != (iec_type, dir, name):

   449

            raise ValueError, _("Definition conflict for location \"%s\"") % name 

   450

   451

    def GenerateCFile(self):

   452

   453

        current_location = self.Controler.GetCurrentLocation()

   454

        # define a unique name for the generated C file

   455

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

   456

   457

        plc_etherlab_filepath = os.path.join(os.path.split(__file__)[0], "plc_etherlab.c")

   458

        plc_etherlab_file = open(plc_etherlab_filepath, 'r')

   459

        plc_etherlab_code = plc_etherlab_file.read()

   460

        plc_etherlab_file.close()

   461

   462

        str_completion = {

   463

            "location": location_str,

   464

            "configure_pdos": int(self.Controler.EtherlabNode.getConfigurePDOs()),

   465

            "master_number": self.Controler.EtherlabNode.getMasterNumber(),

   466

            "located_variables_declaration": [],

   467

            "used_pdo_entry_offset_variables_declaration": [],

   468

            "used_pdo_entry_configuration": [],

   469

            "pdos_configuration_declaration": "",

   470

            "slaves_declaration": "",

   471

            "slaves_configuration": "",

   472

            "retrieve_variables": [],

   473

            "publish_variables": [],

   474

        }

   475

   476

        for slave_entries in self.UsedVariables.itervalues():

   477

            for entry_infos in slave_entries.itervalues():

   478

                entry_infos["mapped"] = False

   479

   480

        for slave_idx, slave_pos in enumerate(self.Controler.GetSlaves()):

   481

   482

            slave = self.Controler.GetSlave(slave_pos)

   483

            if slave is not None:

   484

                type_infos = slave.getType()

   485

   486

                device = self.Controler.GetModuleInfos(type_infos)

   487

                if device is not None:

   488

                    slave_variables = self.UsedVariables.get(slave_pos, {})

   489

                    device_entries = device.GetEntriesList()

   490

   491

                    if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0:

   492

   493

                        for element in ["vendor", "product_code", "revision_number"]:

   494

                            type_infos[element] = ExtractHexDecValue(type_infos[element])

   495

                        type_infos.update(dict(zip(["slave", "alias", "position"], (slave_idx,) + slave_pos)))

   496

   497

                        str_completion["slaves_declaration"] += "static ec_slave_config_t *slave%(slave)d = NULL;\n" % type_infos

   498

                        str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos

   499

   500

                        pdos_infos = {

   501

                            "pdos_entries_infos": [],

   502

                            "pdos_infos": [],

   503

                            "pdos_sync_infos": [], 

   504

                        }

   505

                        pdos_infos.update(type_infos)

   506

   507

                        sync_managers = []

   508

                        for sync_manager_idx, sync_manager in enumerate(device.getSm()):

   509

                            sync_manager_infos = {

   510

                                "index": sync_manager_idx, 

   511

                                "name": sync_manager.getcontent(),

   512

                                "slave": slave_idx,

   513

                                "pdos": [], 

   514

                                "pdos_number": 0,

   515

                            }

   516

   517

                            sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   518

                            sync_manager_direction = sync_manager_control_byte & 0x0c