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, UserAddressedException

    67

    68

base_folder = paths.AbsParentDir(__file__)

    69

    70

MATIEC_ERROR_MODEL = re.compile(

    71

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

    72

    73

    74

def ExtractChildrenTypesFromCatalog(catalog):

    75

    children_types = []

    76

    for n, d, _h, c in catalog:

    77

        if isinstance(c, list):

    78

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    79

        else:

    80

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

    81

    return children_types

    82

    83

    84

def ExtractMenuItemsFromCatalog(catalog):

    85

    menu_items = []

    86

    for n, d, h, c in catalog:

    87

        if isinstance(c, list):

    88

            children = ExtractMenuItemsFromCatalog(c)

    89

        else:

    90

            children = []

    91

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

    92

    return menu_items

    93

    94

    95

def GetAddMenuItems():

    96

    return ExtractMenuItemsFromCatalog(features.catalog)

    97

    98

    99

class Iec2CSettings(object):

   100

   101

    def __init__(self):

   102

        self.iec2c = None

   103

        self.iec2c_buildopts = None

   104

        self.ieclib_path = self.findLibPath()

   105

        self.ieclib_c_path = self.findLibCPath()

   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 wx.Platform == '__WXMSW__' 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(None, buildcmd,

   158

                                                         no_stdout=True,

   159

                                                         no_stderr=True).spin()

   160

        except Exception:

   161

            return buildopt

   162

   163

        for opt in options:

   164

            if opt in result:

   165

                buildopt = buildopt + " " + opt

   166

        return buildopt

   167

   168

    def getCmd(self):

   169

        if self.iec2c is None:

   170

            self.iec2c = self.findCmd()

   171

        return self.iec2c

   172

   173

    def getOptions(self):

   174

        if self.iec2c_buildopts is None:

   175

            self.iec2c_buildopts = self.findSupportedOptions()

   176

        return self.iec2c_buildopts

   177

   178

    def getLibPath(self):

   179

        return self.ieclib_path

   180

   181

    def getLibCPath(self):

   182

        if self.ieclib_c_path is None:

   183

            self.ieclib_c_path = self.findLibCPath()

   184

        return self.ieclib_c_path

   185

   186

   187

def GetProjectControllerXSD():

   188

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

   189

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

   190

      <xsd:element name="BeremizRoot">

   191

        <xsd:complexType>

   192

          <xsd:sequence>

   193

            <xsd:element name="TargetType">

   194

              <xsd:complexType>

   195

                <xsd:choice minOccurs="0">

   196

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

   197

                </xsd:choice>

   198

              </xsd:complexType>

   199

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

   200

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

   201

              <xsd:complexType>

   202

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

   203

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

   204

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

   205

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

   206

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

   207

              </xsd:complexType>

   208

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

   209

          </xsd:sequence>

   210

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

   211

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

   212

        </xsd:complexType>

   213

      </xsd:element>

   214

    </xsd:schema>

   215

    """

   216

    return XSD

   217

   218

   219

class ProjectController(ConfigTreeNode, PLCControler):

   220

   221

    """

   222

    This class define Root object of the confnode tree.

   223

    It is responsible of :

   224

    - Managing project directory

   225

    - Building project

   226

    - Handling PLCOpenEditor controler and view

   227

    - Loading user confnodes and instanciante them as children

   228

    - ...

   229

   230

    """

   231

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

   232

    # packages.

   233

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   234

    XSD = GetProjectControllerXSD()

   235

    EditorType = ProjectNodeEditor

   236

    iec2c_cfg = None

   237

   238

    def __init__(self, frame, logger):

   239

        PLCControler.__init__(self)

   240

        ConfigTreeNode.__init__(self)

   241

   242

        if ProjectController.iec2c_cfg is None:

   243

            ProjectController.iec2c_cfg = Iec2CSettings()

   244

   245

        self.MandatoryParams = None

   246

        self._builder = None

   247

        self._connector = None

   248

        self.DispatchDebugValuesTimer = None

   249

        self.DebugValuesBuffers = []

   250

        self.DebugTicks = []

   251

        self.SetAppFrame(frame, logger)

   252

   253

        # Setup debug information

   254

        self.IECdebug_datas = {}

   255

   256

        self.DebugTimer = None

   257

        self.ResetIECProgramsAndVariables()

   258

   259

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

   260

        self.ChangesToSave = False

   261

        # root have no parent

   262

        self.CTNParent = None

   263

        # Keep track of the confnode type name

   264

        self.CTNType = "Beremiz"

   265

        self.Children = {}

   266

        self._View = None

   267

        # After __init__ root confnode is not valid

   268

        self.ProjectPath = None

   269

        self._setBuildPath(None)

   270

        self.debug_break = False

   271

        self.previous_plcstate = None

   272

        # copy StatusMethods so that it can be later customized

   273

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

   274

        self.DebugToken = None

   275

        self.debug_status = PlcStatus.Stopped

   276

   277

    def __del__(self):

   278

        if self.DebugTimer:

   279

            self.DebugTimer.cancel()

   280

        self.KillDebugThread()

   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 wx.Platform == '__WXMSW__':

   371

            return "Win32"

   372

        else:

   373

            return "Linux"

   374

   375

    def GetTarget(self):

   376

        target = self.BeremizRoot.getTargetType()

   377

        if target.getcontent() is None:

   378

            temp_root = self.Parser.CreateRoot()

   379

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

   380

            temp_root.setTargetType(target)

   381

            target_name = self.GetDefaultTargetName()

   382

            target.setcontent(

   383

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

   384

        return target

   385

   386

    def GetParamsAttributes(self, path=None):

   387

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   388

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

   389

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

   390

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

   391

                    child.update(

   392

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

   393

        return params

   394

   395

    def SetParamsAttribute(self, path, value):

   396

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

   397

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

   398

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

   399

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

   400

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   401

        return res

   402

   403

    # helper func to check project path write permission

   404

    def CheckProjectPathPerm(self, dosave=True):

   405

        if CheckPathPerm(self.ProjectPath):

   406

            return True

   407

        if self.AppFrame is not None:

   408

            dialog = wx.MessageDialog(

   409

                self.AppFrame,

   410

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

   411

                _('Error'),

   412

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

   413

            answer = dialog.ShowModal()

   414

            dialog.Destroy()

   415

            if answer == wx.ID_YES:

   416

                if self.SaveProjectAs():

   417

                    self.AppFrame.RefreshTitle()

   418

                    self.AppFrame.RefreshFileMenu()

   419

                    self.AppFrame.RefreshPageTitles()

   420

                    return True

   421

        return False

   422

   423

    def _getProjectFilesPath(self, project_path=None):

   424

        if project_path is not None:

   425

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

   426

        projectfiles_path = os.path.join(

   427

            self.GetProjectPath(), "project_files")

   428

        if not os.path.exists(projectfiles_path):

   429

            os.mkdir(projectfiles_path)

   430

        return projectfiles_path

   431

   432

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

   433

        self.ProjectAddConfiguration(config_name)

   434

        self.ProjectAddConfigurationResource(config_name, res_name)

   435

   436

    def SetProjectDefaultConfiguration(self):

   437

        # Sets default task and instance for new project

   438

        config = self.Project.getconfiguration(

   439

            self.GetProjectMainConfigurationName())

   440

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

   441

        config = config.getname()

   442

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   443

        def_task = [

   444

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

   445

        def_instance = [

   446

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

   447

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   448

   449

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

   450

        """

   451

        Create a new project in an empty folder

   452

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

   453

        @param PLCParams: properties of the PLCOpen program created

   454

        """

   455

        # Verify that chosen folder is empty

   456

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

   457

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

   458

   459

        # Create PLCOpen program

   460

        self.CreateNewProject(

   461

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

   462

             "productName": _("Unnamed"),

   463

             "productVersion": "1",

   464

             "companyName": _("Unknown"),

   465

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

   466

        self.AddProjectDefaultConfiguration()

   467

   468

        # Change XSD into class members

   469

        self._AddParamsMembers()

   470

        self.Children = {}

   471

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

   472

        self.ProjectPath = ProjectPath

   473

        self._setBuildPath(BuildPath)

   474

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

   475

        self.RefreshConfNodesBlockLists()

   476

        # this will create files base XML files

   477

        self.SaveProject()

   478

        return None

   479

   480

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