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

from __future__ import absolute_import

    27

import os

    28

import sys

    29

import shutil

    30

import wx

    31

from gnosis.xml.pickle import *  # pylint: disable=import-error

    32

from gnosis.xml.pickle.util import setParanoia  # pylint: disable=import-error

    33

    34

import util.paths as paths

    35

from util.TranslationCatalogs import AddCatalog

    36

from ConfigTreeNode import ConfigTreeNode

    37

from PLCControler import \

    38

    LOCATION_CONFNODE, \

    39

    LOCATION_VAR_MEMORY

    40

    41

base_folder = paths.AbsParentDir(__file__, 2)  # noqa

    42

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

    43

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

    44

    45

# pylint: disable=wrong-import-position

    46

from nodelist import NodeList

    47

from nodemanager import NodeManager

    48

import gen_cfile

    49

import eds_utils

    50

import canfestival_config as local_canfestival_config  # pylint: disable=import-error

    51

from commondialogs import CreateNodeDialog

    52

from subindextable import IECTypeConversion, SizeConversion

    53

from canfestival import config_utils

    54

from canfestival.SlaveEditor import SlaveEditor, MasterViewer

    55

from canfestival.NetworkEditor import NetworkEditor

    56

    57

    58

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

    59

setParanoia(0)

    60

    61

    62

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

    63

#              Location Tree Helper

    64

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

    65

    66

    67

def GetSlaveLocationTree(slave_node, current_location, name):

    68

    entries = []

    69

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

    70

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    71

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

    72

        if typeinfos:

    73

            entries.append({

    74

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

    75

                "type": LOCATION_VAR_MEMORY,

    76

                "size": size,

    77

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

    78

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

    79

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

    80

                                                                         (index, subindex)))),

    81

                "description": "",

    82

                "children": []})

    83

    return {"name": name,

    84

            "type": LOCATION_CONFNODE,

    85

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

    86

            "children": entries}

    87

    88

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

    89

#                    SLAVE

    90

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

    91

    92

    93

class _SlaveCTN(NodeManager):

    94

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

    95

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

    96

      <xsd:element name="CanFestivalSlaveNode">

    97

        <xsd:complexType>

    98

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

    99

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

   100

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

   101

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

   102

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

   103

            <xsd:simpleType>

   104

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

   105

                    <xsd:minInclusive value="1"/>

   106

                    <xsd:maxInclusive value="99"/>

   107

                </xsd:restriction>

   108

            </xsd:simpleType>

   109

          </xsd:attribute>

   110

        </xsd:complexType>

   111

      </xsd:element>

   112

    </xsd:schema>

   113

    """

   114

   115

    EditorType = SlaveEditor

   116

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

   117

   118

    def __init__(self):

   119

        # TODO change netname when name change

   120

        NodeManager.__init__(self)

   121

        odfilepath = self.GetSlaveODPath()

   122

        if os.path.isfile(odfilepath):

   123

            self.OpenFileInCurrent(odfilepath)

   124

        else:

   125

            self.FilePath = ""

   126

            dialog = CreateNodeDialog(None, wx.OK)

   127

            dialog.Type.Enable(False)

   128

            dialog.GenSYNC.Enable(False)

   129

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

   130

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

   131

                profile, filepath = dialog.GetProfile()

   132

                NMT = dialog.GetNMTManagement()

   133

                options = dialog.GetOptions()

   134

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

   135

                                   id,           # NodeID - will be changed at build time

   136

                                   "slave",      # Type

   137

                                   description,  # description

   138

                                   profile,      # profile

   139

                                   filepath,     # prfile filepath

   140

                                   NMT,          # NMT

   141

                                   options)      # options

   142

            else:

   143

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

   144

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

   145

                                   "slave",      # Type

   146

                                   "",           # description

   147

                                   "None",       # profile

   148

                                   "",           # prfile filepath

   149

                                   "heartbeat",  # NMT

   150

                                   [])           # options

   151

            dialog.Destroy()

   152

            self.OnCTNSave()

   153

   154

    def GetCurrentNodeName(self):

   155

        return self.CTNName()

   156

   157

    def GetSlaveODPath(self):

   158

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

   159

   160

    def GetCanDevice(self):

   161

        return self.CanFestivalSlaveNode.getCAN_Device()

   162

   163

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

   164

        ConfigTreeNode._OpenView(self, name, onlyopened)

   165

        if self._View is not None:

   166

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

   167

        return self._View

   168

   169

    def _ExportSlave(self):

   170

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

   171

                               _("Choose a file"),

   172

                               os.path.expanduser("~"),

   173

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

   174

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

   175

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   176

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

   177

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

   178

            if result:

   179

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

   180

        dialog.Destroy()

   181

   182

    ConfNodeMethods = [

   183

        {

   184

            "bitmap":    "ExportSlave",

   185

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

   186

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

   187

            "method":   "_ExportSlave"

   188

        },

   189

    ]

   190

   191

    def CTNTestModified(self):

   192

        return self.ChangesToSave or self.OneFileHasChanged()

   193

   194

    def OnCTNSave(self, from_project_path=None):

   195

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   196

   197

    def SetParamsAttribute(self, path, value):

   198

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

   199

   200

        # Filter IEC_Channel and Name, that have specific behavior

   201

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

   202

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

   203

   204

        return result

   205

   206

    def GetVariableLocationTree(self):

   207

        return GetSlaveLocationTree(self.CurrentNode,

   208

                                    self.GetCurrentLocation(),

   209

                                    self.BaseParams.getName())

   210

   211

    def CTNGenerate_C(self, buildpath, locations):

   212

        """

   213

        Generate C code

   214

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

   215

        @param locations: List of complete variables locations \

   216

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

   217

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

   218

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

   219

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

   220

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

   221

            }, ...]

   222

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

   223

        """

   224

        current_location = self.GetCurrentLocation()

   225

        # define a unique name for the generated C file

   226

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

   227

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

   228

        # Create a new copy of the model

   229

        slave = self.GetCurrentNodeCopy()

   230

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

   231

        # allow access to local OD from Slave PLC

   232

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

   233

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

   234

        if res:

   235

            raise Exception(res)

   236

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

   237

        if res:

   238

            raise Exception(res)

   239

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

   240

   241

    def LoadPrevious(self):

   242

        self.LoadCurrentPrevious()

   243

   244

    def LoadNext(self):

   245

        self.LoadCurrentNext()

   246

   247

    def GetBufferState(self):

   248

        return self.GetCurrentBufferState()

   249

   250

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

   251

#                    MASTER

   252

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

   253

   254

   255

class MiniNodeManager(NodeManager):

   256

   257

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

   258

        NodeManager.__init__(self)

   259

   260

        self.OpenFileInCurrent(filepath)

   261

   262

        self.Parent = parent

   263

        self.Fullname = fullname

   264

   265

    def GetIconName(self):

   266

        return None

   267

   268

    def OnCloseEditor(self, view):

   269

        self.Parent.OnCloseEditor(view)

   270

   271

    def CTNFullName(self):

   272

        return self.Fullname

   273

   274

    def CTNTestModified(self):

   275

        return False

   276

   277

    def GetBufferState(self):

   278

        return self.GetCurrentBufferState()

   279

   280

    ConfNodeMethods = []

   281

   282

   283

class _NodeManager(NodeManager):

   284

   285

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

   286

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

   287

        self.Parent = parent

   288

   289

    def __del__(self):

   290

        self.Parent = None

   291

   292

    def GetCurrentNodeName(self):

   293

        return self.Parent.CTNName()

   294

   295

    def GetCurrentNodeID(self):

   296

        return self.Parent.CanFestivalNode.getNodeId()

   297

   298

   299

class _NodeListCTN(NodeList):

   300

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

   301

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

   302

      <xsd:element name="CanFestivalNode">

   303

        <xsd:complexType>

   304

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

   305

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

   306

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

   307

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

   308

        </xsd:complexType>

   309

      </xsd:element>

   310

    </xsd:schema>

   311

    """

   312

   313

    EditorType = NetworkEditor

   314

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

   315

   316

    def __init__(self):

   317

        manager = _NodeManager(self)

   318

        NodeList.__init__(self, manager)

   319

        self.LoadProject(self.CTNPath())

   320

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

   321

   322

    def GetCanDevice(self):

   323

        return self.CanFestivalNode.getCAN_Device()

   324

   325

    def SetParamsAttribute(self, path, value):

   326

        if path == "CanFestivalNode.NodeId":

   327

            nodeid = self.CanFestivalNode.getNodeId()

   328

            if value != nodeid:

   329

                slaves = self.GetSlaveIDs()

   330

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

   331

                while value in slaves and value >= 0:

   332

                    value += dir

   333

                if value < 0:

   334

                    value = nodeid

   335

   336

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

   337

        refresh_network = False

   338

   339

        # Filter IEC_Channel and Name, that have specific behavior

   340

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

   341

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

   342

        elif path == "BaseParams.Name":

   343

            self.SetNetworkName(value)

   344

            refresh_network = True

   345

        elif path == "CanFestivalNode.NodeId":

   346

            refresh_network = True

   347

   348

        if refresh_network and self._View is not None:

   349

            wx.CallAfter(self._View.RefreshBufferState)

   350

        return value, refresh

   351

   352

    def GetVariableLocationTree(self):

   353

        current_location = self.GetCurrentLocation()

   354

        nodeindexes = self.SlaveNodes.keys()

   355

        nodeindexes.sort()

   356

        children = []

   357

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

   358

                                          current_location,

   359

                                          _("Local entries"))]

   360

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

   361

                                          current_location + (nodeid,),

   362

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

   363

   364

        return {

   365

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

   366

            "type":     LOCATION_CONFNODE,

   367

            "location": self.GetFullIEC_Channel(),

   368

            "children": children

   369

        }

   370

   371

    _GeneratedMasterView = None

   372

   373

    def _ShowGeneratedMaster(self):

   374

        self._OpenView("Generated master")

   375

   376

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

   377

        if name == "Generated master":

   378

            app_frame = self.GetCTRoot().AppFrame

   379

            if self._GeneratedMasterView is None:

   380

                buildpath = self._getBuildPath()

   381

                # Eventually create build dir

   382

                if not os.path.exists(buildpath):

   383

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

   384

                    return

   385

   386

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

   387

                if not os.path.exists(masterpath):

   388

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

   389

                    return

   390

   391

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

   392

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

   393

   394

            if self._GeneratedMasterView is not None:

   395

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

   396

   397

            return self._GeneratedMasterView

   398

        else:

   399

            ConfigTreeNode._OpenView(self, name, onlyopened)

   400

            if self._View is not None:

   401

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

   402

            return self._View

   403

   404

    ConfNodeMethods = [

   405

        {

   406

            "bitmap":    "ShowMaster",

   407

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

   408

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

   409

            "method":   "_ShowGeneratedMaster"

   410

        }

   411

    ]

   412

   413

    def OnCloseEditor(self, view):

   414

        ConfigTreeNode.OnCloseEditor(self, view)

   415

        if self._GeneratedMasterView == view:

   416

            self._GeneratedMasterView = None

   417

   418

    def OnCTNClose(self):

   419

        ConfigTreeNode.OnCTNClose(self)

   420

        self._CloseView(self._GeneratedMasterView)

   421

        return True

   422

   423

    def CTNTestModified(self):

   424

        return self.ChangesToSave or self.HasChanged()

   425

   426

    def OnCTNSave(self, from_project_path=None):

   427

        self.SetRoot(self.CTNPath())

   428

        if from_project_path is not None:

   429

            shutil.copytree(self.GetEDSFolder(from_project_path),

   430

                            self.GetEDSFolder())

   431

        return self.SaveProject() is None

   432

   433

    def CTNGenerate_C(self, buildpath, locations):

   434

        """

   435

        Generate C code

   436

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

   437

        @param locations: List of complete variables locations \

   438

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

   439

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

   440

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

   441

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

   442

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

   443

            }, ...]

   444

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

   445

        """

   446

        self._CloseView(self._GeneratedMasterView)

   447

        current_location = self.GetCurrentLocation()

   448

        # define a unique name for the generated C file

   449

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

   450

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

   451

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

   452

        try:

   453

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

   454

        except config_utils.PDOmappingException, e:

   455

            raise Exception(e.message)

   456

        # Do generate C file.

   457

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

   458

        if res:

   459

            raise Exception(res)

   460

   461

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

   462

        # linter disabled here, undefined variable happens

   463

        # here because gnosis isn't impored while linting

   464

        dump(master, file)  # pylint: disable=undefined-variable

   465

        file.close()

   466

   467

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

   468

   469

    def LoadPrevious(self):

   470

        self.Manager.LoadCurrentPrevious()

   471

   472

    def LoadNext(self):

   473

        self.Manager.LoadCurrentNext()

   474

   475

    def GetBufferState(self):

   476

        return self.Manager.GetCurrentBufferState()

   477

   478

   479

class RootClass(object):