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

    54

from nodemanager import NodeManager

    55

import config_utils

    56

import gen_cfile

    57

import eds_utils

    58

import canfestival_config as local_canfestival_config

    59

    60

from commondialogs import CreateNodeDialog

    61

from subindextable import IECTypeConversion, SizeConversion

    62

from SlaveEditor import SlaveEditor, MasterViewer

    63

from NetworkEditor import NetworkEditor

    64

    65

    66

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

    67

setParanoia(0)

    68

    69

    70

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

    71

#              Location Tree Helper

    72

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

    73

    74

    75

def GetSlaveLocationTree(slave_node, current_location, name):

    76

    entries = []

    77

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

    78

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    79

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

    80

        if typeinfos:

    81

            entries.append({

    82

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

    83

                "type": LOCATION_VAR_MEMORY,

    84

                "size": size,

    85

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

    86

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

    87

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

    88

                                                                         (index, subindex)))),

    89

                "description": "",

    90

                "children": []})

    91

    return {"name": name,

    92

            "type": LOCATION_CONFNODE,

    93

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

    94

            "children": entries}

    95

    96

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

    97

#                    SLAVE

    98

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

    99

   100

   101

class _SlaveCTN(NodeManager):

   102

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

   103

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

   104

      <xsd:element name="CanFestivalSlaveNode">

   105

        <xsd:complexType>

   106

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

   107

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

   108

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

   109

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

   110

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

   111

            <xsd:simpleType>

   112

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

   113

                    <xsd:minInclusive value="1"/>

   114

                    <xsd:maxInclusive value="99"/>

   115

                </xsd:restriction>

   116

            </xsd:simpleType>

   117

          </xsd:attribute>

   118

        </xsd:complexType>

   119

      </xsd:element>

   120

    </xsd:schema>

   121

    """

   122

   123

    EditorType = SlaveEditor

   124

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

   125

   126

    def __init__(self):

   127

        # TODO change netname when name change

   128

        NodeManager.__init__(self)

   129

        odfilepath = self.GetSlaveODPath()

   130

        if os.path.isfile(odfilepath):

   131

            self.OpenFileInCurrent(odfilepath)

   132

        else:

   133

            self.FilePath = ""

   134

            dialog = CreateNodeDialog(None, wx.OK)

   135

            dialog.Type.Enable(False)

   136

            dialog.GenSYNC.Enable(False)

   137

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

   138

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

   139

                profile, filepath = dialog.GetProfile()

   140

                NMT = dialog.GetNMTManagement()

   141

                options = dialog.GetOptions()

   142

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

   143

                                   id,           # NodeID - will be changed at build time

   144

                                   "slave",      # Type

   145

                                   description,  # description

   146

                                   profile,      # profile

   147

                                   filepath,     # prfile filepath

   148

                                   NMT,          # NMT

   149

                                   options)      # options

   150

            else:

   151

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

   152

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

   153

                                   "slave",      # Type

   154

                                   "",           # description

   155

                                   "None",       # profile

   156

                                   "",           # prfile filepath

   157

                                   "heartbeat",  # NMT

   158

                                   [])           # options

   159

            dialog.Destroy()

   160

            self.OnCTNSave()

   161

   162

    def GetCurrentNodeName(self):

   163

        return self.CTNName()

   164

   165

    def GetSlaveODPath(self):

   166

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

   167

   168

    def GetCanDevice(self):

   169

        return self.CanFestivalSlaveNode.getCAN_Device()

   170

   171

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

   172

        ConfigTreeNode._OpenView(self, name, onlyopened)

   173

        if self._View is not None:

   174

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

   175

        return self._View

   176

   177

    def _ExportSlave(self):

   178

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

   179

                               _("Choose a file"),

   180

                               os.path.expanduser("~"),

   181

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

   182

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

   183

                               wx.SAVE | wx.OVERWRITE_PROMPT)

   184

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

   185

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

   186

            if result:

   187

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

   188

        dialog.Destroy()

   189

   190

    ConfNodeMethods = [

   191

        {

   192

            "bitmap":    "ExportSlave",

   193

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

   194

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

   195

            "method":   "_ExportSlave"

   196

        },

   197

    ]

   198

   199

    def CTNTestModified(self):

   200

        return self.ChangesToSave or self.OneFileHasChanged()

   201

   202

    def OnCTNSave(self, from_project_path=None):

   203

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   204

   205

    def SetParamsAttribute(self, path, value):

   206

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

   207

   208

        # Filter IEC_Channel and Name, that have specific behavior

   209

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

   210

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

   211

   212

        return result

   213

   214

    def GetVariableLocationTree(self):

   215

        current_location = self.GetCurrentLocation()

   216

        return GetSlaveLocationTree(self.CurrentNode,

   217

                                    self.GetCurrentLocation(),

   218

                                    self.BaseParams.getName())

   219

   220

    def CTNGenerate_C(self, buildpath, locations):

   221

        """

   222

        Generate C code

   223

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

   224

        @param locations: List of complete variables locations \

   225

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

   226

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

   227

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

   228

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

   229

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

   230

            }, ...]

   231

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

   232

        """

   233

        current_location = self.GetCurrentLocation()

   234

        # define a unique name for the generated C file

   235

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

   236

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

   237

        # Create a new copy of the model

   238

        slave = self.GetCurrentNodeCopy()

   239

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

   240

        # allow access to local OD from Slave PLC

   241

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

   242

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

   243

        if res:

   244

            raise Exception(res)

   245

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

   246

        if res:

   247

            raise Exception(res)

   248

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

   249

   250

    def LoadPrevious(self):

   251

        self.LoadCurrentPrevious()

   252

   253

    def LoadNext(self):

   254

        self.LoadCurrentNext()

   255

   256

    def GetBufferState(self):

   257

        return self.GetCurrentBufferState()

   258

   259

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

   260

#                    MASTER

   261

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

   262

   263

   264

class MiniNodeManager(NodeManager):

   265

   266

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

   267

        NodeManager.__init__(self)

   268

   269

        self.OpenFileInCurrent(filepath)

   270

   271

        self.Parent = parent

   272

        self.Fullname = fullname

   273

   274

    def GetIconName(self):

   275

        return None

   276

   277

    def OnCloseEditor(self, view):

   278

        self.Parent.OnCloseEditor(view)

   279

   280

    def CTNFullName(self):

   281

        return self.Fullname

   282

   283

    def CTNTestModified(self):

   284

        return False

   285

   286

    def GetBufferState(self):

   287

        return self.GetCurrentBufferState()

   288

   289

    ConfNodeMethods = []

   290

   291

   292

class _NodeManager(NodeManager):

   293

   294

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

   295

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

   296

        self.Parent = parent

   297

   298

    def __del__(self):

   299

        self.Parent = None

   300

   301

    def GetCurrentNodeName(self):

   302

        return self.Parent.CTNName()

   303

   304

    def GetCurrentNodeID(self):

   305

        return self.Parent.CanFestivalNode.getNodeId()

   306

   307

   308

class _NodeListCTN(NodeList):

   309

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

   310

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

   311

      <xsd:element name="CanFestivalNode">

   312

        <xsd:complexType>

   313

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

   314

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

   315

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

   316

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

   317

        </xsd:complexType>

   318

      </xsd:element>

   319

    </xsd:schema>

   320

    """

   321

   322

    EditorType = NetworkEditor

   323

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

   324

   325

    def __init__(self):

   326

        manager = _NodeManager(self)

   327

        NodeList.__init__(self, manager)

   328

        self.LoadProject(self.CTNPath())

   329

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

   330

   331

    def GetCanDevice(self):

   332

        return self.CanFestivalNode.getCAN_Device()

   333

   334

    def SetParamsAttribute(self, path, value):

   335

        if path == "CanFestivalNode.NodeId":

   336

            nodeid = self.CanFestivalNode.getNodeId()

   337

            if value != nodeid:

   338

                slaves = self.GetSlaveIDs()

   339

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

   340

                while value in slaves and value >= 0:

   341

                    value += dir

   342

                if value < 0:

   343

                    value = nodeid

   344

   345

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

   346

        refresh_network = False

   347

   348

        # Filter IEC_Channel and Name, that have specific behavior

   349

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

   350

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

   351

        elif path == "BaseParams.Name":

   352

            self.SetNetworkName(value)

   353

            refresh_network = True

   354

        elif path == "CanFestivalNode.NodeId":

   355

            refresh_network = True

   356

   357

        if refresh_network and self._View is not None:

   358

            wx.CallAfter(self._View.RefreshBufferState)

   359

        return value, refresh

   360

   361

    def GetVariableLocationTree(self):

   362

        current_location = self.GetCurrentLocation()

   363

        nodeindexes = self.SlaveNodes.keys()

   364

        nodeindexes.sort()

   365

        children = []

   366

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

   367

                                          current_location,

   368

                                          _("Local entries"))]

   369

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

   370

                                          current_location + (nodeid,),

   371

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

   372

   373

        return {

   374

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

   375

            "type":     LOCATION_CONFNODE,

   376

            "location": self.GetFullIEC_Channel(),

   377

            "children": children

   378

        }

   379

   380

    _GeneratedMasterView = None

   381

   382

    def _ShowGeneratedMaster(self):

   383

        self._OpenView("Generated master")

   384

   385

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

   386

        if name == "Generated master":

   387

            app_frame = self.GetCTRoot().AppFrame

   388

            if self._GeneratedMasterView is None:

   389

                buildpath = self._getBuildPath()

   390

                # Eventually create build dir

   391

                if not os.path.exists(buildpath):

   392

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

   393

                    return

   394

   395

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

   396

                if not os.path.exists(masterpath):

   397

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

   398

                    return

   399

   400

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

   401

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

   402

   403

            if self._GeneratedMasterView is not None:

   404

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

   405

   406

            return self._GeneratedMasterView

   407

        else:

   408

            ConfigTreeNode._OpenView(self, name, onlyopened)

   409

            if self._View is not None:

   410

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

   411

            return self._View

   412

   413

    ConfNodeMethods = [

   414

        {

   415

            "bitmap":    "ShowMaster",

   416

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

   417

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

   418

            "method":   "_ShowGeneratedMaster"

   419

        }

   420

    ]

   421

   422

    def OnCloseEditor(self, view):

   423

        ConfigTreeNode.OnCloseEditor(self, view)

   424

        if self._GeneratedMasterView == view:

   425

            self._GeneratedMasterView = None

   426

   427

    def OnCTNClose(self):

   428

        ConfigTreeNode.OnCTNClose(self)

   429

        self._CloseView(self._GeneratedMasterView)

   430

        return True

   431

   432

    def CTNTestModified(self):

   433

        return self.ChangesToSave or self.HasChanged()

   434

   435

    def OnCTNSave(self, from_project_path=None):

   436

        self.SetRoot(self.CTNPath())

   437

        if from_project_path is not None:

   438

            shutil.copytree(self.GetEDSFolder(from_project_path),

   439

                            self.GetEDSFolder())

   440

        return self.SaveProject() is None

   441

   442

    def CTNGenerate_C(self, buildpath, locations):

   443

        """

   444

        Generate C code

   445

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

   446

        @param locations: List of complete variables locations \

   447

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

   448

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

   449

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

   450

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

   451

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

   452

            }, ...]

   453

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

   454

        """

   455

        self._CloseView(self._GeneratedMasterView)

   456

        current_location = self.GetCurrentLocation()

   457

        # define a unique name for the generated C file

   458

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

   459

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

   460

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

   461

        try:

   462

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

   463

        except config_utils.PDOmappingException, e:

   464

            raise Exception(e.message)

   465

        # Do generate C file.

   466

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

   467

        if res:

   468

            raise Exception(res)

   469

   470

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

   471

        dump(master, file)

   472

        file.close()

   473

   474

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

   475

   476

    def LoadPrevious(self):

   477

        self.Manager.LoadCurrentPrevious()

   478

   479

    def LoadNext(self):

   480

        self.Manager.LoadCurrentNext()