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

from collections import OrderedDict

    44

    45

import wx

    46

    47

import features

    48

import connectors

    49

import util.paths as paths

    50

from util.misc import CheckPathPerm, GetClassImporter

    51

from util.MiniTextControler import MiniTextControler

    52

from util.ProcessLogger import ProcessLogger

    53

from util.BitmapLibrary import GetBitmap

    54

from editors.FileManagementPanel import FileManagementPanel

    55

from editors.ProjectNodeEditor import ProjectNodeEditor

    56

from editors.IECCodeViewer import IECCodeViewer

    57

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    58

from dialogs import UriEditor, IDManager

    59

from PLCControler import PLCControler

    60

from plcopen.structures import IEC_KEYWORDS

    61

from plcopen.types_enums import ComputeConfigurationResourceName, ITEM_CONFNODE

    62

import targets

    63

from runtime.typemapping import DebugTypesSize, UnpackDebugBuffer, ValueToIECBytes

    64

from runtime import PlcStatus

    65

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    66

from POULibrary import 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 name, displayname, _helpstr, moduleclassname in catalog:

    77

        if isinstance(moduleclassname, list):

    78

            children_types.extend(ExtractChildrenTypesFromCatalog(moduleclassname))

    79

        else:

    80

            children_types.append((name, GetClassImporter(moduleclassname), displayname))

    81

    return children_types

    82

    83

    84

def ExtractMenuItemsFromCatalog(catalog):

    85

    menu_items = []

    86

    for name, displayname, helpstr, moduleclassname in catalog:

    87

        if isinstance(moduleclassname, list):

    88

            children = ExtractMenuItemsFromCatalog(moduleclassname)

    89

        else:

    90

            children = []

    91

        menu_items.append((name, displayname, helpstr, 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, controler):

   102

        self.iec2c = None

   103

        self.iec2c_buildopts = None

   104

        self.ieclib_path = self.findLibPath()

   105

        self.ieclib_c_path = self.findLibCPath()

   106

        self.controler = controler

   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 os.name == 'nt' 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(self.controler.logger, buildcmd,

   159

                                                         no_stdout=True,

   160

                                                         no_stderr=True).spin()

   161

        except Exception:

   162

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

   163

            return buildopt

   164

   165

        for opt in options:

   166

            if opt in result:

   167

                buildopt = buildopt + " " + opt

   168

        return buildopt

   169

   170

    def getCmd(self):

   171

        if self.iec2c is None:

   172

            self.iec2c = self.findCmd()

   173

        return self.iec2c

   174

   175

    def getOptions(self):

   176

        if self.iec2c_buildopts is None:

   177

            self.iec2c_buildopts = self.findSupportedOptions()

   178

        return self.iec2c_buildopts

   179

   180

    def getLibPath(self):

   181

        return self.ieclib_path

   182

   183

    def getLibCPath(self):

   184

        if self.ieclib_c_path is None:

   185

            self.ieclib_c_path = self.findLibCPath()

   186

        return self.ieclib_c_path

   187

   188

   189

def GetProjectControllerXSD():

   190

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

   191

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

   192

      <xsd:element name="BeremizRoot">

   193

        <xsd:complexType>

   194

          <xsd:sequence>

   195

            <xsd:element name="TargetType">

   196

              <xsd:complexType>

   197

                <xsd:choice minOccurs="0">

   198

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

   199

                </xsd:choice>

   200

              </xsd:complexType>

   201

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

   202

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

   203

              <xsd:complexType>

   204

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

   205

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

   206

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

   207

                               ('false' if type(default)==str or default==False else 'true') + '"/>'

   208

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

   209

              </xsd:complexType>

   210

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

   211

          </xsd:sequence>

   212

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

   213

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

   214

        </xsd:complexType>

   215

      </xsd:element>

   216

    </xsd:schema>

   217

    """

   218

    return XSD

   219

   220

   221

class ProjectController(ConfigTreeNode, PLCControler):

   222

   223

    """

   224

    This class define Root object of the confnode tree.

   225

    It is responsible of :

   226

    - Managing project directory

   227

    - Building project

   228

    - Handling PLCOpenEditor controler and view

   229

    - Loading user confnodes and instanciante them as children

   230

    - ...

   231

   232

    """

   233

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

   234

    # packages.

   235

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   236

    XSD = GetProjectControllerXSD()

   237

    EditorType = ProjectNodeEditor

   238

    iec2c_cfg = None

   239

   240

    def __init__(self, frame, logger):

   241

        PLCControler.__init__(self)

   242

        ConfigTreeNode.__init__(self)

   243

   244

        if ProjectController.iec2c_cfg is None:

   245

            ProjectController.iec2c_cfg = Iec2CSettings(self)

   246

   247

        self.MandatoryParams = None

   248

        self._builder = None

   249

        self._connector = None

   250

        self.DispatchDebugValuesTimer = None

   251

        self.DebugValuesBuffers = []

   252

        self.DebugTicks = []

   253

        self.SetAppFrame(frame, logger)

   254

   255

        # Setup debug information

   256

        self.IECdebug_datas = {}

   257

   258

        self.DebugUpdatePending = False

   259

        self.ResetIECProgramsAndVariables()

   260

   261

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

   262

        self.ChangesToSave = False

   263

        # root have no parent

   264

        self.CTNParent = None

   265

        # Keep track of the confnode type name

   266

        self.CTNType = "Beremiz"

   267

        self.Children = {}

   268

        self._View = None

   269

        # After __init__ root confnode is not valid

   270

        self.ProjectPath = None

   271

        self._setBuildPath(None)

   272

        self.debug_break = False

   273

        self.previous_plcstate = None

   274

        # copy StatusMethods so that it can be later customized

   275

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

   276

        self.DebugToken = None

   277

        self.LastComplainDebugToken = None

   278

        self.debug_status = PlcStatus.Stopped

   279

   280

        self.IECcodeDigest = None

   281

        self.LastBuiltIECcodeDigest = None

   282

   283

    def LoadLibraries(self):

   284

        self.Libraries = OrderedDict()

   285

        TypeStack = []

   286

        for libname, clsname, default in features.libraries:

   287

            lib_enabled = False if type(default)==str else default

   288

            if self.BeremizRoot.Libraries is not None:

   289

                enable_attr = getattr(self.BeremizRoot.Libraries,

   290

                                      "Enable_" + libname + "_Library")

   291

                if enable_attr is not None:

   292

                    lib_enabled = enable_attr

   293

   294

            if lib_enabled:

   295

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

   296

                TypeStack.append(Lib.GetTypes())

   297

                self.Libraries[libname] = Lib

   298

   299

    def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   300

        """ 

   301

        Project controller applies libraries requirements when adding new CTN

   302

        """

   303

        res = ConfigTreeNode.CTNAddChild(self, CTNName, CTNType, IEC_Channel)

   304

   305

        # find library associated with new CTN, if any

   306

        associated_lib = {default:libname 

   307

                          for libname, _clsname, default 

   308

                          in features.libraries}.get(CTNType, None)

   309

   310

        # if any, then enable it if it wasn't and inform user

   311

        if associated_lib is not None:

   312

            # FIXME: This should be done with GetParamsAttribute

   313

            # but it fails with missing optional attributes

   314

            attrname = "Enable_" + associated_lib + "_Library"

   315

            libobj = self.BeremizRoot.Libraries

   316

            lib_enabled = False if libobj is None else getattr(libobj, attrname)

   317

            if not lib_enabled:

   318

                # use SetParamsAttribute to trigger reload of libs

   319

                self.SetParamsAttribute("BeremizRoot.Libraries.Enable_" + associated_lib + "_Library", True)

   320

                msg = _("Enabled {a1} library, required by {a2} extension\n").format(

   321

                    a1=associated_lib, a2=CTNType)

   322

                self.GetCTRoot().logger.write(msg)

   323

   324

        return res

   325

   326

    def SetAppFrame(self, frame, logger):

   327

        self.AppFrame = frame

   328

        self.logger = logger

   329

        self.StatusTimer = None

   330

        if self.DispatchDebugValuesTimer is not None:

   331

            self.DispatchDebugValuesTimer.Stop()

   332

        self.DispatchDebugValuesTimer = None

   333

   334

        if frame is not None:

   335

   336

            # Timer to pull PLC status

   337

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

   338

            self.AppFrame.Bind(wx.EVT_TIMER,

   339

                               self.PullPLCStatusProc,

   340

                               self.StatusTimer)

   341

   342

            if self._connector is not None:

   343

                frame.LogViewer.SetLogSource(self._connector)

   344

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

   345

   346

            # Timer to dispatch debug values to consumers

   347

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

   348

            self.AppFrame.Bind(wx.EVT_TIMER,

   349

                               self.DispatchDebugValuesProc,

   350

                               self.DispatchDebugValuesTimer)

   351

   352

            self.RefreshConfNodesBlockLists()

   353

   354

    def ResetAppFrame(self, logger):

   355

        if self.AppFrame is not None:

   356

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

   357

            self.StatusTimer = None

   358

            self.AppFrame = None

   359

            self.KillDebugThread()

   360

        self.logger = logger

   361

   362

    def CTNName(self):

   363

        return "Project"

   364

   365

    def CTNTestModified(self):

   366

        return self.ChangesToSave or not self.ProjectIsSaved()

   367

   368

    def CTNFullName(self):

   369

        return ""

   370

   371

    def GetCTRoot(self):

   372

        return self

   373

   374

    def GetIECLibPath(self):

   375

        return self.iec2c_cfg.getLibCPath()

   376

   377

    def GetIEC2cPath(self):

   378

        return self.iec2c_cfg.getCmd()

   379

   380

    def GetCurrentLocation(self):

   381

        return ()

   382

   383

    def GetCurrentName(self):

   384

        return ""

   385

   386

    def _GetCurrentName(self):

   387

        return ""

   388

   389

    def GetProjectPath(self):

   390

        return self.ProjectPath

   391

   392

    def GetProjectName(self):

   393

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

   394

   395

    def GetIconName(self):

   396

        return "PROJECT"

   397

   398

    def GetDefaultTargetName(self):

   399

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

   400

            return "Linux"

   401

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

   402

            return "OSX"

   403

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

   404

            return "Win32"

   405

   406

        # Fall back to Linux as default target

   407

        return "Linux"

   408

   409

   410

    def GetTarget(self):

   411

        target = self.BeremizRoot.getTargetType()

   412

        if target.getcontent() is None:

   413

            temp_root = self.Parser.CreateRoot()

   414

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

   415

            temp_root.setTargetType(target)

   416

            target_name = self.GetDefaultTargetName()

   417

            target.setcontent(

   418

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

   419

        return target

   420

   421

    def GetParamsAttributes(self, path=None):

   422

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   423

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

   424

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

   425

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

   426

                    child.update(

   427

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

   428

        return params

   429

   430

    def SetParamsAttribute(self, path, value):

   431

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

   432

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

   433

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

   434

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

   435

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   436

        return res

   437

   438

    # helper func to check project path write permission

   439

    def CheckProjectPathPerm(self):

   440

        if CheckPathPerm(self.ProjectPath):

   441

            return True

   442

        if self.AppFrame is not None:

   443

            dialog = wx.MessageDialog(

   444

                self.AppFrame,

   445

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

   446

                _('Error'),

   447

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

   448

            answer = dialog.ShowModal()

   449

            dialog.Destroy()

   450

            if answer == wx.ID_YES:

   451

                if self.SaveProjectAs():

   452

                    self.AppFrame.RefreshTitle()

   453

                    self.AppFrame.RefreshFileMenu()

   454

                    self.AppFrame.RefreshPageTitles()

   455

                    return True

   456

        return False

   457

   458

    def _getProjectFilesPath(self, project_path=None):

   459

        if project_path is not None:

   460

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

   461

        projectfiles_path = os.path.join(

   462

            self.GetProjectPath(), "project_files")

   463

        if not os.path.exists(projectfiles_path):

   464

            os.mkdir(projectfiles_path)

   465

        return projectfiles_path

   466

   467

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

   468

        self.ProjectAddConfiguration(config_name)

   469

        self.ProjectAddConfigurationResource(config_name, res_name)

   470

   471

    def SetProjectDefaultConfiguration(self):

   472

        # Sets default task and instance for new project

   473

        config = self.Project.getconfiguration(

   474

            self.GetProjectMainConfigurationName())

   475

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

   476

        config = config.getname()

   477

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   478

        def_task = [

   479

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

   480

        def_instance = [

   481

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