1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os, sys, shutil

    26

    27

base_folder = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))

    28

CanFestivalPath = os.path.join(base_folder, "CanFestival-3")

    29

sys.path.append(os.path.join(CanFestivalPath, "objdictgen"))

    30

    31

import wx

    32

    33

from nodelist import NodeList

    34

from nodemanager import NodeManager

    35

import config_utils, gen_cfile, eds_utils

    36

import canfestival_config as local_canfestival_config

    37

from ConfigTreeNode import ConfigTreeNode

    38

from commondialogs import CreateNodeDialog

    39

from subindextable import IECTypeConversion, SizeConversion

    40

    41

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

    42

from SlaveEditor import SlaveEditor, MasterViewer

    43

from NetworkEditor import NetworkEditor

    44

    45

from gnosis.xml.pickle import *

    46

from gnosis.xml.pickle.util import setParanoia

    47

setParanoia(0)

    48

    49

from util.TranslationCatalogs import AddCatalog

    50

AddCatalog(os.path.join(CanFestivalPath, "objdictgen", "locale"))

    51

    52

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

    53

#              Location Tree Helper

    54

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

    55

    56

def GetSlaveLocationTree(slave_node, current_location, name):

    57

    entries = []

    58

    for index, subindex, size, entry_name in slave_node.GetMapVariableList():

    59

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    60

        typeinfos = slave_node.GetEntryInfos(subentry_infos["type"])

    61

        if typeinfos:

    62

            entries.append({

    63

                "name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry_name),

    64

                "type": LOCATION_VAR_MEMORY,

    65

                "size": size,

    66

                "IEC_type": IECTypeConversion.get(typeinfos["name"]),

    67

                "var_name": "%s_%4.4x_%2.2x" % ("_".join(name.split()), index, subindex),

    68

                "location": "%s%s"%(SizeConversion[size], ".".join(map(str, current_location + 

    69

                                                                                (index, subindex)))),

    70

                "description": "",

    71

                "children": []})

    72

    return  {"name": name,

    73

             "type": LOCATION_CONFNODE,

    74

             "location": ".".join([str(i) for i in current_location]) + ".x",

    75

             "children": entries

    76

    }

    77

    78

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

    79

#                    SLAVE

    80

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

    81

    82

class _SlaveCTN(NodeManager):

    83

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

    84

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

    85

      <xsd:element name="CanFestivalSlaveNode">

    86

        <xsd:complexType>

    87

          <xsd:attribute name="CAN_Device" type="xsd:string" use="optional"/>

    88

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional"/>

    89

          <xsd:attribute name="NodeId" type="xsd:integer" use="optional" default="2"/>

    90

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

    91

          <xsd:attribute name="Sync_Align_Ratio" use="optional" default="50">

    92

            <xsd:simpleType>

    93

                <xsd:restriction base="xsd:integer">

    94

                    <xsd:minInclusive value="1"/>

    95

                    <xsd:maxInclusive value="99"/>

    96

                </xsd:restriction>

    97

            </xsd:simpleType>

    98

          </xsd:attribute>

    99

        </xsd:complexType>

   100

      </xsd:element>

   101

    </xsd:schema>

   102

    """

   103

   104

    EditorType = SlaveEditor

   105

    IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

   106

   107

    def __init__(self):

   108

        # TODO change netname when name change

   109

        NodeManager.__init__(self)

   110

        odfilepath = self.GetSlaveODPath()

   111

        if(os.path.isfile(odfilepath)):

   112

            self.OpenFileInCurrent(odfilepath)

   113

        else:

   114

            self.FilePath = ""

   115

            dialog = CreateNodeDialog(None, wx.OK)

   116

            dialog.Type.Enable(False)

   117

            dialog.GenSYNC.Enable(False)

   118

            if dialog.ShowModal() == wx.ID_OK:

   119

                name, id, nodetype, description = dialog.GetValues()

   120

                profile, filepath = dialog.GetProfile()

   121

                NMT = dialog.GetNMTManagement()

   122

                options = dialog.GetOptions()

   123

                self.CreateNewNode(name,       # Name - will be changed at build time

   124

                                   id,         # NodeID - will be changed at build time

   125

                                   "slave",    # Type

   126

                                   description,# description 

   127

                                   profile,    # profile

   128

                                   filepath,   # prfile filepath

   129

                                   NMT,        # NMT

   130

                                   options)     # options

   131

            else:

   132

                self.CreateNewNode("SlaveNode",  # Name - will be changed at build time

   133

                                   0x00,         # NodeID - will be changed at build time

   134

                                   "slave",      # Type

   135

                                   "",           # description 

   136

                                   "None",       # profile

   137

                                   "", # prfile filepath

   138

                                   "heartbeat",  # NMT

   139

                                   [])           # options

   140

            dialog.Destroy()

   141

            self.OnCTNSave()

   142

   143

    def GetCurrentNodeName(self):

   144

        return self.CTNName()

   145

   146

    def GetSlaveODPath(self):

   147

        return os.path.join(self.CTNPath(), 'slave.od')

   148

   149

    def GetCanDevice(self):

   150

        return self.CanFestivalSlaveNode.getCAN_Device()

   151

   152

    def _OpenView(self, name=None, onlyopened=False):

   153

        ConfigTreeNode._OpenView(self, name, onlyopened)

   154

        if self._View is not None:

   155

            self._View.SetBusId(self.GetCurrentLocation())

   156

        return self._View

   157

   158

    def _ExportSlave(self):

   159

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame, 

   160

                               _("Choose a file"), 

   161

                               os.path.expanduser("~"), 

   162

                               "%s.eds" % self.CTNName(),  

   163

                               _("EDS files (*.eds)|*.eds|All files|*.*"),

   164

                               wx.SAVE|wx.OVERWRITE_PROMPT)

   165

        if dialog.ShowModal() == wx.ID_OK:

   166

            result = eds_utils.GenerateEDSFile(dialog.GetPath(), self.GetCurrentNodeCopy())

   167

            if result:

   168

                self.GetCTRoot().logger.write_error(_("Error: Export slave failed\n"))

   169

        dialog.Destroy()  

   170

   171

    ConfNodeMethods = [

   172

        {"bitmap" : "ExportSlave",

   173

         "name" : _("Export slave"), 

   174

         "tooltip" : _("Export CanOpen slave to EDS file"),

   175

         "method" : "_ExportSlave"},

   176

    ]

   177

   178

    def CTNTestModified(self):

   179

        return self.ChangesToSave or self.OneFileHasChanged()

   180

   181

    def OnCTNSave(self, from_project_path=None):

   182

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   183

   184

    def SetParamsAttribute(self, path, value):

   185

        result = ConfigTreeNode.SetParamsAttribute(self, path, value)

   186

   187

        # Filter IEC_Channel and Name, that have specific behavior

   188

        if path == "BaseParams.IEC_Channel" and self._View is not None:

   189

            self._View.SetBusId(self.GetCurrentLocation())

   190

   191

        return result

   192

   193

    def GetVariableLocationTree(self):

   194

        current_location = self.GetCurrentLocation()

   195

        return GetSlaveLocationTree(self.CurrentNode, 

   196

                                    self.GetCurrentLocation(), 

   197

                                    self.BaseParams.getName())

   198

   199

    def CTNGenerate_C(self, buildpath, locations):

   200

        """

   201

        Generate C code

   202

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

   203

        @param locations: List of complete variables locations \

   204

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

   205

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

   206

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

   207

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

   208

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

   209

            }, ...]

   210

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

   211

        """

   212

        current_location = self.GetCurrentLocation()

   213

        # define a unique name for the generated C file

   214

        prefix = "_".join(map(str, current_location))

   215

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   216

        # Create a new copy of the model

   217

        slave = self.GetCurrentNodeCopy()

   218

        slave.SetNodeName("OD_%s"%prefix)

   219

        # allow access to local OD from Slave PLC

   220

        pointers = config_utils.LocalODPointers(locations, current_location, slave)

   221

        res = gen_cfile.GenerateFile(Gen_OD_path, slave, pointers)

   222

        if res :

   223

            raise Exception, res

   224

        res = eds_utils.GenerateEDSFile(os.path.join(buildpath, "Slave_%s.eds"%prefix), slave)

   225

        if res :

   226

            raise Exception, res

   227

        return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   228

   229

    def LoadPrevious(self):

   230

        self.LoadCurrentPrevious()

   231

   232

    def LoadNext(self):

   233

        self.LoadCurrentNext()

   234

   235

    def GetBufferState(self):

   236

        return self.GetCurrentBufferState()

   237

   238

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

   239

#                    MASTER

   240

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

   241

   242

class MiniNodeManager(NodeManager):

   243

   244

    def __init__(self, parent, filepath, fullname):

   245

        NodeManager.__init__(self)

   246

   247

        self.OpenFileInCurrent(filepath)

   248

   249

        self.Parent = parent

   250

        self.Fullname = fullname

   251

   252

    def GetIconName(self):

   253

        return None

   254

   255

    def OnCloseEditor(self, view):

   256

        self.Parent.OnCloseEditor(view)

   257

   258

    def CTNFullName(self):

   259

        return self.Fullname

   260

   261

    def CTNTestModified(self):

   262

        return False

   263

   264

    def GetBufferState(self):

   265

        return self.GetCurrentBufferState()

   266

   267

    ConfNodeMethods = []

   268

   269

class _NodeManager(NodeManager):

   270

   271

    def __init__(self, parent, *args, **kwargs):

   272

        NodeManager.__init__(self, *args, **kwargs)

   273

        self.Parent = parent

   274

   275

    def __del__(self):

   276

        self.Parent = None

   277

   278

    def GetCurrentNodeName(self):

   279

        return self.Parent.CTNName()

   280

   281

    def GetCurrentNodeID(self):

   282

        return self.Parent.CanFestivalNode.getNodeId()

   283

   284

class _NodeListCTN(NodeList):

   285

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

   286

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

   287

      <xsd:element name="CanFestivalNode">

   288

        <xsd:complexType>

   289

          <xsd:attribute name="CAN_Device" type="xsd:string" use="optional"/>

   290

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional"/>

   291

          <xsd:attribute name="NodeId" type="xsd:integer" use="optional" default="1"/>

   292

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

   293

        </xsd:complexType>

   294

      </xsd:element>

   295

    </xsd:schema>

   296

    """ 

   297

   298

    EditorType = NetworkEditor

   299

    IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

   300

   301

    def __init__(self):

   302

        manager = _NodeManager(self)

   303

        NodeList.__init__(self, manager)

   304

        self.LoadProject(self.CTNPath())

   305

        self.SetNetworkName(self.BaseParams.getName())

   306

   307

    def GetCanDevice(self):

   308

        return self.CanFestivalNode.getCAN_Device()

   309

   310

    def SetParamsAttribute(self, path, value):

   311

        if path == "CanFestivalNode.NodeId":

   312

            nodeid = self.CanFestivalNode.getNodeId()

   313

            if value != nodeid:

   314

                slaves = self.GetSlaveIDs()

   315

                dir = (value - nodeid) / abs(value - nodeid)

   316

                while value in slaves and value >= 0:

   317

                    value += dir

   318

                if value < 0:

   319

                    value = nodeid

   320

   321

        value, refresh = ConfigTreeNode.SetParamsAttribute(self, path, value)

   322

        refresh_network = False

   323

   324

        # Filter IEC_Channel and Name, that have specific behavior

   325

        if path == "BaseParams.IEC_Channel" and self._View is not None:

   326

            self._View.SetBusId(self.GetCurrentLocation())

   327

        elif path == "BaseParams.Name":

   328

            self.SetNetworkName(value)

   329

            refresh_network = True

   330

        elif path == "CanFestivalNode.NodeId":

   331

            refresh_network = True

   332

   333

        if refresh_network and self._View is not None:

   334

            wx.CallAfter(self._View.RefreshBufferState)

   335

        return value, refresh

   336

   337

    def GetVariableLocationTree(self):

   338

        current_location = self.GetCurrentLocation()

   339

        nodeindexes = self.SlaveNodes.keys()

   340

        nodeindexes.sort()

   341

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

   342

                 "type": LOCATION_CONFNODE,

   343

                 "location": self.GetFullIEC_Channel(),

   344

                 "children": [GetSlaveLocationTree(self.Manager.GetCurrentNodeCopy(),

   345

                                                   current_location,

   346

                                                   _("Local entries"))] + 

   347

                             [GetSlaveLocationTree(self.SlaveNodes[nodeid]["Node"], 

   348

                                                   current_location + (nodeid,), 

   349

                                                   self.SlaveNodes[nodeid]["Name"])

   350

                              for nodeid in nodeindexes]

   351

        }

   352

   353

    _GeneratedMasterView = None

   354

    def _ShowGeneratedMaster(self):

   355

        self._OpenView("Generated master")

   356

   357

    def _OpenView(self, name=None, onlyopened=False):

   358

        if name == "Generated master":

   359

            app_frame = self.GetCTRoot().AppFrame

   360

            if self._GeneratedMasterView is None:

   361

                buildpath = self._getBuildPath()

   362

                # Eventually create build dir

   363

                if not os.path.exists(buildpath):

   364

                    self.GetCTRoot().logger.write_error(_("Error: No PLC built\n"))

   365

                    return

   366

   367

                masterpath = os.path.join(buildpath, "MasterGenerated.od")

   368

                if not os.path.exists(masterpath):

   369

                    self.GetCTRoot().logger.write_error(_("Error: No Master generated\n"))

   370

                    return

   371

   372

                manager = MiniNodeManager(self, masterpath, self.CTNFullName())

   373

                self._GeneratedMasterView = MasterViewer(app_frame.TabsOpened, manager, app_frame, name)

   374

   375

            if self._GeneratedMasterView is not None:

   376

                app_frame.EditProjectElement(self._GeneratedMasterView, self._GeneratedMasterView.GetInstancePath())

   377

   378

            return self._GeneratedMasterView

   379

        else:

   380

            ConfigTreeNode._OpenView(self, name, onlyopened)

   381

            if self._View is not None:

   382

                self._View.SetBusId(self.GetCurrentLocation())

   383

            return self._View

   384

   385

    ConfNodeMethods = [

   386

        {"bitmap" : "ShowMaster",

   387

         "name" : _("Show Master"), 

   388

         "tooltip" : _("Show Master generated by config_utils"),

   389

         "method" : "_ShowGeneratedMaster"}

   390

    ]

   391

   392

    def OnCloseEditor(self, view):

   393

        ConfigTreeNode.OnCloseEditor(self, view)

   394

        if self._GeneratedMasterView == view:

   395

            self._GeneratedMasterView = None

   396

   397

    def OnCTNClose(self):

   398

        ConfigTreeNode.OnCTNClose(self)

   399

        self._CloseView(self._GeneratedMasterView)

   400

        return True

   401

   402

    def CTNTestModified(self):

   403

        return self.ChangesToSave or self.HasChanged()

   404

   405

    def OnCTNSave(self, from_project_path=None):

   406

        self.SetRoot(self.CTNPath())

   407

        if from_project_path is not None:

   408

            shutil.copytree(self.GetEDSFolder(from_project_path), 

   409

                            self.GetEDSFolder())

   410

        return self.SaveProject() is None

   411

   412

    def CTNGenerate_C(self, buildpath, locations):

   413

        """

   414

        Generate C code

   415

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

   416

        @param locations: List of complete variables locations \

   417

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

   418

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

   419

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

   420

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

   421

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

   422

            }, ...]

   423

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

   424

        """

   425

        self._CloseView(self._GeneratedMasterView)

   426

        current_location = self.GetCurrentLocation()

   427

        # define a unique name for the generated C file

   428

        prefix = "_".join(map(str, current_location))

   429

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   430

        # Create a new copy of the model with DCF loaded with PDO mappings for desired location

   431

        try:

   432

            master, pointers = config_utils.GenerateConciseDCF(locations, current_location, self, self.CanFestivalNode.getSync_TPDOs(),"OD_%s"%prefix)

   433

        except config_utils.PDOmappingException, e:

   434

            raise Exception, e.message

   435

        # Do generate C file.

   436

        res = gen_cfile.GenerateFile(Gen_OD_path, master, pointers)

   437

        if res :

   438

            raise Exception, res

   439

   440

        file = open(os.path.join(buildpath, "MasterGenerated.od"), "w")

   441

        dump(master, file)

   442

        file.close()

   443

   444

        return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   445

   446

    def LoadPrevious(self):

   447

        self.Manager.LoadCurrentPrevious()

   448

   449

    def LoadNext(self):

   450

        self.Manager.LoadCurrentNext()

   451

   452

    def GetBufferState(self):

   453

        return self.Manager.GetCurrentBufferState()

   454

   455

class RootClass:

   456

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

   457

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

   458

      <xsd:element name="CanFestivalInstance">

   459

        <xsd:complexType>

   460

          <xsd:attribute name="CAN_Driver" type="xsd:string" use="optional"/>

   461

        </xsd:complexType>

   462

      </xsd:element>

   463

    </xsd:schema>

   464

    """

   465

   466

    CTNChildrenTypes = [("CanOpenNode",_NodeListCTN, "CanOpen Master"),

   467

                       ("CanOpenSlave",_SlaveCTN, "CanOpen Slave")]

   468

    def GetParamsAttributes(self, path = None):

   469

        infos = ConfigTreeNode.GetParamsAttributes(self, path = path)

   470

        for element in infos:

   471

            if element["name"] == "CanFestivalInstance":

   472

                for child in element["children"]:

   473

                    if child["name"] == "CAN_Driver":

   474

                        child["type"] = local_canfestival_config.DLL_LIST

   475

        return infos

   476

   477

    def GetCanDriver(self):

   478

        res = self.CanFestivalInstance.getCAN_Driver()

   479

        if not res :

   480

            return ""

   481

        return res

   482

   483

    def CTNGenerate_C(self, buildpath, locations):

   484

        can_driver = self.GetCanDriver()

   485

        if can_driver is not None: