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

"""

    27

Beremiz Project Controller

    28

"""

    29

    30

    31

from __future__ import absolute_import

    32

import os

    33

import traceback

    34

import time

    35

from time import localtime

    36

import shutil

    37

import re

    38

import tempfile

    39

from threading import Timer

    40

from datetime import datetime

    41

from weakref import WeakKeyDictionary

    43

from six.moves import xrange

    44

    45

import wx

    46

    47

import features

    48

import connectors

    49

import util.paths as paths

    50

from util.misc import CheckPathPerm, GetClassImporter

    51

from util.MiniTextControler import MiniTextControler

    52

from util.ProcessLogger import ProcessLogger

    53

from util.BitmapLibrary import GetBitmap

    54

from editors.FileManagementPanel import FileManagementPanel

    55

from editors.ProjectNodeEditor import ProjectNodeEditor

    56

from editors.IECCodeViewer import IECCodeViewer

    57

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    58

from dialogs import DiscoveryDialog

    59

from PLCControler import PLCControler

    60

from plcopen.structures import IEC_KEYWORDS

    61

from plcopen.types_enums import ComputeConfigurationResourceName, ITEM_CONFNODE

    62

import targets

    63

from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer

    64

from runtime import PlcStatus

    65

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    66

    67

base_folder = paths.AbsParentDir(__file__)

    68

    69

MATIEC_ERROR_MODEL = re.compile(

    70

    r".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")

    71

    72

    73

def ExtractChildrenTypesFromCatalog(catalog):

    74

    children_types = []

    75

    for n, d, _h, c in catalog:

    76

        if isinstance(c, list):

    77

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    78

        else:

    79

            children_types.append((n, GetClassImporter(c), d))

    80

    return children_types

    81

    82

    83

def ExtractMenuItemsFromCatalog(catalog):

    84

    menu_items = []

    85

    for n, d, h, c in catalog:

    86

        if isinstance(c, list):

    87

            children = ExtractMenuItemsFromCatalog(c)

    88

        else:

    89

            children = []

    90

        menu_items.append((n, d, h, children))

    91

    return menu_items

    92

    93

    94

def GetAddMenuItems():

    95

    return ExtractMenuItemsFromCatalog(features.catalog)

    96

    97

    98

class Iec2CSettings(object):

    99

   100

    def __init__(self):

   101

        self.iec2c = None

   102

        self.iec2c_buildopts = None

   103

        self.ieclib_path = self.findLibPath()

   104

        self.ieclib_c_path = self.findLibCPath()

   105

   106

    def findObject(self, paths, test):

   107

        path = None

   108

        for p in paths:

   109

            if test(p):

   110

                path = p

   111

                break

   112

        return path

   113

   114

    def findCmd(self):

   115

        cmd = "iec2c" + (".exe" if wx.Platform == '__WXMSW__' else "")

   116

        paths = [

   117

            os.path.join(base_folder, "matiec")

   118

        ]

   119

        path = self.findObject(

   120

            paths, lambda p: os.path.isfile(os.path.join(p, cmd)))

   121

   122

        # otherwise use iec2c from PATH

   123

        if path is not None:

   124

            cmd = os.path.join(path, cmd)

   125

   126

        return cmd

   127

   128

    def findLibPath(self):

   129

        paths = [

   130

            os.path.join(base_folder, "matiec", "lib"),

   131

            "/usr/lib/matiec"

   132

        ]

   133

        path = self.findObject(

   134

            paths, lambda p: os.path.isfile(os.path.join(p, "ieclib.txt")))

   135

        return path

   136

   137

    def findLibCPath(self):

   138

        path = None

   139

        if self.ieclib_path is not None:

   140

            paths = [

   141

                os.path.join(self.ieclib_path, "C"),

   142

                self.ieclib_path]

   143

            path = self.findObject(

   144

                paths,

   145

                lambda p: os.path.isfile(os.path.join(p, "iec_types.h")))

   146

        return path

   147

   148

    def findSupportedOptions(self):

   149

        buildcmd = "\"%s\" -h" % (self.getCmd())

   150

        options = ["-f", "-l", "-p"]

   151

   152

        buildopt = ""

   153

        try:

   154

            # Invoke compiler.

   155

            # Output files are listed to stdout, errors to stderr

   156

            _status, result, _err_result = ProcessLogger(None, buildcmd,

   157

                                                         no_stdout=True,

   158

                                                         no_stderr=True).spin()

   159

        except Exception:

   160

            return buildopt

   161

   162

        for opt in options:

   163

            if opt in result:

   164

                buildopt = buildopt + " " + opt

   165

        return buildopt

   166

   167

    def getCmd(self):

   168

        if self.iec2c is None:

   169

            self.iec2c = self.findCmd()

   170

        return self.iec2c

   171

   172

    def getOptions(self):

   173

        if self.iec2c_buildopts is None:

   174

            self.iec2c_buildopts = self.findSupportedOptions()

   175

        return self.iec2c_buildopts

   176

   177

    def getLibPath(self):

   178

        return self.ieclib_path

   179

   180

    def getLibCPath(self):

   181

        if self.ieclib_c_path is None:

   182

            self.ieclib_c_path = self.findLibCPath()

   183

        return self.ieclib_c_path

   184

   185

   186

def GetProjectControllerXSD():

   187

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

   188

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

   189

      <xsd:element name="BeremizRoot">

   190

        <xsd:complexType>

   191

          <xsd:sequence>

   192

            <xsd:element name="TargetType">

   193

              <xsd:complexType>

   194

                <xsd:choice minOccurs="0">

   195

                """ + targets.GetTargetChoices() + """

   196

                </xsd:choice>

   197

              </xsd:complexType>

   198

            </xsd:element>""" + (("""

   199

            <xsd:element name="Libraries" minOccurs="0">

   200

              <xsd:complexType>

   201

              """ + "\n".join(['<xsd:attribute name=' +

   202

                               '"Enable_' + libname + '_Library" ' +

   203

                               'type="xsd:boolean" use="optional" default="' +

   204

                               ('true' if default else 'false') + '"/>'

   205

                               for libname, _lib, default in features.libraries]) + """

   206

              </xsd:complexType>

   207

            </xsd:element>""") if len(features.libraries) > 0 else '') + """

   208

          </xsd:sequence>

   209

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

   210

          <xsd:attribute name="Disable_Extensions" type="xsd:boolean" use="optional" default="false"/>

   211

        </xsd:complexType>

   212

      </xsd:element>

   213

    </xsd:schema>

   214

    """

   215

    return XSD

   216

   217

   218

class ProjectController(ConfigTreeNode, PLCControler):

   219

   220

    """

   221

    This class define Root object of the confnode tree.

   222

    It is responsible of :

   223

    - Managing project directory

   224

    - Building project

   225

    - Handling PLCOpenEditor controler and view

   226

    - Loading user confnodes and instanciante them as children

   227

    - ...

   228

   229

    """

   230

    # For root object, available Children Types are modules of the confnode

   231

    # packages.

   232

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   233

    XSD = GetProjectControllerXSD()

   234

    EditorType = ProjectNodeEditor

   235

    iec2c_cfg = None

   236

   237

    def __init__(self, frame, logger):

   238

        PLCControler.__init__(self)

   239

        ConfigTreeNode.__init__(self)

   240

   241

        if ProjectController.iec2c_cfg is None:

   242

            ProjectController.iec2c_cfg = Iec2CSettings()

   243

   244

        self.MandatoryParams = None

   245

        self._builder = None

   246

        self._connector = None

   247

        self.DispatchDebugValuesTimer = None

   248

        self.DebugValuesBuffers = []

   249

        self.DebugTicks = []

   250

        self.SetAppFrame(frame, logger)

   251

   252

        # Setup debug information

   253

        self.IECdebug_datas = {}

   254

   255

        self.DebugTimer = None

   256

        self.ResetIECProgramsAndVariables()

   257

   258

        # In both new or load scenario, no need to save

   259

        self.ChangesToSave = False

   260

        # root have no parent

   261

        self.CTNParent = None

   262

        # Keep track of the confnode type name

   263

        self.CTNType = "Beremiz"

   264

        self.Children = {}

   265

        self._View = None

   266

        # After __init__ root confnode is not valid

   267

        self.ProjectPath = None

   268

        self._setBuildPath(None)

   269

        self.debug_break = False

   270

        self.previous_plcstate = None

   271

        # copy ConfNodeMethods so that it can be later customized

   272

        self.StatusMethods = [dic.copy() for dic in self.StatusMethods]

   273

   274

    def __del__(self):

   275

        if self.DebugTimer:

   276

            self.DebugTimer.cancel()

   277

        self.KillDebugThread()

   278

   279

    def LoadLibraries(self):

   280

        self.Libraries = []

   281

        TypeStack = []

   282

        for libname, clsname, _default in features.libraries:

   283

            if self.BeremizRoot.Libraries is not None and \

   284

               getattr(self.BeremizRoot.Libraries,

   285

                       "Enable_" + libname + "_Library"):

   286

                Lib = GetClassImporter(clsname)()(self, libname, TypeStack)

   287

                TypeStack.append(Lib.GetTypes())

   288

                self.Libraries.append(Lib)

   289

   290

    def SetAppFrame(self, frame, logger):

   291

        self.AppFrame = frame

   292

        self.logger = logger

   293

        self.StatusTimer = None

   294

        if self.DispatchDebugValuesTimer is not None:

   295

            self.DispatchDebugValuesTimer.Stop()

   296

        self.DispatchDebugValuesTimer = None

   297

   298

        if frame is not None:

   299

   300

            # Timer to pull PLC status

   301

            self.StatusTimer = wx.Timer(self.AppFrame, -1)

   302

            self.AppFrame.Bind(wx.EVT_TIMER,

   303

                               self.PullPLCStatusProc,

   304

                               self.StatusTimer)

   305

   306

            if self._connector is not None:

   307

                frame.LogViewer.SetLogSource(self._connector)

   308

                self.StatusTimer.Start(milliseconds=500, oneShot=False)

   309

   310

            # Timer to dispatch debug values to consumers

   311

            self.DispatchDebugValuesTimer = wx.Timer(self.AppFrame, -1)

   312

            self.AppFrame.Bind(wx.EVT_TIMER,

   313

                               self.DispatchDebugValuesProc,

   314

                               self.DispatchDebugValuesTimer)

   315

   316

            self.RefreshConfNodesBlockLists()

   317

   318

    def ResetAppFrame(self, logger):

   319

        if self.AppFrame is not None:

   320

            self.AppFrame.Unbind(wx.EVT_TIMER, self.StatusTimer)

   321

            self.StatusTimer = None

   322

            self.AppFrame = None

   323

            self.KillDebugThread()

   324

        self.logger = logger

   325

   326

    def CTNName(self):

   327

        return "Project"

   328

   329

    def CTNTestModified(self):

   330

        return self.ChangesToSave or not self.ProjectIsSaved()

   331

   332

    def CTNFullName(self):

   333

        return ""

   334

   335

    def GetCTRoot(self):

   336

        return self

   337

   338

    def GetIECLibPath(self):

   339

        return self.iec2c_cfg.getLibCPath()

   340

   341

    def GetIEC2cPath(self):

   342

        return self.iec2c_cfg.getCmd()

   343

   344

    def GetCurrentLocation(self):

   345

        return ()

   346

   347

    def GetCurrentName(self):

   348

        return ""

   349

   350

    def _GetCurrentName(self):

   351

        return ""

   352

   353

    def GetProjectPath(self):

   354

        return self.ProjectPath

   355

   356

    def GetProjectName(self):

   357

        return os.path.split(self.ProjectPath)[1]

   358

   359

    def GetIconName(self):

   360

        return "PROJECT"

   361

   362

    def GetDefaultTargetName(self):

   363

        if wx.Platform == '__WXMSW__':

   364

            return "Win32"

   365

        else:

   366

            return "Linux"

   367

   368

    def GetTarget(self):

   369

        target = self.BeremizRoot.getTargetType()

   370

        if target.getcontent() is None:

   371

            temp_root = self.Parser.CreateRoot()

   372

            target = self.Parser.CreateElement("TargetType", "BeremizRoot")

   373

            temp_root.setTargetType(target)

   374

            target_name = self.GetDefaultTargetName()

   375

            target.setcontent(

   376

                self.Parser.CreateElement(target_name, "TargetType"))

   377

        return target

   378

   379

    def GetParamsAttributes(self, path=None):

   380

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   381

        if params[0]["name"] == "BeremizRoot":

   382

            for child in params[0]["children"]:

   383

                if child["name"] == "TargetType" and child["value"] == '':

   384

                    child.update(

   385

                        self.GetTarget().getElementInfos("TargetType"))

   386

        return params

   387

   388

    def SetParamsAttribute(self, path, value):

   389

        if path.startswith("BeremizRoot.TargetType.") and self.BeremizRoot.getTargetType().getcontent() is None:

   390

            self.BeremizRoot.setTargetType(self.GetTarget())

   391

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

   392

        if path.startswith("BeremizRoot.Libraries."):

   393

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   394

        return res

   395

   396

    # helper func to check project path write permission

   397

    def CheckProjectPathPerm(self, dosave=True):

   398

        if CheckPathPerm(self.ProjectPath):

   399

            return True

   400

        if self.AppFrame is not None:

   401

            dialog = wx.MessageDialog(

   402

                self.AppFrame,

   403

                _('You must have permission to work on the project\nWork on a project copy ?'),

   404

                _('Error'),

   405

                wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)

   406

            answer = dialog.ShowModal()

   407

            dialog.Destroy()

   408

            if answer == wx.ID_YES:

   409

                if self.SaveProjectAs():

   410

                    self.AppFrame.RefreshTitle()

   411

                    self.AppFrame.RefreshFileMenu()

   412

                    self.AppFrame.RefreshPageTitles()

   413

                    return True

   414

        return False

   415

   416

    def _getProjectFilesPath(self, project_path=None):

   417

        if project_path is not None:

   418

            return os.path.join(project_path, "project_files")

   419

        projectfiles_path = os.path.join(

   420

            self.GetProjectPath(), "project_files")

   421

        if not os.path.exists(projectfiles_path):

   422

            os.mkdir(projectfiles_path)

   423

        return projectfiles_path

   424

   425

    def AddProjectDefaultConfiguration(self, config_name="config", res_name="resource1"):

   426

        self.ProjectAddConfiguration(config_name)

   427

        self.ProjectAddConfigurationResource(config_name, res_name)

   428

   429

    def SetProjectDefaultConfiguration(self):

   430

        # Sets default task and instance for new project

   431

        config = self.Project.getconfiguration(

   432

            self.GetProjectMainConfigurationName())

   433

        resource = config.getresource()[0].getname()

   434

        config = config.getname()

   435

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   436

        def_task = [

   437

            {'Priority': '0', 'Single': '', 'Interval': 'T#20ms', 'Name': 'task0', 'Triggering': 'Cyclic'}]

   438

        def_instance = [

   439

            {'Task': def_task[0].get('Name'), 'Type': self.GetProjectPouNames()[0], 'Name': 'instance0'}]

   440

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   441

   442

    def NewProject(self, ProjectPath, BuildPath=None):

   443

        """

   444

        Create a new project in an empty folder

   445

        @param ProjectPath: path of the folder where project have to be created

   446

        @param PLCParams: properties of the PLCOpen program created

   447

        """

   448

        # Verify that chosen folder is empty

   449

        if not os.path.isdir(ProjectPath) or len(os.listdir(ProjectPath)) > 0:

   450

            return _("Chosen folder isn't empty. You can't use it for a new project!")

   451

   452

        # Create PLCOpen program

   453

        self.CreateNewProject(

   454

            {"projectName": _("Unnamed"),

   455

             "productName": _("Unnamed"),

   456

             "productVersion": "1",

   457

             "companyName": _("Unknown"),

   458

             "creationDateTime": datetime(*localtime()[:6])})

   459

        self.AddProjectDefaultConfiguration()

   460

   461

        # Change XSD into class members

   462

        self._AddParamsMembers()

   463

        self.Children = {}

   464

        # Keep track of the root confnode (i.e. project path)

   465

        self.ProjectPath = ProjectPath

   466

        self._setBuildPath(BuildPath)

   467

        # get confnodes bloclist (is that usefull at project creation?)

   468

        self.RefreshConfNodesBlockLists()

   469

        # this will create files base XML files

   470

        self.SaveProject()

   471

        return None

   472

   473

    def LoadProject(self, ProjectPath, BuildPath=None):

   474

        """

   475

        Load a project contained in a folder

   476

        @param ProjectPath: path of the project folder

   477

        """

   478

        if os.path.basename(ProjectPath) == "":

   479

            ProjectPath = os.path.dirname(ProjectPath)

   480

        # Verify that project contains a PLCOpen program

   481