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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

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

    14

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

    15

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

    16

#

    17

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

    18

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

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

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

    25

    30

import util.paths as paths

    31

    32

base_folder = paths.AbsParentDir(__file__, 2)

    33

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

    34

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

    35

    36

import wx

    37

    38

from nodelist import NodeList

    39

from nodemanager import NodeManager

    43

import canfestival_config as local_canfestival_config

    44

from ConfigTreeNode import ConfigTreeNode

    45

from commondialogs import CreateNodeDialog

    46

from subindextable import IECTypeConversion, SizeConversion

    47

    48

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

    49

from SlaveEditor import SlaveEditor, MasterViewer

    50

from NetworkEditor import NetworkEditor

    51

    52

from gnosis.xml.pickle import *

    53

from gnosis.xml.pickle.util import setParanoia

    54

setParanoia(0)

    55

    56

from util.TranslationCatalogs import AddCatalog

    57

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

    58

    59

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

    60

#              Location Tree Helper

    61

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

    62

    63

def GetSlaveLocationTree(slave_node, current_location, name):

    64

    entries = []

    65

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

    66

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    67

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

    68

        if typeinfos:

    69

            entries.append({

    70

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

    71

                "type": LOCATION_VAR_MEMORY,

    72

                "size": size,

    73

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

    74

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

    75

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

    76

                                                                                (index, subindex)))),

    77

                "description": "",

    78

                "children": []})

    79

    return  {"name": name,

    80

             "type": LOCATION_CONFNODE,

    81

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

    82

             "children": entries

    83

    }

    84

    85

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

    86

#                    SLAVE

    87

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

    88

    89

class _SlaveCTN(NodeManager):

    90

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

    91

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

    92

      <xsd:element name="CanFestivalSlaveNode">

    93

        <xsd:complexType>

    94

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

    95

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

    96

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

    97

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

    98

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

    99

            <xsd:simpleType>

   100

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

   101

                    <xsd:minInclusive value="1"/>

   102

                    <xsd:maxInclusive value="99"/>

   103

                </xsd:restriction>

   104

            </xsd:simpleType>

   105

          </xsd:attribute>

   106

        </xsd:complexType>

   107

      </xsd:element>

   108

    </xsd:schema>

   109

    """

   110

   111

    EditorType = SlaveEditor

   112

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

   113

   114

    def __init__(self):

   115

        # TODO change netname when name change

   116

        NodeManager.__init__(self)

   117

        odfilepath = self.GetSlaveODPath()

   118

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

   119

            self.OpenFileInCurrent(odfilepath)

   120

        else:

   121

            self.FilePath = ""

   122

            dialog = CreateNodeDialog(None, wx.OK)

   123

            dialog.Type.Enable(False)

   124

            dialog.GenSYNC.Enable(False)

   125

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

   126

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

   127

                profile, filepath = dialog.GetProfile()

   128

                NMT = dialog.GetNMTManagement()

   129

                options = dialog.GetOptions()

   130

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

   131

                                   id,         # NodeID - will be changed at build time

   132

                                   "slave",    # Type

   133

                                   description,# description

   134

                                   profile,    # profile

   135

                                   filepath,   # prfile filepath

   136

                                   NMT,        # NMT

   137

                                   options)     # options

   138

            else:

   139

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

   140

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

   141

                                   "slave",      # Type

   142

                                   "",           # description

   143

                                   "None",       # profile

   144

                                   "", # prfile filepath

   145

                                   "heartbeat",  # NMT

   146

                                   [])           # options

   147

            dialog.Destroy()

   148

            self.OnCTNSave()

   149

   150

    def GetCurrentNodeName(self):

   151

        return self.CTNName()

   152

   153

    def GetSlaveODPath(self):

   154

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

   155

   156

    def GetCanDevice(self):

   157

        return self.CanFestivalSlaveNode.getCAN_Device()

   158

   159

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

   160

        ConfigTreeNode._OpenView(self, name, onlyopened)

   161

        if self._View is not None:

   162

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

   163

        return self._View

   164

   165

    def _ExportSlave(self):

   166

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

   167

                               _("Choose a file"),

   168

                               os.path.expanduser("~"),

   169

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

   170

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

   171

                               wx.SAVE|wx.OVERWRITE_PROMPT)

   172

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

   173

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

   174

            if result:

   175

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

   176

        dialog.Destroy()

   177

   178

    ConfNodeMethods = [

   179

        {"bitmap" : "ExportSlave",

   180

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

   181

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

   182

         "method" : "_ExportSlave"},

   183

    ]

   184

   185

    def CTNTestModified(self):

   186

        return self.ChangesToSave or self.OneFileHasChanged()

   187

   188

    def OnCTNSave(self, from_project_path=None):

   189

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   190

   191

    def SetParamsAttribute(self, path, value):

   192

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

   193

   194

        # Filter IEC_Channel and Name, that have specific behavior

   195

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

   196

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

   197

   198

        return result

   199

   200

    def GetVariableLocationTree(self):

   201

        current_location = self.GetCurrentLocation()

   202

        return GetSlaveLocationTree(self.CurrentNode,

   203

                                    self.GetCurrentLocation(),

   204

                                    self.BaseParams.getName())

   205

   206

    def CTNGenerate_C(self, buildpath, locations):

   207

        """

   208

        Generate C code

   209

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

   210

        @param locations: List of complete variables locations \

   211

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

   212

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

   213

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

   214

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

   215

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

   216

            }, ...]

   217

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

   218

        """

   219

        current_location = self.GetCurrentLocation()

   220

        # define a unique name for the generated C file

   221

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

   222

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

   223

        # Create a new copy of the model

   224

        slave = self.GetCurrentNodeCopy()

   225

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

   226

        # allow access to local OD from Slave PLC

   227

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

   228

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

   229

        if res :

   230

            raise Exception, res

   231

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

   232

        if res :

   233

            raise Exception, res

   234

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

   235

   236

    def LoadPrevious(self):

   237

        self.LoadCurrentPrevious()

   238

   239

    def LoadNext(self):

   240

        self.LoadCurrentNext()

   241

   242

    def GetBufferState(self):

   243

        return self.GetCurrentBufferState()

   244

   245

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

   246

#                    MASTER

   247

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

   248

   249

class MiniNodeManager(NodeManager):

   250

   251

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

   252

        NodeManager.__init__(self)

   253

   254

        self.OpenFileInCurrent(filepath)

   255

   256

        self.Parent = parent

   257

        self.Fullname = fullname

   258

   259

    def GetIconName(self):

   260

        return None

   261

   262

    def OnCloseEditor(self, view):

   263

        self.Parent.OnCloseEditor(view)

   264

   265

    def CTNFullName(self):

   266

        return self.Fullname

   267

   268

    def CTNTestModified(self):

   269

        return False

   270

   271

    def GetBufferState(self):

   272

        return self.GetCurrentBufferState()

   273

   274

    ConfNodeMethods = []

   275

   276

class _NodeManager(NodeManager):

   277

   278

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

   279

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

   280

        self.Parent = parent

   281

   282

    def __del__(self):

   283

        self.Parent = None

   284

   285

    def GetCurrentNodeName(self):

   286

        return self.Parent.CTNName()

   287

   288

    def GetCurrentNodeID(self):

   289

        return self.Parent.CanFestivalNode.getNodeId()

   290

   291

class _NodeListCTN(NodeList):

   292

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

   293

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

   294

      <xsd:element name="CanFestivalNode">

   295

        <xsd:complexType>

   296

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

   297

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

   298

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

   299

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

   300

        </xsd:complexType>

   301

      </xsd:element>

   302

    </xsd:schema>

   303

    """

   304

   305

    EditorType = NetworkEditor

   306

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

   307

   308

    def __init__(self):

   309

        manager = _NodeManager(self)

   310

        NodeList.__init__(self, manager)

   311

        self.LoadProject(self.CTNPath())

   312

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

   313

   314

    def GetCanDevice(self):

   315

        return self.CanFestivalNode.getCAN_Device()

   316

   317

    def SetParamsAttribute(self, path, value):

   318

        if path == "CanFestivalNode.NodeId":

   319

            nodeid = self.CanFestivalNode.getNodeId()

   320

            if value != nodeid:

   321

                slaves = self.GetSlaveIDs()

   322

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

   323

                while value in slaves and value >= 0:

   324

                    value += dir

   325

                if value < 0:

   326

                    value = nodeid

   327

   328

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

   329

        refresh_network = False

   330

   331

        # Filter IEC_Channel and Name, that have specific behavior

   332

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

   333

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

   334

        elif path == "BaseParams.Name":

   335

            self.SetNetworkName(value)

   336

            refresh_network = True

   337

        elif path == "CanFestivalNode.NodeId":

   338

            refresh_network = True

   339

   340

        if refresh_network and self._View is not None:

   341

            wx.CallAfter(self._View.RefreshBufferState)

   342

        return value, refresh

   343

   344

    def GetVariableLocationTree(self):

   345

        current_location = self.GetCurrentLocation()

   346

        nodeindexes = self.SlaveNodes.keys()

   347

        nodeindexes.sort()

   348

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

   349

                 "type": LOCATION_CONFNODE,

   350

                 "location": self.GetFullIEC_Channel(),

   351

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

   352

                                                   current_location,

   353

                                                   _("Local entries"))] +

   354

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

   355

                                                   current_location + (nodeid,),

   356

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

   357

                              for nodeid in nodeindexes]

   358

        }

   359

   360

    _GeneratedMasterView = None

   361

    def _ShowGeneratedMaster(self):

   362

        self._OpenView("Generated master")

   363

   364

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

   365

        if name == "Generated master":

   366

            app_frame = self.GetCTRoot().AppFrame

   367

            if self._GeneratedMasterView is None:

   368

                buildpath = self._getBuildPath()

   369

                # Eventually create build dir

   370

                if not os.path.exists(buildpath):

   371

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

   372

                    return

   373

   374

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

   375

                if not os.path.exists(masterpath):

   376

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

   377

                    return

   378

   379

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

   380

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

   381

   382

            if self._GeneratedMasterView is not None:

   383

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

   384

   385

            return self._GeneratedMasterView

   386

        else:

   387

            ConfigTreeNode._OpenView(self, name, onlyopened)

   388

            if self._View is not None:

   389

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

   390

            return self._View

   391

   392

    ConfNodeMethods = [

   393

        {"bitmap" : "ShowMaster",

   394

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

   395

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

   396

         "method" : "_ShowGeneratedMaster"}

   397

    ]

   398

   399

    def OnCloseEditor(self, view):

   400

        ConfigTreeNode.OnCloseEditor(self, view)

   401

        if self._GeneratedMasterView == view:

   402

            self._GeneratedMasterView = None

   403

   404

    def OnCTNClose(self):

   405

        ConfigTreeNode.OnCTNClose(self)

   406

        self._CloseView(self._GeneratedMasterView)

   407

        return True

   408

   409

    def CTNTestModified(self):

   410

        return self.ChangesToSave or self.HasChanged()

   411

   412

    def OnCTNSave(self, from_project_path=None):

   413

        self.SetRoot(self.CTNPath())

   414

        if from_project_path is not None:

   415

            shutil.copytree(self.GetEDSFolder(from_project_path),

   416

                            self.GetEDSFolder())

   417

        return self.SaveProject() is None

   418

   419

    def CTNGenerate_C(self, buildpath, locations):

   420

        """

   421

        Generate C code

   422

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

   423

        @param locations: List of complete variables locations \

   424

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

   425

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

   426

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

   427

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

   428

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

   429

            }, ...]

   430

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

   431

        """

   432

        self._CloseView(self._GeneratedMasterView)

   433

        current_location = self.GetCurrentLocation()

   434

        # define a unique name for the generated C file

   435

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

   436

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

   437

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

   438

        try:

   439

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

   440

        except config_utils.PDOmappingException, e:

   441

            raise Exception, e.message

   442

        # Do generate C file.

   443

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

   444

        if res :

   445

            raise Exception, res

   446

   447

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

   448

        dump(master, file)

   449

        file.close()

   450

   451

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

   452

   453

    def LoadPrevious(self):

   454

        self.Manager.LoadCurrentPrevious()

   455

   456

    def LoadNext(self):

   457

        self.Manager.LoadCurrentNext()

   458

   459

    def GetBufferState(self):

   460

        return self.Manager.GetCurrentBufferState()

   461

   462

class RootClass:

   463

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

   464

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

   465

      <xsd:element name="CanFestivalInstance">

   466

        <xsd:complexType>

   467

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

   468

        </xsd:complexType>

   469

      </xsd:element>

   470

    </xsd:schema>

   471

    """

   472

   473

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

   474

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

   475

    def GetParamsAttributes(self, path = None):

   476

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

   477

        for element in infos:

   478

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

   479

                for child in element["children"]:

   480

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

   481

                        child["type"] = local_canfestival_config.DLL_LIST