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

    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:

    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:

    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 GetFilename(self):

   116

        return self.MandatoryParams[1].getName()

   117

   118

    def GetSlaves(self):

   119

        slaves = []

   120

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

   121

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

   122

        slaves.sort()

   123

        return slaves

   124

   125

    def GetSlave(self, slave_pos):

   126

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

   127

            slave_info = slave.getInfo()

   128

            if slave_info.getSlavePosition() == slave_pos:

   129

                return slave

   130

        return None

   131

   132

    def AddSlave(self):

   133

        slaves = self.GetSlaves()

   134

        if len(slaves) > 0:

   135

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

   136

        else:

   137

            new_pos = (0, 0)

   138

        slave = EtherCATConfigClasses["Config_Slave"]()

   139

        slave_infos = slave.getInfo()

   140

        slave_infos.setName("undefined")

   141

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

   142

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

   143

        self.BufferConfig()

   144

        return new_pos

   145

   146

    def RemoveSlave(self, slave_pos):

   147

        config = self.Config.getConfig()

   148

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

   149

            slave_infos = slave.getInfo()

   150

            if slave_infos.getSlavePosition() == slave_pos:

   151

                config.removeSlave(idx)

   152

                self.BufferConfig()

   153

                return True

   154

        return False

   155

   156

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

   157

        slave = self.GetSlave(slave_pos)

   158

        if slave is not None:

   159

            slave_info = slave.getInfo()

   160

            new_pos = slave_pos

   161

            if alias is not None:

   162

                new_pos = (alias, new_pos[1])

   163

            if position is not None:

   164

                new_pos = (new_pos[0], position)

   165

            if self.GetSlave(new_pos) is not None:

   166

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

   167

            slave_info.setSlavePosition(*new_pos)

   168

            self.BufferConfig()

   169

        return None

   170

   171

    def GetSlaveType(self, slave_pos):

   172

        slave = self.GetSlave(slave_pos)

   173

        if slave is not None:

   174

            return slave.getType()

   175

        return None

   176

   177

    def SetSlaveType(self, slave_pos, type_infos):

   178

        slave = self.GetSlave(slave_pos)

   179

        if slave is not None:

   180

            slave.setType(type_infos)

   181

            self.BufferConfig()

   182

        return None

   183

   184

    def GetSlaveInfos(self, slave_pos):

   185

        slave = self.GetSlave(slave_pos)

   186

        if slave is not None:

   187

            type_infos = slave.getType()

   188

            device = self.GetModuleInfos(type_infos)

   189

            if device is not None:

   190

                infos = type_infos.copy()

   194

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

   197

                return infos

   198

        return None

   199

   200

    def GetModuleInfos(self, type_infos):

   201

        return self.PlugParent.GetModuleInfos(type_infos)

   202

   203

    def GetSlaveTypesLibrary(self):

   204

        return self.PlugParent.GetModulesLibrary()

   205

   206

    def GetVariableLocationTree(self):

   207

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

   208

   209

        current_location = self.GetCurrentLocation()

   210

   211

        groups = []

   212

        for slave_pos in self.GetSlaves():

   213

   214

            slave = self.GetSlave(slave_pos)

   215

            if slave is not None:

   216

                type_infos = slave.getType()

   217

   218

                device = self.GetModuleInfos(type_infos)

   219

                if device is not None:

   220

                    vars = []

   221

   222

                    sync_managers = []

   223

                    for sync_manager in device.getSm():

   224

                        sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   225

                        sync_manager_direction = sync_manager_control_byte & 0x0c

   226

                        if sync_manager_direction:

   227

                            sync_managers.append(LOCATION_VAR_OUTPUT)

   228

                        else:

   229

                            sync_managers.append(LOCATION_VAR_INPUT)

   230

   237

                            if var_class == LOCATION_VAR_INPUT:

   238

                                var_dir = "%I"

   239

                            else:

   240

                                var_dir = "%Q"    

   241

   243

                                         "type": var_class,

   244

                                         "size": var_size,

   247

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

   248

                                                                                                    slave_pos + 

   249

                                                                                                    (index, subindex)))),

   250

                                         "description": "",

   251

                                         "children": []})

   252

   253

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

   254

                                   "type": LOCATION_GROUP,

   255

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

   256

                                   "children": vars})

   257

   258

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

   259

                 "type": LOCATION_PLUGIN,

   260

                 "location": self.GetFullIEC_Channel(),

   261

                 "children": groups}

   262

   263

    PluginMethods = [

   264

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

   265

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

   266

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

   267

         "method" : "_OpenView"},

   268

    ]

   269

   270

    def PlugTestModified(self):

   271

        return self.ChangesToSave or not self.ConfigIsSaved()    

   272

   273

    def OnPlugSave(self):

   274

        filepath = self.ConfigFileName()

   275

   276

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

   277

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

   278

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

   279

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

   280

   281

        xmlfile = open(filepath,"w")

   282

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

   283

        xmlfile.close()

   284

   285

        self.ConfigBuffer.CurrentSaved()

   286

        return True

   287

   288

    def PlugGenerate_C(self, buildpath, locations):

   289

        """

   290

        Generate C code

   291

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

   292

        @param locations: List of complete variables locations \

   293

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

   294

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

   295

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

   296

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

   297

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

   298

            }, ...]

   299

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

   300

        """

   301

        current_location = self.GetCurrentLocation()

   302

        # define a unique name for the generated C file

   303

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

   304

   305

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

   306

   307

        file_generator = _EthercatCFileGenerator(self, Gen_Ethercatfile_path)

   308

   309

        for location in locations:

   310

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

   311

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

   312

   313

        file_generator.GenerateCFile()

   314

   315

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

   316

   317

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

   318

#                      Current Buffering Management Functions

   319

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

   320

   321

    """

   322

    Return a copy of the config

   323

    """

   324

    def Copy(self, model):

   325

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

   326

   327

    def CreateConfigBuffer(self, saved):

   328

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

   329

   330

    def BufferConfig(self):

   331

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

   332

   333

    def ConfigIsSaved(self):

   334

        if self.ConfigBuffer is not None:

   335

            return self.ConfigBuffer.IsCurrentSaved()

   336

        else:

   337

            return True

   338

   339

    def LoadPrevious(self):

   340

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

   341

   342

    def LoadNext(self):

   343

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

   344

   345

    def GetBufferState(self):

   346

        first = self.ConfigBuffer.IsFirst()

   347

        last = self.ConfigBuffer.IsLast()

   348

        return not first, not last

   349

   350

   351

SLAVE_PDOS_CONFIGURATION_DECLARATION = """

   352

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

   353

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

   354

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

   355

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

   356

 */

   357

   358

ec_pdo_entry_info_t slave_%(slave)d_pdo_entries[] = {

   359

%(pdos_entries_infos)s

   360

};

   361

   362

ec_pdo_info_t slave_%(slave)d_pdos[] = {

   363

%(pdos_infos)s

   364

};

   365

   366

ec_sync_info_t slave_%(slave)d_syncs[] = {

   367

%(pdos_sync_infos)s

   368

    {0xff}

   369

};

   370

"""

   371

   372

SLAVE_CONFIGURATION_TEMPLATE = """

   373

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

   374

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

   375

        return -1;

   376

    }

   377

   378

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

   379

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

   380

        return -1;

   381

    }

   382

"""

   383

   432

class _EthercatCFileGenerator:

   433

   434

    def __init__(self, controler, filepath):

   435

        self.Controler = controler

   436

        self.FilePath = filepath

   437

   438

        self.UsedVariables = {}

   439

   440

    def __del__(self):

   441

        self.Controler = None

   442

   443

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

   444

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

   445

   446

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

   447

        if entry_infos is None:

   452

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

   454

    def GenerateCFile(self):

   455

   456

        current_location = self.Controler.GetCurrentLocation()

   457

        # define a unique name for the generated C file

   458

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

   459

   460

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

   461

        plc_etherlab_file = open(plc_etherlab_filepath, 'r')

   462

        plc_etherlab_code = plc_etherlab_file.read()

   463

        plc_etherlab_file.close()

   464

   465

        str_completion = {

   466

            "location": location_str,

   467

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

   468

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

   469

            "located_variables_declaration": [],

   470

            "used_pdo_entry_offset_variables_declaration": [],

   471

            "used_pdo_entry_configuration": [],

   472

            "pdos_configuration_declaration": "",

   473

            "slaves_declaration": "",

   474

            "slaves_configuration": "",

   475

            "retrieve_variables": [],

   476

            "publish_variables": [],

   477

        }

   478

   483

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

   484

   485

            slave = self.Controler.GetSlave(slave_pos)

   486

            if slave is not None:

   487

                type_infos = slave.getType()

   488

   489

                device = self.Controler.GetModuleInfos(type_infos)

   490

                if device is not None:

   493

   495

   496

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

   497

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

   498

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

   499

   500

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

   501

                        str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos

   502

   503

                        pdos_infos = {

   504

                            "pdos_entries_infos": [],

   505

                            "pdos_infos": [],

   506

                            "pdos_sync_infos": [], 

   507

                        }

   508

                        pdos_infos.update(type_infos)

   509

   510

                        sync_managers = []

   511

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

   512

                            sync_manager_infos = {

   513

                                "index": sync_manager_idx, 

   515

                                "slave": slave_idx,

   517

                                "pdos_number": 0,

   518

                            }