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

    26

import os

    27

import sys

    28

import shutil

    29

import wx

    30

from gnosis.xml.pickle import *

    31

from gnosis.xml.pickle.util import setParanoia

    32

    33

import util.paths as paths

    34

from util.TranslationCatalogs import AddCatalog

    35

from ConfigTreeNode import ConfigTreeNode

    36

from PLCControler import \

    37

    LOCATION_CONFNODE, \

    38

    LOCATION_MODULE, \

    39

    LOCATION_GROUP, \

    40

    LOCATION_VAR_INPUT, \

    41

    LOCATION_VAR_OUTPUT, \

    42

    LOCATION_VAR_MEMORY

    43

    44

try:

    45

    from nodelist import NodeList

    46

except ImportError:

    47

    base_folder = paths.AbsParentDir(__file__, 2)

    48

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

    49

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

    50

    51

    from nodelist import NodeList

    52

    53

from nodemanager import NodeManager

    54

import gen_cfile

    55

import eds_utils

    56

import canfestival_config as local_canfestival_config

    57

    58

from commondialogs import CreateNodeDialog

    59

from subindextable import IECTypeConversion, SizeConversion

    60

import config_utils

    61

from SlaveEditor import SlaveEditor, MasterViewer

    62

from NetworkEditor import NetworkEditor

    63

    64

    65

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

    66

setParanoia(0)

    67

    68

    69

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

    70

#              Location Tree Helper

    71

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

    72

    73

    74

def GetSlaveLocationTree(slave_node, current_location, name):

    75

    entries = []

    76

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

    77

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    78

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

    79

        if typeinfos:

    80

            entries.append({

    81

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

    82

                "type": LOCATION_VAR_MEMORY,

    83

                "size": size,

    84

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

    85

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

    86

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

    87

                                                                         (index, subindex)))),

    88

                "description": "",

    89

                "children": []})

    90

    return {"name": name,

    91

            "type": LOCATION_CONFNODE,

    92

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

    93

            "children": entries}

    94

    95

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

    96

#                    SLAVE

    97

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

    98

    99

   100

class _SlaveCTN(NodeManager):

   101

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

   102

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

   103

      <xsd:element name="CanFestivalSlaveNode">

   104

        <xsd:complexType>

   105

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

   106

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

   107

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

   108

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

   109

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

   110

            <xsd:simpleType>

   111

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

   112

                    <xsd:minInclusive value="1"/>

   113

                    <xsd:maxInclusive value="99"/>

   114

                </xsd:restriction>

   115

            </xsd:simpleType>

   116

          </xsd:attribute>

   117

        </xsd:complexType>

   118

      </xsd:element>

   119

    </xsd:schema>

   120

    """

   121

   122

    EditorType = SlaveEditor

   123

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

   124

   125

    def __init__(self):

   126

        # TODO change netname when name change

   127

        NodeManager.__init__(self)

   128

        odfilepath = self.GetSlaveODPath()

   129

        if os.path.isfile(odfilepath):

   130

            self.OpenFileInCurrent(odfilepath)

   131

        else:

   132

            self.FilePath = ""

   133

            dialog = CreateNodeDialog(None, wx.OK)

   134

            dialog.Type.Enable(False)

   135

            dialog.GenSYNC.Enable(False)

   136

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

   138

                profile, filepath = dialog.GetProfile()

   139

                NMT = dialog.GetNMTManagement()

   140

                options = dialog.GetOptions()

   141

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

   142

                                   id,           # NodeID - will be changed at build time

   143

                                   "slave",      # Type

   144

                                   description,  # description

   145

                                   profile,      # profile

   146

                                   filepath,     # prfile filepath

   147

                                   NMT,          # NMT

   148

                                   options)      # options

   149

            else:

   150

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

   151

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

   152

                                   "slave",      # Type

   153

                                   "",           # description

   154

                                   "None",       # profile

   155

                                   "",           # prfile filepath

   156

                                   "heartbeat",  # NMT

   157

                                   [])           # options

   158

            dialog.Destroy()

   159

            self.OnCTNSave()

   160

   161

    def GetCurrentNodeName(self):

   162

        return self.CTNName()

   163

   164

    def GetSlaveODPath(self):

   165

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

   166

   167

    def GetCanDevice(self):

   168

        return self.CanFestivalSlaveNode.getCAN_Device()

   169

   170

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

   171

        ConfigTreeNode._OpenView(self, name, onlyopened)

   172

        if self._View is not None:

   173

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

   174

        return self._View

   175

   176

    def _ExportSlave(self):

   177

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

   178

                               _("Choose a file"),

   179

                               os.path.expanduser("~"),

   180

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

   181

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

   182

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   183

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

   184

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

   185

            if result:

   186

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

   187

        dialog.Destroy()

   188

   189

    ConfNodeMethods = [

   190

        {

   191

            "bitmap":    "ExportSlave",

   192

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

   193

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

   194

            "method":   "_ExportSlave"

   195

        },

   196

    ]

   197

   198

    def CTNTestModified(self):

   199

        return self.ChangesToSave or self.OneFileHasChanged()

   200

   201

    def OnCTNSave(self, from_project_path=None):

   202

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   203

   204

    def SetParamsAttribute(self, path, value):

   205

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

   206

   207

        # Filter IEC_Channel and Name, that have specific behavior

   208

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

   209

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

   210

   211

        return result

   212

   213

    def GetVariableLocationTree(self):

   214

        return GetSlaveLocationTree(self.CurrentNode,

   215

                                    self.GetCurrentLocation(),

   216

                                    self.BaseParams.getName())

   217

   218

    def CTNGenerate_C(self, buildpath, locations):

   219

        """

   220

        Generate C code

   221

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

   222

        @param locations: List of complete variables locations \

   223

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

   224

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

   225

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

   226

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

   227

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

   228

            }, ...]

   229

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

   230

        """

   231

        current_location = self.GetCurrentLocation()

   232

        # define a unique name for the generated C file

   233

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

   234

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

   235

        # Create a new copy of the model

   236

        slave = self.GetCurrentNodeCopy()

   237

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

   238

        # allow access to local OD from Slave PLC

   239

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

   240

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

   241

        if res:

   242

            raise Exception(res)

   243

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

   244

        if res:

   245

            raise Exception(res)

   246

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

   247

   248

    def LoadPrevious(self):

   249

        self.LoadCurrentPrevious()

   250

   251

    def LoadNext(self):

   252

        self.LoadCurrentNext()

   253

   254

    def GetBufferState(self):

   255

        return self.GetCurrentBufferState()

   256

   257

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

   258

#                    MASTER

   259

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

   260

   261

   262

class MiniNodeManager(NodeManager):

   263

   264

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

   265

        NodeManager.__init__(self)

   266

   267

        self.OpenFileInCurrent(filepath)

   268

   269

        self.Parent = parent

   270

        self.Fullname = fullname

   271

   272

    def GetIconName(self):

   273

        return None

   274

   275

    def OnCloseEditor(self, view):

   276

        self.Parent.OnCloseEditor(view)

   277

   278

    def CTNFullName(self):

   279

        return self.Fullname

   280

   281

    def CTNTestModified(self):

   282

        return False

   283

   284

    def GetBufferState(self):

   285

        return self.GetCurrentBufferState()

   286

   287

    ConfNodeMethods = []

   288

   289

   290

class _NodeManager(NodeManager):

   291

   292

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

   293

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

   294

        self.Parent = parent

   295

   296

    def __del__(self):

   297

        self.Parent = None

   298

   299

    def GetCurrentNodeName(self):

   300

        return self.Parent.CTNName()

   301

   302

    def GetCurrentNodeID(self):

   303

        return self.Parent.CanFestivalNode.getNodeId()

   304

   305

   306

class _NodeListCTN(NodeList):

   307

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

   308

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

   309

      <xsd:element name="CanFestivalNode">

   310

        <xsd:complexType>

   311

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

   312

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

   313

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

   314

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

   315

        </xsd:complexType>

   316

      </xsd:element>

   317

    </xsd:schema>

   318

    """

   319

   320

    EditorType = NetworkEditor

   321

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

   322

   323

    def __init__(self):

   324

        manager = _NodeManager(self)

   325

        NodeList.__init__(self, manager)

   326

        self.LoadProject(self.CTNPath())

   327

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

   328

   329

    def GetCanDevice(self):

   330

        return self.CanFestivalNode.getCAN_Device()

   331

   332

    def SetParamsAttribute(self, path, value):

   333

        if path == "CanFestivalNode.NodeId":

   334

            nodeid = self.CanFestivalNode.getNodeId()

   335

            if value != nodeid:

   336

                slaves = self.GetSlaveIDs()

   337

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

   338

                while value in slaves and value >= 0:

   339

                    value += dir

   340

                if value < 0:

   341

                    value = nodeid

   342

   343

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

   344

        refresh_network = False

   345

   346

        # Filter IEC_Channel and Name, that have specific behavior

   347

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

   348

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

   349

        elif path == "BaseParams.Name":

   350

            self.SetNetworkName(value)

   351

            refresh_network = True

   352

        elif path == "CanFestivalNode.NodeId":

   353

            refresh_network = True

   354

   355

        if refresh_network and self._View is not None:

   356

            wx.CallAfter(self._View.RefreshBufferState)

   357

        return value, refresh

   358

   359

    def GetVariableLocationTree(self):

   360

        current_location = self.GetCurrentLocation()

   361

        nodeindexes = self.SlaveNodes.keys()

   362

        nodeindexes.sort()

   363

        children = []

   364

        children += [GetSlaveLocationTree(self.Manager.GetCurrentNodeCopy(),

   365

                                          current_location,

   366

                                          _("Local entries"))]

   367

        children += [GetSlaveLocationTree(self.SlaveNodes[nodeid]["Node"],

   368

                                          current_location + (nodeid,),

   369

                                          self.SlaveNodes[nodeid]["Name"]) for nodeid in nodeindexes]

   370

   371

        return {

   372

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

   373

            "type":     LOCATION_CONFNODE,

   374

            "location": self.GetFullIEC_Channel(),

   375

            "children": children

   376

        }

   377

   378

    _GeneratedMasterView = None

   379

   380

    def _ShowGeneratedMaster(self):

   381

        self._OpenView("Generated master")

   382

   383

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

   384

        if name == "Generated master":

   385

            app_frame = self.GetCTRoot().AppFrame

   386

            if self._GeneratedMasterView is None:

   387

                buildpath = self._getBuildPath()

   388

                # Eventually create build dir

   389

                if not os.path.exists(buildpath):

   390

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

   391

                    return

   392

   393

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

   394

                if not os.path.exists(masterpath):

   395

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

   396

                    return

   397

   398

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

   399

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

   400

   401

            if self._GeneratedMasterView is not None:

   402

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

   403

   404

            return self._GeneratedMasterView

   405

        else:

   406

            ConfigTreeNode._OpenView(self, name, onlyopened)

   407

            if self._View is not None:

   408

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

   409

            return self._View

   410

   411

    ConfNodeMethods = [

   412

        {

   413

            "bitmap":    "ShowMaster",

   414

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

   415

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

   416

            "method":   "_ShowGeneratedMaster"

   417

        }

   418

    ]

   419

   420

    def OnCloseEditor(self, view):

   421

        ConfigTreeNode.OnCloseEditor(self, view)

   422

        if self._GeneratedMasterView == view:

   423

            self._GeneratedMasterView = None

   424

   425

    def OnCTNClose(self):

   426

        ConfigTreeNode.OnCTNClose(self)

   427

        self._CloseView(self._GeneratedMasterView)

   428

        return True

   429

   430

    def CTNTestModified(self):

   431

        return self.ChangesToSave or self.HasChanged()

   432

   433

    def OnCTNSave(self, from_project_path=None):

   434

        self.SetRoot(self.CTNPath())

   435

        if from_project_path is not None:

   436

            shutil.copytree(self.GetEDSFolder(from_project_path),

   437

                            self.GetEDSFolder())

   438

        return self.SaveProject() is None

   439

   440

    def CTNGenerate_C(self, buildpath, locations):

   441

        """

   442

        Generate C code

   443

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

   444

        @param locations: List of complete variables locations \

   445

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

   446

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

   447

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

   448

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

   449

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

   450

            }, ...]

   451

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

   452

        """

   453

        self._CloseView(self._GeneratedMasterView)

   454

        current_location = self.GetCurrentLocation()

   455

        # define a unique name for the generated C file

   456

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

   457

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

   458

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

   459

        try:

   460

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

   461

        except config_utils.PDOmappingException, e:

   462

            raise Exception(e.message)

   463

        # Do generate C file.

   464

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

   465

        if res:

   466

            raise Exception(res)

   467

   468

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

   469

        dump(master, file)

   470

        file.close()

   471

   472

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

   473

   474

    def LoadPrevious(self):

   475

        self.Manager.LoadCurrentPrevious()

   476

   477

    def LoadNext(self):

   478

        self.Manager.LoadCurrentNext()

   479

   480