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

    42

from functools import reduce

    43

from distutils.dir_util import copy_tree

    44

from six.moves import xrange

    45

    46

import wx

    47

    48

import features

    49

import connectors

    50

import util.paths as paths

    51

from util.misc import CheckPathPerm, GetClassImporter

    52

from util.MiniTextControler import MiniTextControler

    53

from util.ProcessLogger import ProcessLogger

    54

from util.BitmapLibrary import GetBitmap

    55

from editors.FileManagementPanel import FileManagementPanel

    56

from editors.ProjectNodeEditor import ProjectNodeEditor

    57

from editors.IECCodeViewer import IECCodeViewer

    58

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    59

from dialogs import UriEditor, IDManager

    60

from PLCControler import PLCControler

    61

from plcopen.structures import IEC_KEYWORDS

    62

from plcopen.types_enums import ComputeConfigurationResourceName, ITEM_CONFNODE

    63

import targets

    64

from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer

    65

from runtime import PlcStatus

    66

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    67

from POULibrary import UserAddressedException

    68

    69

base_folder = paths.AbsParentDir(__file__)

    70

    71

MATIEC_ERROR_MODEL = re.compile(

    72

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

    73

    74

    75

def ExtractChildrenTypesFromCatalog(catalog):

    76

    children_types = []

    77

    for n, d, _h, c in catalog:

    78

        if isinstance(c, list):

    79

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    80

        else:

    81

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

    82

    return children_types

    83

    84

    85

def ExtractMenuItemsFromCatalog(catalog):

    86

    menu_items = []

    87

    for n, d, h, c in catalog:

    88

        if isinstance(c, list):

    89

            children = ExtractMenuItemsFromCatalog(c)

    90

        else:

    91

            children = []

    92

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

    93

    return menu_items

    94

    95

    96

def GetAddMenuItems():

    97

    return ExtractMenuItemsFromCatalog(features.catalog)

    98

    99

   100

class Iec2CSettings(object):

   101

   102

    def __init__(self):

   103

        self.iec2c = None

   104

        self.iec2c_buildopts = None

   105

        self.ieclib_path = self.findLibPath()

   106

        self.ieclib_c_path = self.findLibCPath()

   107

   108

    def findObject(self, paths, test):

   109

        path = None

   110

        for p in paths:

   111

            if test(p):

   112

                path = p

   113

                break

   114

        return path

   115

   116

    def findCmd(self):

   117

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

   118

        paths = [

   119

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

   120

        ]

   121

        path = self.findObject(

   122

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

   123

   124

        # otherwise use iec2c from PATH

   125

        if path is not None:

   126

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

   127

   128

        return cmd

   129

   130

    def findLibPath(self):

   131

        paths = [

   132

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

   133

            "/usr/lib/matiec"

   134

        ]

   135

        path = self.findObject(

   136

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

   137

        return path

   138

   139

    def findLibCPath(self):

   140

        path = None

   141

        if self.ieclib_path is not None:

   142

            paths = [

   143

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

   144

                self.ieclib_path]

   145

            path = self.findObject(

   146

                paths,

   147

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

   148

        return path

   149

   150

    def findSupportedOptions(self):

   151

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

   152

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

   153

   154

        buildopt = ""

   155

        try:

   156

            # Invoke compiler.

   157

            # Output files are listed to stdout, errors to stderr

   158

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

   159

                                                         no_stdout=True,

   160

                                                         no_stderr=True).spin()

   161

        except Exception:

   162

            return buildopt

   163

   164

        for opt in options:

   165

            if opt in result:

   166

                buildopt = buildopt + " " + opt

   167

        return buildopt

   168

   169

    def getCmd(self):

   170

        if self.iec2c is None:

   171

            self.iec2c = self.findCmd()

   172

        return self.iec2c

   173

   174

    def getOptions(self):

   175

        if self.iec2c_buildopts is None:

   176

            self.iec2c_buildopts = self.findSupportedOptions()

   177

        return self.iec2c_buildopts

   178

   179

    def getLibPath(self):

   180

        return self.ieclib_path

   181

   182

    def getLibCPath(self):

   183

        if self.ieclib_c_path is None:

   184

            self.ieclib_c_path = self.findLibCPath()

   185

        return self.ieclib_c_path

   186

   187

   188

def GetProjectControllerXSD():

   189

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

   190

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

   191

      <xsd:element name="BeremizRoot">

   192

        <xsd:complexType>

   193

          <xsd:sequence>

   194

            <xsd:element name="TargetType">

   195

              <xsd:complexType>

   196

                <xsd:choice minOccurs="0">

   197

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

   198

                </xsd:choice>

   199

              </xsd:complexType>

   200

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

   201

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

   202

              <xsd:complexType>

   203

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

   204

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

   205

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

   206

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

   207

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

   208

              </xsd:complexType>

   209

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

   210

          </xsd:sequence>

   211

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

   212

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

   213

        </xsd:complexType>

   214

      </xsd:element>

   215

    </xsd:schema>

   216

    """

   217

    return XSD

   218

   219

   220

class ProjectController(ConfigTreeNode, PLCControler):

   221

   222

    """

   223

    This class define Root object of the confnode tree.

   224

    It is responsible of :

   225

    - Managing project directory

   226

    - Building project

   227

    - Handling PLCOpenEditor controler and view

   228

    - Loading user confnodes and instanciante them as children

   229

    - ...

   230

   231

    """

   232

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

   233

    # packages.

   234

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   235

    XSD = GetProjectControllerXSD()

   236

    EditorType = ProjectNodeEditor

   237

    iec2c_cfg = None

   238

   239

    def __init__(self, frame, logger):

   240

        PLCControler.__init__(self)

   241

        ConfigTreeNode.__init__(self)

   242

   243

        if ProjectController.iec2c_cfg is None:

   244

            ProjectController.iec2c_cfg = Iec2CSettings()

   245

   246

        self.MandatoryParams = None

   247

        self._builder = None

   248

        self._connector = None

   249

        self.DispatchDebugValuesTimer = None

   250

        self.DebugValuesBuffers = []

   251

        self.DebugTicks = []

   252

        self.SetAppFrame(frame, logger)

   253

   254

        # Setup debug information

   255

        self.IECdebug_datas = {}

   256

   257

        self.DebugUpdatePending = False

   258

        self.ResetIECProgramsAndVariables()

   259

   260

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

   261

        self.ChangesToSave = False

   262

        # root have no parent

   263

        self.CTNParent = None

   264

        # Keep track of the confnode type name

   265

        self.CTNType = "Beremiz"

   266

        self.Children = {}

   267

        self._View = None

   268

        # After __init__ root confnode is not valid

   269

        self.ProjectPath = None

   270

        self._setBuildPath(None)

   271

        self.debug_break = False

   272

        self.previous_plcstate = None

   273

        # copy StatusMethods so that it can be later customized

   274

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

   275

        self.DebugToken = None

   276

        self.debug_status = PlcStatus.Stopped

   277

   278

    def __del__(self):

   279

        self.KillDebugThread()

   280

   281

    def LoadLibraries(self):

   282

        self.Libraries = []

   283

        TypeStack = []

   284

        for libname, clsname, lib_enabled in features.libraries:

   285

            if self.BeremizRoot.Libraries is not None:

   286

                enable_attr = getattr(self.BeremizRoot.Libraries,

   287

                                      "Enable_" + libname + "_Library")

   288

                if enable_attr is not None:

   289

                    lib_enabled = enable_attr

   290

   291

            if lib_enabled:

   292

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

   293

                TypeStack.append(Lib.GetTypes())

   294

                self.Libraries.append(Lib)

   295

   296

    def SetAppFrame(self, frame, logger):

   297

        self.AppFrame = frame

   298

        self.logger = logger

   299

        self.StatusTimer = None

   300

        if self.DispatchDebugValuesTimer is not None:

   301

            self.DispatchDebugValuesTimer.Stop()

   302

        self.DispatchDebugValuesTimer = None

   303

   304

        if frame is not None:

   305

   306

            # Timer to pull PLC status

   307

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

   308

            self.AppFrame.Bind(wx.EVT_TIMER,

   309

                               self.PullPLCStatusProc,

   310

                               self.StatusTimer)

   311

   312

            if self._connector is not None:

   313

                frame.LogViewer.SetLogSource(self._connector)

   314

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

   315

   316

            # Timer to dispatch debug values to consumers

   317

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

   318

            self.AppFrame.Bind(wx.EVT_TIMER,

   319

                               self.DispatchDebugValuesProc,

   320

                               self.DispatchDebugValuesTimer)

   321

   322

            self.RefreshConfNodesBlockLists()

   323

   324

    def ResetAppFrame(self, logger):

   325

        if self.AppFrame is not None:

   326

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

   327

            self.StatusTimer = None

   328

            self.AppFrame = None

   329

            self.KillDebugThread()

   330

        self.logger = logger

   331

   332

    def CTNName(self):

   333

        return "Project"

   334

   335

    def CTNTestModified(self):

   336

        return self.ChangesToSave or not self.ProjectIsSaved()

   337

   338

    def CTNFullName(self):

   339

        return ""

   340

   341

    def GetCTRoot(self):

   342

        return self

   343

   344

    def GetIECLibPath(self):

   345

        return self.iec2c_cfg.getLibCPath()

   346

   347

    def GetIEC2cPath(self):

   348

        return self.iec2c_cfg.getCmd()

   349

   350

    def GetCurrentLocation(self):

   351

        return ()

   352

   353

    def GetCurrentName(self):

   354

        return ""

   355

   356

    def _GetCurrentName(self):

   357

        return ""

   358

   359

    def GetProjectPath(self):

   360

        return self.ProjectPath

   361

   362

    def GetProjectName(self):

   363

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

   364

   365

    def GetIconName(self):

   366

        return "PROJECT"

   367

   368

    def GetDefaultTargetName(self):

   369

        if wx.Platform == '__WXMSW__':

   370

            return "Win32"

   371

        else:

   372

            return "Linux"

   373

   374

    def GetTarget(self):

   375

        target = self.BeremizRoot.getTargetType()

   376

        if target.getcontent() is None:

   377

            temp_root = self.Parser.CreateRoot()

   378

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

   379

            temp_root.setTargetType(target)

   380

            target_name = self.GetDefaultTargetName()

   381

            target.setcontent(

   382

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

   383

        return target

   384

   385

    def GetParamsAttributes(self, path=None):

   386

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   387

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

   388

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

   389

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

   390

                    child.update(

   391

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

   392

        return params

   393

   394

    def SetParamsAttribute(self, path, value):

   395

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

   396

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

   397

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

   398

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

   399

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   400

        return res

   401

   402

    # helper func to check project path write permission

   403

    def CheckProjectPathPerm(self, dosave=True):

   404

        if CheckPathPerm(self.ProjectPath):

   405

            return True

   406

        if self.AppFrame is not None:

   407

            dialog = wx.MessageDialog(

   408

                self.AppFrame,

   409

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

   410

                _('Error'),

   411

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

   412

            answer = dialog.ShowModal()

   413

            dialog.Destroy()

   414

            if answer == wx.ID_YES:

   415

                if self.SaveProjectAs():

   416

                    self.AppFrame.RefreshTitle()

   417

                    self.AppFrame.RefreshFileMenu()

   418

                    self.AppFrame.RefreshPageTitles()

   419

                    return True

   420

        return False

   421

   422

    def _getProjectFilesPath(self, project_path=None):

   423

        if project_path is not None:

   424

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

   425

        projectfiles_path = os.path.join(

   426

            self.GetProjectPath(), "project_files")

   427

        if not os.path.exists(projectfiles_path):

   428

            os.mkdir(projectfiles_path)

   429

        return projectfiles_path

   430

   431

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

   432

        self.ProjectAddConfiguration(config_name)

   433

        self.ProjectAddConfigurationResource(config_name, res_name)

   434

   435

    def SetProjectDefaultConfiguration(self):

   436

        # Sets default task and instance for new project

   437

        config = self.Project.getconfiguration(

   438

            self.GetProjectMainConfigurationName())

   439

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

   440

        config = config.getname()

   441

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   442

        def_task = [

   443

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

   444

        def_instance = [

   445

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

   446

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   447

   448

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

   449

        """

   450

        Create a new project in an empty folder

   451

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

   452

        @param PLCParams: properties of the PLCOpen program created

   453

        """

   454

        # Verify that chosen folder is empty

   455

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

   456

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

   457

   458

        # Create PLCOpen program

   459

        self.CreateNewProject(

   460

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

   461

             "productName": _("Unnamed"),

   462

             "productVersion": "1",

   463

             "companyName": _("Unknown"),

   464

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

   465

        self.AddProjectDefaultConfiguration()

   466

   467

        # Change XSD into class members

   468

        self._AddParamsMembers()

   469

        self.Children = {}

   470

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

   471

        self.ProjectPath = ProjectPath

   472

        self._setBuildPath(BuildPath)

   473

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

   474

        self.RefreshConfNodesBlockLists()

   475

        # this will create files base XML files

   476

        self.SaveProject()

   477

        return None

   478

   479

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

   480

        """

   481