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

import sys

    31

import os

    32

import traceback

    33

import time

    34

from time import localtime

    35

import shutil

    36

import re

    37

import tempfile

    38

import hashlib

    39

import shutil

    40

from datetime import datetime

    41

from weakref import WeakKeyDictionary

    42

from functools import reduce

    43

    44

import wx

    45

    46

import features

    47

import connectors

    48

import util.paths as paths

    49

from util.misc import CheckPathPerm, GetClassImporter

    50

from util.MiniTextControler import MiniTextControler

    51

from util.ProcessLogger import ProcessLogger

    52

from util.BitmapLibrary import GetBitmap

    53

from editors.FileManagementPanel import FileManagementPanel

    54

from editors.ProjectNodeEditor import ProjectNodeEditor

    55

from editors.IECCodeViewer import IECCodeViewer

    56

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    57

from dialogs import UriEditor, IDManager

    58

from PLCControler import PLCControler

    59

from plcopen.structures import IEC_KEYWORDS

    60

from plcopen.types_enums import ComputeConfigurationResourceName, ITEM_CONFNODE

    61

import targets

    62

from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer

    63

from runtime import PlcStatus

    64

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    65

from POULibrary import UserAddressedException

    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, controler):

   101

        self.iec2c = None

   102

        self.iec2c_buildopts = None

   103

        self.ieclib_path = self.findLibPath()

   104

        self.ieclib_c_path = self.findLibCPath()

   105

        self.controler = controler

   106

   107

    def findObject(self, paths, test):

   108

        path = None

   109

        for p in paths:

   110

            if test(p):

   111

                path = p

   112

                break

   113

        return path

   114

   115

    def findCmd(self):

   116

        cmd = "iec2c" + (".exe" if os.name == 'nt' else "")

   117

        paths = [

   118

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

   119

        ]

   120

        path = self.findObject(

   121

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

   122

   123

        # otherwise use iec2c from PATH

   124

        if path is not None:

   125

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

   126

   127

        return cmd

   128

   129

    def findLibPath(self):

   130

        paths = [

   131

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

   132

            "/usr/lib/matiec"

   133

        ]

   134

        path = self.findObject(

   135

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

   136

        return path

   137

   138

    def findLibCPath(self):

   139

        path = None

   140

        if self.ieclib_path is not None:

   141

            paths = [

   142

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

   143

                self.ieclib_path]

   144

            path = self.findObject(

   145

                paths,

   146

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

   147

        return path

   148

   149

    def findSupportedOptions(self):

   150

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

   151

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

   152

   153

        buildopt = ""

   154

        try:

   155

            # Invoke compiler.

   156

            # Output files are listed to stdout, errors to stderr

   157

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

   158

                                                         no_stdout=True,

   159

                                                         no_stderr=True).spin()

   160

        except Exception:

   161

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

   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(self)

   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.LastComplainDebugToken = None

   277

        self.debug_status = PlcStatus.Stopped

   278

   279

        self.IECcodeDigest = None

   280

        self.LastBuiltIECcodeDigest = None

   281

   282

    def LoadLibraries(self):

   283

        self.Libraries = []

   284

        TypeStack = []

   285

        for libname, clsname, lib_enabled in features.libraries:

   286

            if self.BeremizRoot.Libraries is not None:

   287

                enable_attr = getattr(self.BeremizRoot.Libraries,

   288

                                      "Enable_" + libname + "_Library")

   289

                if enable_attr is not None:

   290

                    lib_enabled = enable_attr

   291

   292

            if lib_enabled:

   293

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

   294

                TypeStack.append(Lib.GetTypes())

   295

                self.Libraries.append(Lib)

   296

   297

    def SetAppFrame(self, frame, logger):

   298

        self.AppFrame = frame

   299

        self.logger = logger

   300

        self.StatusTimer = None

   301

        if self.DispatchDebugValuesTimer is not None:

   302

            self.DispatchDebugValuesTimer.Stop()

   303

        self.DispatchDebugValuesTimer = None

   304

   305

        if frame is not None:

   306

   307

            # Timer to pull PLC status

   308

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

   309

            self.AppFrame.Bind(wx.EVT_TIMER,

   310

                               self.PullPLCStatusProc,

   311

                               self.StatusTimer)

   312

   313

            if self._connector is not None:

   314

                frame.LogViewer.SetLogSource(self._connector)

   315

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

   316

   317

            # Timer to dispatch debug values to consumers

   318

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

   319

            self.AppFrame.Bind(wx.EVT_TIMER,

   320

                               self.DispatchDebugValuesProc,

   321

                               self.DispatchDebugValuesTimer)

   322

   323

            self.RefreshConfNodesBlockLists()

   324

   325

    def ResetAppFrame(self, logger):

   326

        if self.AppFrame is not None:

   327

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

   328

            self.StatusTimer = None

   329

            self.AppFrame = None

   330

            self.KillDebugThread()

   331

        self.logger = logger

   332

   333

    def CTNName(self):

   334

        return "Project"

   335

   336

    def CTNTestModified(self):

   337

        return self.ChangesToSave or not self.ProjectIsSaved()

   338

   339

    def CTNFullName(self):

   340

        return ""

   341

   342

    def GetCTRoot(self):

   343

        return self

   344

   345

    def GetIECLibPath(self):

   346

        return self.iec2c_cfg.getLibCPath()

   347

   348

    def GetIEC2cPath(self):

   349

        return self.iec2c_cfg.getCmd()

   350

   351

    def GetCurrentLocation(self):

   352

        return ()

   353

   354

    def GetCurrentName(self):

   355

        return ""

   356

   357

    def _GetCurrentName(self):

   358

        return ""

   359

   360

    def GetProjectPath(self):

   361

        return self.ProjectPath

   362

   363

    def GetProjectName(self):

   364

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

   365

   366

    def GetIconName(self):

   367

        return "PROJECT"

   368

   369

    def GetDefaultTargetName(self):

   370

        if sys.platform.startswith('linux'):

   371

            return "Linux"

   372

        elif sys.platform.startswith('darwin'):

   373

            return "OSX"

   374

        elif sys.platform.startswith('win32'):

   375

            return "Win32"

   376

   377

        # Fall back to Linux as default target

   378

        return "Linux"

   379

   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?)

   481