1

import os, shutil

     3

     4

import wx

     5

import csv

     6

     7

from xmlclass import *

     8

     9

from ConfigTreeNode import ConfigTreeNode

    10

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

    11

    12

from EthercatSlave import ExtractHexDecValue, ExtractName

    13

from EthercatMaster import _EthercatCTN

    14

from ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    15

    18

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

    19

#                 Ethercat ConfNode

    20

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

    21

    82

if cls:

    85

    def GetProfileNumbers(self):

    87

    setattr(cls, "GetProfileNumbers", GetProfileNumbers)

    88

    89

    def getCoE(self):

    90

        mailbox = self.getMailbox()

    91

        if mailbox is not None:

    92

            return mailbox.getCoE()

    93

        return None

    94

    setattr(cls, "getCoE", getCoE)

    95

    96

    def GetEntriesList(self, limits=None):

    97

        entries = {}

    98

   109

   110

        return entries

   111

    setattr(cls, "GetEntriesList", GetEntriesList)

   113

    def GetSyncManagers(self):

   114

        sync_managers = []

   115

        for sync_manager in self.getSm():

   116

            sync_manager_infos = {}

   117

            for name, value in [("Name", sync_manager.getcontent()),

   118

                                ("Start Address", sync_manager.getStartAddress()),

   119

                                ("Default Size", sync_manager.getDefaultSize()),

   120

                                ("Control Byte", sync_manager.getControlByte()),

   121

                                ("Enable", sync_manager.getEnable())]:

   122

                if value is None:

   123

                    value =""

   124

                sync_manager_infos[name] = value

   125

            sync_managers.append(sync_manager_infos)

   126

        return sync_managers

   127

    setattr(cls, "GetSyncManagers", GetSyncManagers)

   128

   129

def GroupItemCompare(x, y):

   130

    if x["type"] == y["type"]:

   131

        if x["type"] == ETHERCAT_GROUP:

   132

            return cmp(x["order"], y["order"])

   133

        else:

   134

            return cmp(x["name"], y["name"])

   135

    elif x["type"] == ETHERCAT_GROUP:

   136

        return -1

   137

    return 1

   138

   139

def SortGroupItems(group):

   140

    for item in group["children"]:

   141

        if item["type"] == ETHERCAT_GROUP:

   142

            SortGroupItems(item)

   143

    group["children"].sort(GroupItemCompare)

   144

   145

class ModulesLibrary:

   146

   147

    MODULES_EXTRA_PARAMS = [

   148

        ("pdo_alignment", {

   149

            "column_label": _("PDO alignment"), 

   150

            "column_size": 150,

   151

            "default": 8,

   152

            "description": _(

   153

"Minimal size in bits between 2 pdo entries")}),

   154

        ("max_pdo_size", {

   155

            "column_label": _("Max entries by PDO"),

   156

            "column_size": 150,

   157

            "default": 255,

   158

            "description": _(

   159

"""Maximal number of entries mapped in a PDO

   160

including empty entries used for PDO alignment""")}),

   161

        ("add_pdo", {

   162

            "column_label": _("Creating new PDO"), 

   163

            "column_size": 150,

   164

            "default": 0,

   165

            "description": _(

   166

"""Adding a PDO not defined in default configuration

   167

for mapping needed location variables

   168

(1 if possible)""")})

   169

    ]

   170

   171

    def __init__(self, path, parent_library=None):

   172

        self.Path = path

   173

        if not os.path.exists(self.Path):

   174

            os.makedirs(self.Path)

   175

        self.ParentLibrary = parent_library

   176

   177

        if parent_library is not None:

   178

            self.LoadModules()

   179

        else:

   180

            self.Library = None

   181

        self.LoadModulesExtraParams()

   182

   183

    def GetPath(self):

   184

        return self.Path

   185

   186

    def GetModulesExtraParamsFilePath(self):

   187

        return os.path.join(self.Path, "modules_extra_params.cfg")

   188

   191

    def LoadModules(self):

   192

        self.Library = {}

   193

   194

        files = os.listdir(self.Path)

   195

        for file in files:

   196

            filepath = os.path.join(self.Path, file)

   197

            if os.path.isfile(filepath) and os.path.splitext(filepath)[-1] == ".xml":

   200

                xmlfile = open(filepath, 'r')

   206

                xmlfile.close()

   207

   208

                if self.modules_infos is not None:

   209

                    vendor = self.modules_infos.getVendor()

   210

   215

   217

                        group_type = group.getType()

   218

   225

   227

                        device_group = device.getGroupType()

   228

                        if not vendor_category["groups"].has_key(device_group):

   229

                            raise ValueError, "Not such group \"%\"" % device_group

   232

   233

        return self.Library 

   234

   235

    def GetModulesLibrary(self, profile_filter=None):

   236

        if self.Library is None:

   237

            self.LoadModules()

   238

        library = []

   239

        for vendor_id, vendor in self.Library.iteritems():

   240

            groups = []

   241

            children_dict = {}

   242

            for group_type, group in vendor["groups"].iteritems():

   243

                group_infos = {"name": group["name"],

   244

                               "order": group["order"],

   245

                               "type": ETHERCAT_GROUP,

   246

                               "infos": None,

   247

                               "children": children_dict.setdefault(group_type, [])}

   248

                device_dict = {}

   249

                for device_type, device in group["devices"]:

   250

                    if profile_filter is None or profile_filter in device.GetProfileNumbers():

   251

                        product_code = device.getType().getProductCode()

   252

                        revision_number = device.getType().getRevisionNo()

   253

                        module_infos = {"device_type": device_type,

   254

                                        "vendor": vendor_id,

   255

                                        "product_code": product_code,

   256

                                        "revision_number": revision_number}

   257

                        module_infos.update(self.GetModuleExtraParams(vendor_id, product_code, revision_number))

   258

                        device_infos = {"name": ExtractName(device.getName()),

   259

                                        "type": ETHERCAT_DEVICE,

   260

                                        "infos": module_infos,

   261

                                        "children": []}

   262

                        group_infos["children"].append(device_infos)

   263

                        device_type_occurrences = device_dict.setdefault(device_type, [])

   264

                        device_type_occurrences.append(device_infos)

   265

                for device_type_occurrences in device_dict.itervalues():

   266

                    if len(device_type_occurrences) > 1:

   267

                        for occurrence in device_type_occurrences:

   268

                            occurrence["name"] += _(" (rev. %s)") % occurrence["infos"]["revision_number"]

   269

                if len(group_infos["children"]) > 0:

   270

                    if group["parent"] is not None:

   271

                        parent_children = children_dict.setdefault(group["parent"], [])

   272

                        parent_children.append(group_infos)

   273

                    else:

   274

                        groups.append(group_infos)

   275

            if len(groups) > 0:

   276

                library.append({"name": vendor["name"],

   277

                                "type": ETHERCAT_VENDOR,

   278

                                "infos": None,

   279

                                "children": groups})

   280

        library.sort(lambda x, y: cmp(x["name"], y["name"]))

   281

        return library

   282

   283

    def GetVendors(self):

   284

        return [(vendor_id, vendor["name"]) for vendor_id, vendor in self.Library.items()]

   285

   286

    def GetModuleInfos(self, module_infos):

   287

        vendor = ExtractHexDecValue(module_infos["vendor"])

   288

        vendor_infos = self.Library.get(vendor)

   289

        if vendor_infos is not None:

   290

            for group_name, group_infos in vendor_infos["groups"].iteritems():

   291

                for device_type, device_infos in group_infos["devices"]:

   292

                    product_code = ExtractHexDecValue(device_infos.getType().getProductCode())

   293

                    revision_number = ExtractHexDecValue(device_infos.getType().getRevisionNo())

   294

                    if (product_code == ExtractHexDecValue(module_infos["product_code"]) and

   295

                        revision_number == ExtractHexDecValue(module_infos["revision_number"])):

   296

                        self.cntdevice = device_infos 

   297

                        self.cntdeviceType = device_type  

   298

                        return device_infos, self.GetModuleExtraParams(vendor, product_code, revision_number)

   299

        return None, None

   300

   301

    def ImportModuleLibrary(self, filepath):

   302

        if os.path.isfile(filepath):

   303

            shutil.copy(filepath, self.Path)

   304

            self.LoadModules()

   305

            return True

   306

        return False

   307

   308

    def LoadModulesExtraParams(self):

   309

        self.ModulesExtraParams = {}

   310

   311

        csvfile_path = self.GetModulesExtraParamsFilePath()

   312

        if os.path.exists(csvfile_path):

   313

            csvfile = open(csvfile_path, "rb")

   314

            sample = csvfile.read(1024)

   315

            csvfile.seek(0)

   316

            dialect = csv.Sniffer().sniff(sample)

   317

            has_header = csv.Sniffer().has_header(sample)

   318

            reader = csv.reader(csvfile, dialect)

   319

            for row in reader:

   320

                if has_header:

   321

                    has_header = False

   322

                else:

   323

                    params_values = {}

   324

                    for (param, param_infos), value in zip(

   325

                        self.MODULES_EXTRA_PARAMS, row[3:]):

   326

                        if value != "":

   327

                            params_values[param] = int(value)

   328

                    self.ModulesExtraParams[

   329

                        tuple(map(int, row[:3]))] = params_values

   330

            csvfile.close()

   331

   332

    def SaveModulesExtraParams(self):

   333

        csvfile = open(self.GetModulesExtraParamsFilePath(), "wb")

   334

        extra_params = [param for param, params_infos in self.MODULES_EXTRA_PARAMS]

   335

        writer = csv.writer(csvfile, delimiter=';')

   336

        writer.writerow(['Vendor', 'product_code', 'revision_number'] + extra_params)

   337

        for (vendor, product_code, revision_number), module_extra_params in self.ModulesExtraParams.iteritems():

   338

            writer.writerow([vendor, product_code, revision_number] + 

   339

                            [module_extra_params.get(param, '') 

   340

                             for param in extra_params])

   341

        csvfile.close()

   342

   343

    def SetModuleExtraParam(self, vendor, product_code, revision_number, param, value):

   344

        vendor = ExtractHexDecValue(vendor)

   345

        product_code = ExtractHexDecValue(product_code)

   346

        revision_number = ExtractHexDecValue(revision_number)

   347

   348

        module_infos = (vendor, product_code, revision_number)

   349

        self.ModulesExtraParams.setdefault(module_infos, {})

   350

        self.ModulesExtraParams[module_infos][param] = value

   351

   352

        self.SaveModulesExtraParams()

   353

   354

    def GetModuleExtraParams(self, vendor, product_code, revision_number):

   355

        vendor = ExtractHexDecValue(vendor)

   356

        product_code = ExtractHexDecValue(product_code)

   357

        revision_number = ExtractHexDecValue(revision_number)

   358

   359

        if self.ParentLibrary is not None:

   360

            extra_params = self.ParentLibrary.GetModuleExtraParams(vendor, product_code, revision_number)

   361

        else:

   362

            extra_params = {}

   363

   364

        extra_params.update(self.ModulesExtraParams.get((vendor, product_code, revision_number), {}))

   365

   366

        for param, param_infos in self.MODULES_EXTRA_PARAMS:

   367

            extra_params.setdefault(param, param_infos["default"])

   368

   369

        return extra_params

   370

   371

USERDATA_DIR = wx.StandardPaths.Get().GetUserDataDir()

   372

if wx.Platform != '__WXMSW__':

   373

    USERDATA_DIR += '_files'

   374

   375

ModulesDatabase = ModulesLibrary(

   376

    os.path.join(USERDATA_DIR, "ethercat_modules"))

   377

   378

class RootClass:

   379

   380

    CTNChildrenTypes = [("EthercatNode",_EthercatCTN,"Ethercat Master")]

   381

    EditorType = LibraryEditor

   384

    def __init__(self):

   385

        self.ModulesLibrary = None

   386

        self.LoadModulesLibrary()

   387

   388

    def GetIconName(self):

   389

        return "Ethercat"

   390

   391

    def GetModulesLibraryPath(self, project_path=None):

   392

        if project_path is None:

   393

            project_path = self.CTNPath()

   394

        return os.path.join(project_path, "modules") 

   395

   396

    def OnCTNSave(self, from_project_path=None):

   397

        if from_project_path is not None:

   398

            shutil.copytree(self.GetModulesLibraryPath(from_project_path),

   399

                            self.GetModulesLibraryPath())

   400

        return True

   401

   402

    def CTNGenerate_C(self, buildpath, locations):

   403

        return [],"",False

   404

   405

    def LoadModulesLibrary(self):

   406

        if self.ModulesLibrary is None:

   407

            self.ModulesLibrary = ModulesLibrary(self.GetModulesLibraryPath(), ModulesDatabase)

   408

        else:

   409

            self.ModulesLibrary.LoadModulesLibrary()

   410

   411

    def GetModulesDatabaseInstance(self):

   412

        return ModulesDatabase

   413

   414

    def GetModulesLibraryInstance(self):

   415

        return self.ModulesLibrary

   416

   417

    def GetModulesLibrary(self, profile_filter=None):

   418

        return self.ModulesLibrary.GetModulesLibrary(profile_filter)

   419

   420

    def GetVendors(self):

   421

        return self.ModulesLibrary.GetVendors()

   422

   423

    def GetModuleInfos(self, module_infos):

   424

        return self.ModulesLibrary.GetModuleInfos(module_infos)

   425