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 datetime import datetime

    40

from weakref import WeakKeyDictionary

    41

from functools import reduce

    42

from itertools import izip

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

   103

        self.iec2c = None

   104

        self.iec2c_buildopts = None

   105

        self.ieclib_path = self.findLibPath()

   106

        self.ieclib_c_path = self.findLibCPath()

   107

        self.controler = controler

   108

   109

    def findObject(self, paths, test):

   110

        path = None

   111

        for p in paths:

   112

            if test(p):

   113

                path = p

   114

                break

   115

        return path

   116

   117

    def findCmd(self):

   118

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

   119

        paths = [

   120

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

   121

        ]

   122

        path = self.findObject(

   123

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

   124

   125

        # otherwise use iec2c from PATH

   126

        if path is not None:

   127

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

   128

   129

        return cmd

   130

   131

    def findLibPath(self):

   132

        paths = [

   133

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

   134

            "/usr/lib/matiec"

   135

        ]

   136

        path = self.findObject(

   137

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

   138

        return path

   139

   140

    def findLibCPath(self):

   141

        path = None

   142

        if self.ieclib_path is not None:

   143

            paths = [

   144

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

   145

                self.ieclib_path]

   146

            path = self.findObject(

   147

                paths,

   148

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

   149

        return path

   150

   151

    def findSupportedOptions(self):

   152

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

   153

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

   154

   155

        buildopt = ""

   156

        try:

   157

            # Invoke compiler.

   158

            # Output files are listed to stdout, errors to stderr

   159

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

   160

                                                         no_stdout=True,

   161

                                                         no_stderr=True).spin()

   162

        except Exception:

   163

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

   164

            return buildopt

   165

   166

        for opt in options:

   167

            if opt in result:

   168

                buildopt = buildopt + " " + opt

   169

        return buildopt

   170

   171

    def getCmd(self):

   172

        if self.iec2c is None:

   173

            self.iec2c = self.findCmd()

   174

        return self.iec2c

   175

   176

    def getOptions(self):

   177

        if self.iec2c_buildopts is None:

   178

            self.iec2c_buildopts = self.findSupportedOptions()

   179

        return self.iec2c_buildopts

   180

   181

    def getLibPath(self):

   182

        return self.ieclib_path

   183

   184

    def getLibCPath(self):

   185

        if self.ieclib_c_path is None:

   186

            self.ieclib_c_path = self.findLibCPath()

   187

        return self.ieclib_c_path

   188

   189

   190

def GetProjectControllerXSD():

   191

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

   192

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

   193

      <xsd:element name="BeremizRoot">

   194

        <xsd:complexType>

   195

          <xsd:sequence>

   196

            <xsd:element name="TargetType">

   197

              <xsd:complexType>

   198

                <xsd:choice minOccurs="0">

   199

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

   200

                </xsd:choice>

   201

              </xsd:complexType>

   202

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

   203

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

   204

              <xsd:complexType>

   205

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

   206

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

   207

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

   208

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

   209

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

   210

              </xsd:complexType>

   211

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

   212

          </xsd:sequence>

   213

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

   214

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

   215

        </xsd:complexType>

   216

      </xsd:element>

   217

    </xsd:schema>

   218

    """

   219

    return XSD

   220

   221

   222

class ProjectController(ConfigTreeNode, PLCControler):

   223

   224

    """

   225

    This class define Root object of the confnode tree.

   226

    It is responsible of :

   227

    - Managing project directory

   228

    - Building project

   229

    - Handling PLCOpenEditor controler and view

   230

    - Loading user confnodes and instanciante them as children

   231

    - ...

   232

   233

    """

   234

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

   235

    # packages.

   236

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   237

    XSD = GetProjectControllerXSD()

   238

    EditorType = ProjectNodeEditor

   239

    iec2c_cfg = None

   240

   241

    def __init__(self, frame, logger):

   242

        PLCControler.__init__(self)

   243

        ConfigTreeNode.__init__(self)

   244

   245

        if ProjectController.iec2c_cfg is None:

   246

            ProjectController.iec2c_cfg = Iec2CSettings(self)

   247

   248

        self.MandatoryParams = None

   249

        self._builder = None

   250

        self._connector = None

   251

        self.DispatchDebugValuesTimer = None

   252

        self.DebugValuesBuffers = []

   253

        self.DebugTicks = []

   254

        self.SetAppFrame(frame, logger)

   255

   256

        # Setup debug information

   257

        self.IECdebug_datas = {}

   258

   259

        self.DebugUpdatePending = False

   260

        self.ResetIECProgramsAndVariables()

   261

   262

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

   263

        self.ChangesToSave = False

   264

        # root have no parent

   265

        self.CTNParent = None

   266

        # Keep track of the confnode type name

   267

        self.CTNType = "Beremiz"

   268

        self.Children = {}

   269

        self._View = None

   270

        # After __init__ root confnode is not valid

   271

        self.ProjectPath = None

   272

        self._setBuildPath(None)

   273

        self.debug_break = False

   274

        self.previous_plcstate = None

   275

        # copy StatusMethods so that it can be later customized

   276

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

   277

        self.DebugToken = None

   278

        self.debug_status = PlcStatus.Stopped

   279

   280

    def __del__(self):

   281

        self.KillDebugThread()

   282

   283

    def LoadLibraries(self):

   284

        self.Libraries = []

   285

        TypeStack = []

   286

        for libname, clsname, lib_enabled in features.libraries:

   287

            if self.BeremizRoot.Libraries is not None:

   288

                enable_attr = getattr(self.BeremizRoot.Libraries,

   289

                                      "Enable_" + libname + "_Library")

   290

                if enable_attr is not None:

   291

                    lib_enabled = enable_attr

   292

   293

            if lib_enabled:

   294

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

   295

                TypeStack.append(Lib.GetTypes())

   296

                self.Libraries.append(Lib)

   297

   298

    def SetAppFrame(self, frame, logger):

   299

        self.AppFrame = frame

   300

        self.logger = logger

   301

        self.StatusTimer = None

   302

        if self.DispatchDebugValuesTimer is not None:

   303

            self.DispatchDebugValuesTimer.Stop()

   304

        self.DispatchDebugValuesTimer = None

   305

   306

        if frame is not None:

   307

   308

            # Timer to pull PLC status

   309

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

   310

            self.AppFrame.Bind(wx.EVT_TIMER,

   311

                               self.PullPLCStatusProc,

   312

                               self.StatusTimer)

   313

   314

            if self._connector is not None:

   315

                frame.LogViewer.SetLogSource(self._connector)

   316

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

   317

   318

            # Timer to dispatch debug values to consumers

   319

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

   320

            self.AppFrame.Bind(wx.EVT_TIMER,

   321

                               self.DispatchDebugValuesProc,

   322

                               self.DispatchDebugValuesTimer)

   323

   324

            self.RefreshConfNodesBlockLists()

   325

   326

    def ResetAppFrame(self, logger):

   327

        if self.AppFrame is not None:

   328

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

   329

            self.StatusTimer = None

   330

            self.AppFrame = None

   331

            self.KillDebugThread()

   332

        self.logger = logger

   333

   334

    def CTNName(self):

   335

        return "Project"

   336

   337

    def CTNTestModified(self):

   338

        return self.ChangesToSave or not self.ProjectIsSaved()

   339

   340

    def CTNFullName(self):

   341

        return ""

   342

   343

    def GetCTRoot(self):

   344

        return self

   345

   346

    def GetIECLibPath(self):

   347

        return self.iec2c_cfg.getLibCPath()

   348

   349

    def GetIEC2cPath(self):

   350

        return self.iec2c_cfg.getCmd()

   351

   352

    def GetCurrentLocation(self):

   353

        return ()

   354

   355

    def GetCurrentName(self):

   356

        return ""

   357

   358

    def _GetCurrentName(self):

   359

        return ""

   360

   361

    def GetProjectPath(self):

   362

        return self.ProjectPath

   363

   364

    def GetProjectName(self):

   365

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

   366

   367

    def GetIconName(self):

   368

        return "PROJECT"

   369

   370

    def GetDefaultTargetName(self):

   371

        if wx.Platform == '__WXMSW__':

   372

            return "Win32"

   373

        else:

   374

            return "Linux"

   375

   376

    def GetTarget(self):

   377

        target = self.BeremizRoot.getTargetType()

   378

        if target.getcontent() is None:

   379

            temp_root = self.Parser.CreateRoot()

   380

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

   381

            temp_root.setTargetType(target)

   382

            target_name = self.GetDefaultTargetName()

   383

            target.setcontent(

   384

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

   385

        return target

   386

   387

    def GetParamsAttributes(self, path=None):

   388

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   389

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

   390

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

   391

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

   392

                    child.update(

   393

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

   394

        return params

   395

   396

    def SetParamsAttribute(self, path, value):

   397

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

   398

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

   399

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

   400

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

   401

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   402

        return res

   403

   404

    # helper func to check project path write permission

   405

    def CheckProjectPathPerm(self):

   406

        if CheckPathPerm(self.ProjectPath):

   407

            return True

   408

        if self.AppFrame is not None:

   409

            dialog = wx.MessageDialog(

   410

                self.AppFrame,

   411

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

   412

                _('Error'),

   413

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

   414

            answer = dialog.ShowModal()

   415

            dialog.Destroy()

   416

            if answer == wx.ID_YES:

   417

                if self.SaveProjectAs():

   418

                    self.AppFrame.RefreshTitle()

   419

                    self.AppFrame.RefreshFileMenu()

   420

                    self.AppFrame.RefreshPageTitles()

   421

                    return True

   422

        return False

   423

   424

    def _getProjectFilesPath(self, project_path=None):

   425

        if project_path is not None:

   426

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

   427

        projectfiles_path = os.path.join(

   428

            self.GetProjectPath(), "project_files")

   429

        if not os.path.exists(projectfiles_path):

   430

            os.mkdir(projectfiles_path)

   431

        return projectfiles_path

   432

   433

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

   434

        self.ProjectAddConfiguration(config_name)

   435

        self.ProjectAddConfigurationResource(config_name, res_name)

   436

   437

    def SetProjectDefaultConfiguration(self):

   438

        # Sets default task and instance for new project

   439

        config = self.Project.getconfiguration(

   440

            self.GetProjectMainConfigurationName())

   441

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

   442

        config = config.getname()

   443

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   444

        def_task = [

   445

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

   446

        def_instance = [

   447

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

   448

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   449

   450

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

   451

        """

   452

        Create a new project in an empty folder

   453

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

   454

        @param PLCParams: properties of the PLCOpen program created

   455

        """

   456

        # Verify that chosen folder is empty

   457

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

   458

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

   459

   460

        # Create PLCOpen program

   461

        self.CreateNewProject(

   462

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

   463

             "productName": _("Unnamed"),

   464

             "productVersion": "1",

   465

             "companyName": _("Unknown"),

   466

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

   467

        self.AddProjectDefaultConfiguration()

   468

   469

        # Change XSD into class members

   470

        self._AddParamsMembers()

   471

        self.Children = {}

   472

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

   473

        self.ProjectPath = ProjectPath

   474

        self._setBuildPath(BuildPath)

   475

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

   476

        self.RefreshConfNodesBlockLists()

   477

        # this will create files base XML files

   478

        self.SaveProject()

   479

        return None

   480