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

import hashlib

    40

from datetime import datetime

    41

from weakref import WeakKeyDictionary

    42

from functools import reduce

    43

from itertools import izip

    44

from distutils.dir_util import copy_tree

    45

from six.moves import xrange

    46

    47

import wx

    48

    49

import features

    50

import connectors

    51

import util.paths as paths

    52

from util.misc import CheckPathPerm, GetClassImporter

    53

from util.MiniTextControler import MiniTextControler

    54

from util.ProcessLogger import ProcessLogger

    55

from util.BitmapLibrary import GetBitmap

    56

from editors.FileManagementPanel import FileManagementPanel

    57

from editors.ProjectNodeEditor import ProjectNodeEditor

    58

from editors.IECCodeViewer import IECCodeViewer

    59

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    60

from dialogs import UriEditor, IDManager

    61

from PLCControler import PLCControler

    62

from plcopen.structures import IEC_KEYWORDS

    63

from plcopen.types_enums import ComputeConfigurationResourceName, ITEM_CONFNODE

    64

import targets

    65

from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer

    66

from runtime import PlcStatus

    67

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    68

from POULibrary import UserAddressedException

    69

    70

base_folder = paths.AbsParentDir(__file__)

    71

    72

MATIEC_ERROR_MODEL = re.compile(

    73

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

    74

    75

    76

def ExtractChildrenTypesFromCatalog(catalog):

    77

    children_types = []

    78

    for n, d, _h, c in catalog:

    79

        if isinstance(c, list):

    80

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    81

        else:

    82

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

    83

    return children_types

    84

    85

    86

def ExtractMenuItemsFromCatalog(catalog):

    87

    menu_items = []

    88

    for n, d, h, c in catalog:

    89

        if isinstance(c, list):

    90

            children = ExtractMenuItemsFromCatalog(c)

    91

        else:

    92

            children = []

    93

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

    94

    return menu_items

    95

    96

    97

def GetAddMenuItems():

    98

    return ExtractMenuItemsFromCatalog(features.catalog)

    99

   100

   101

class Iec2CSettings(object):

   102

   103

    def __init__(self, controler):

   104

        self.iec2c = None

   105

        self.iec2c_buildopts = None

   106

        self.ieclib_path = self.findLibPath()

   107

        self.ieclib_c_path = self.findLibCPath()

   108

        self.controler = controler

   109

   110

    def findObject(self, paths, test):

   111

        path = None

   112

        for p in paths:

   113

            if test(p):

   114

                path = p

   115

                break

   116

        return path

   117

   118

    def findCmd(self):

   119

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

   120

        paths = [

   121

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

   122

        ]

   123

        path = self.findObject(

   124

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

   125

   126

        # otherwise use iec2c from PATH

   127

        if path is not None:

   128

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

   129

   130

        return cmd

   131

   132

    def findLibPath(self):

   133

        paths = [

   134

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

   135

            "/usr/lib/matiec"

   136

        ]

   137

        path = self.findObject(

   138

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

   139

        return path

   140

   141

    def findLibCPath(self):

   142

        path = None

   143

        if self.ieclib_path is not None:

   144

            paths = [

   145

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

   146

                self.ieclib_path]

   147

            path = self.findObject(

   148

                paths,

   149

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

   150

        return path

   151

   152

    def findSupportedOptions(self):

   153

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

   154

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

   155

   156

        buildopt = ""

   157

        try:

   158

            # Invoke compiler.

   159

            # Output files are listed to stdout, errors to stderr

   160

            _status, result, _err_result = ProcessLogger(self.controler.logger, buildcmd,

   161

                                                         no_stdout=True,

   162

                                                         no_stderr=True).spin()

   163

        except Exception:

   164

            self.controler.logger.write_error(_("Couldn't launch IEC compiler to determine compatible options.\n"))

   165

            return buildopt

   166

   167

        for opt in options:

   168

            if opt in result:

   169

                buildopt = buildopt + " " + opt

   170

        return buildopt

   171

   172

    def getCmd(self):

   173

        if self.iec2c is None:

   174

            self.iec2c = self.findCmd()

   175

        return self.iec2c

   176

   177

    def getOptions(self):

   178

        if self.iec2c_buildopts is None:

   179

            self.iec2c_buildopts = self.findSupportedOptions()

   180

        return self.iec2c_buildopts

   181

   182

    def getLibPath(self):

   183

        return self.ieclib_path

   184

   185

    def getLibCPath(self):

   186

        if self.ieclib_c_path is None:

   187

            self.ieclib_c_path = self.findLibCPath()

   188

        return self.ieclib_c_path

   189

   190

   191

def GetProjectControllerXSD():

   192

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

   193

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

   194

      <xsd:element name="BeremizRoot">

   195

        <xsd:complexType>

   196

          <xsd:sequence>

   197

            <xsd:element name="TargetType">

   198

              <xsd:complexType>

   199

                <xsd:choice minOccurs="0">

   200

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

   201

                </xsd:choice>

   202

              </xsd:complexType>

   203

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

   204

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

   205

              <xsd:complexType>

   206

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

   207

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

   208

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

   209

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

   210

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

   211

              </xsd:complexType>

   212

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

   213

          </xsd:sequence>

   214

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

   215

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

   216

        </xsd:complexType>

   217

      </xsd:element>

   218

    </xsd:schema>

   219

    """

   220

    return XSD

   221

   222

   223

class ProjectController(ConfigTreeNode, PLCControler):

   224

   225

    """

   226

    This class define Root object of the confnode tree.

   227

    It is responsible of :

   228

    - Managing project directory

   229

    - Building project

   230

    - Handling PLCOpenEditor controler and view

   231

    - Loading user confnodes and instanciante them as children

   232

    - ...

   233

   234

    """

   235

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

   236

    # packages.

   237

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   238

    XSD = GetProjectControllerXSD()

   239

    EditorType = ProjectNodeEditor

   240

    iec2c_cfg = None

   241

   242

    def __init__(self, frame, logger):

   243

        PLCControler.__init__(self)

   244

        ConfigTreeNode.__init__(self)

   245

   246

        if ProjectController.iec2c_cfg is None:

   247

            ProjectController.iec2c_cfg = Iec2CSettings(self)

   248

   249

        self.MandatoryParams = None

   250

        self._builder = None

   251

        self._connector = None

   252

        self.DispatchDebugValuesTimer = None

   253

        self.DebugValuesBuffers = []

   254

        self.DebugTicks = []

   255

        self.SetAppFrame(frame, logger)

   256

   257

        # Setup debug information

   258

        self.IECdebug_datas = {}

   259

   260

        self.DebugUpdatePending = False

   261

        self.ResetIECProgramsAndVariables()

   262

   263

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

   264

        self.ChangesToSave = False

   265

        # root have no parent

   266

        self.CTNParent = None

   267

        # Keep track of the confnode type name

   268

        self.CTNType = "Beremiz"

   269

        self.Children = {}

   270

        self._View = None

   271

        # After __init__ root confnode is not valid

   272

        self.ProjectPath = None

   273

        self._setBuildPath(None)

   274

        self.debug_break = False

   275

        self.previous_plcstate = None

   276

        # copy StatusMethods so that it can be later customized

   277

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

   278

        self.DebugToken = None

   279

        self.LastComplainDebugToken = None

   280

        self.debug_status = PlcStatus.Stopped

   281

   282

        self.IECcodeDigest = None

   283

        self.LastBuiltIECcodeDigest = None

   284

   285

    def __del__(self):

   286

        self.KillDebugThread()

   287

   288

    def LoadLibraries(self):

   289

        self.Libraries = []

   290

        TypeStack = []

   291

        for libname, clsname, lib_enabled in features.libraries:

   292

            if self.BeremizRoot.Libraries is not None:

   293

                enable_attr = getattr(self.BeremizRoot.Libraries,

   294

                                      "Enable_" + libname + "_Library")

   295

                if enable_attr is not None:

   296

                    lib_enabled = enable_attr

   297

   298

            if lib_enabled:

   299

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

   300

                TypeStack.append(Lib.GetTypes())

   301

                self.Libraries.append(Lib)

   302

   303

    def SetAppFrame(self, frame, logger):

   304

        self.AppFrame = frame

   305

        self.logger = logger

   306

        self.StatusTimer = None

   307

        if self.DispatchDebugValuesTimer is not None:

   308

            self.DispatchDebugValuesTimer.Stop()

   309

        self.DispatchDebugValuesTimer = None

   310

   311

        if frame is not None:

   312

   313

            # Timer to pull PLC status

   314

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

   315

            self.AppFrame.Bind(wx.EVT_TIMER,

   316

                               self.PullPLCStatusProc,

   317

                               self.StatusTimer)

   318

   319

            if self._connector is not None:

   320

                frame.LogViewer.SetLogSource(self._connector)

   321

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

   322

   323

            # Timer to dispatch debug values to consumers

   324

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

   325

            self.AppFrame.Bind(wx.EVT_TIMER,

   326

                               self.DispatchDebugValuesProc,

   327

                               self.DispatchDebugValuesTimer)

   328

   329

            self.RefreshConfNodesBlockLists()

   330

   331

    def ResetAppFrame(self, logger):

   332

        if self.AppFrame is not None:

   333

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

   334

            self.StatusTimer = None

   335

            self.AppFrame = None

   336

            self.KillDebugThread()

   337

        self.logger = logger

   338

   339

    def CTNName(self):

   340

        return "Project"

   341

   342

    def CTNTestModified(self):

   343

        return self.ChangesToSave or not self.ProjectIsSaved()

   344

   345

    def CTNFullName(self):

   346

        return ""

   347

   348

    def GetCTRoot(self):

   349

        return self

   350

   351

    def GetIECLibPath(self):

   352

        return self.iec2c_cfg.getLibCPath()

   353

   354

    def GetIEC2cPath(self):

   355

        return self.iec2c_cfg.getCmd()

   356

   357

    def GetCurrentLocation(self):

   358

        return ()

   359

   360

    def GetCurrentName(self):

   361

        return ""

   362

   363

    def _GetCurrentName(self):

   364

        return ""

   365

   366

    def GetProjectPath(self):

   367

        return self.ProjectPath

   368

   369

    def GetProjectName(self):

   370

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

   371

   372

    def GetIconName(self):

   373

        return "PROJECT"

   374

   375

    def GetDefaultTargetName(self):

   376

        if wx.Platform == '__WXMSW__':

   377

            return "Win32"

   378

        else:

   379

            return "Linux"

   380

   381

    def GetTarget(self):

   382

        target = self.BeremizRoot.getTargetType()

   383

        if target.getcontent() is None:

   384

            temp_root = self.Parser.CreateRoot()

   385

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

   386

            temp_root.setTargetType(target)

   387

            target_name = self.GetDefaultTargetName()

   388

            target.setcontent(

   389

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

   390

        return target

   391

   392

    def GetParamsAttributes(self, path=None):

   393

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   394

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

   395

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

   396

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

   397

                    child.update(

   398

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

   399

        return params

   400

   401

    def SetParamsAttribute(self, path, value):

   402

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

   403

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

   404

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

   405

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

   406

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   407

        return res

   408

   409

    # helper func to check project path write permission

   410

    def CheckProjectPathPerm(self):

   411

        if CheckPathPerm(self.ProjectPath):

   412

            return True

   413

        if self.AppFrame is not None:

   414

            dialog = wx.MessageDialog(

   415

                self.AppFrame,

   416

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

   417

                _('Error'),

   418

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

   419

            answer = dialog.ShowModal()

   420

            dialog.Destroy()

   421

            if answer == wx.ID_YES:

   422

                if self.SaveProjectAs():

   423

                    self.AppFrame.RefreshTitle()

   424

                    self.AppFrame.RefreshFileMenu()

   425

                    self.AppFrame.RefreshPageTitles()

   426

                    return True

   427

        return False

   428

   429

    def _getProjectFilesPath(self, project_path=None):

   430

        if project_path is not None:

   431

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

   432

        projectfiles_path = os.path.join(

   433

            self.GetProjectPath(), "project_files")

   434

        if not os.path.exists(projectfiles_path):

   435

            os.mkdir(projectfiles_path)

   436

        return projectfiles_path

   437

   438

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

   439

        self.ProjectAddConfiguration(config_name)

   440

        self.ProjectAddConfigurationResource(config_name, res_name)

   441

   442

    def SetProjectDefaultConfiguration(self):

   443

        # Sets default task and instance for new project

   444

        config = self.Project.getconfiguration(

   445

            self.GetProjectMainConfigurationName())

   446

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

   447

        config = config.getname()

   448

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   449

        def_task = [

   450

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

   451

        def_instance = [

   452

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

   453

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   454

   455

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

   456

        """

   457

        Create a new project in an empty folder

   458

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

   459

        @param PLCParams: properties of the PLCOpen program created

   460

        """

   461

        # Verify that chosen folder is empty

   462

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

   463

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

   464

   465

        # Create PLCOpen program

   466

        self.CreateNewProject(

   467

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

   468

             "productName": _("Unnamed"),

   469

             "productVersion": "1",

   470

             "companyName": _("Unknown"),

   471

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

   472

        self.AddProjectDefaultConfiguration()

   473

   474

        # Change XSD into class members

   475

        self._AddParamsMembers()

   476

        self.Children = {}

   477

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

   478

        self.ProjectPath = ProjectPath

   479

        self._setBuildPath(BuildPath)

   480

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