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 pathutils

    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

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

    76

        if isinstance(moduleclassname, list):

    77

            children_types.extend(ExtractChildrenTypesFromCatalog(moduleclassname))

    78

        else:

    79

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

    80

    return children_types

    81

    82

    83

def ExtractMenuItemsFromCatalog(catalog):

    84

    menu_items = []

    85

    for name, displayname, helpstr, moduleclassname in catalog:

    86

        if isinstance(moduleclassname, list):

    87

            children = ExtractMenuItemsFromCatalog(moduleclassname)

    88

        else:

    89

            children = []

    90

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

            pathutils.ThirdPartyPath("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

            pathutils.ThirdPartyPath("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

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

   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

        # compute CFLAGS for PLC code

   283

        self.plcCFLAGS = '"-I%s" -Wno-unused-function' % os.path.abspath(self.iec2c_cfg.getLibCPath())

   284

   285

    def LoadLibraries(self):

   286

        self.Libraries = OrderedDict()

   287

        TypeStack = []

   288

        for libname, clsname, default in features.libraries:

   289

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

   290

            if self.BeremizRoot.Libraries is not None:

   291

                enable_attr = getattr(self.BeremizRoot.Libraries,

   292

                                      "Enable_" + libname + "_Library")

   293

                if enable_attr is not None:

   294

                    lib_enabled = enable_attr

   295

   296

            if lib_enabled:

   297

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

   298

                TypeStack.append(Lib.GetTypes())

   299

                self.Libraries[libname] = Lib

   300

   301

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

   302

        """ 

   303

        Project controller applies libraries requirements when adding new CTN

   304

        """

   305

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

   306

   307

        # find library associated with new CTN, if any

   308

        associated_lib = {default:libname 

   309

                          for libname, _clsname, default 

   310

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

   311

   312

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

   313

        if associated_lib is not None:

   314

            # FIXME: This should be done with GetParamsAttribute

   315

            # but it fails with missing optional attributes

   316

            attrname = "Enable_" + associated_lib + "_Library"

   317

            libobj = self.BeremizRoot.Libraries

   318

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

   319

            if not lib_enabled:

   320

                # use SetParamsAttribute to trigger reload of libs

   321

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

   322

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

   323

                    a1=associated_lib, a2=CTNType)

   324

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

   325

   326

        return res

   327

   328

    def SetAppFrame(self, frame, logger):

   329

        self.AppFrame = frame

   330

        self.logger = logger

   331

        self.StatusTimer = None

   332

        if self.DispatchDebugValuesTimer is not None:

   333

            self.DispatchDebugValuesTimer.Stop()

   334

        self.DispatchDebugValuesTimer = None

   335

   336

        if frame is not None:

   337

   338

            # Timer to pull PLC status

   339

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

   340

            self.AppFrame.Bind(wx.EVT_TIMER,

   341

                               self.PullPLCStatusProc,

   342

                               self.StatusTimer)

   343

   344

            if self._connector is not None:

   345

                frame.LogViewer.SetLogSource(self._connector)

   346

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

   347

   348

            # Timer to dispatch debug values to consumers

   349

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

   350

            self.AppFrame.Bind(wx.EVT_TIMER,

   351

                               self.DispatchDebugValuesProc,

   352

                               self.DispatchDebugValuesTimer)

   353

   354

            self.RefreshConfNodesBlockLists()

   355

   356

    def ResetAppFrame(self, logger):

   357

        if self.AppFrame is not None:

   358

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

   359

            self.StatusTimer = None

   360

            self.AppFrame = None

   361

            self.KillDebugThread()

   362

        self.logger = logger

   363

   364

    def CTNName(self):

   365

        return "Project"

   366

   367

    def CTNTestModified(self):

   368

        return self.ChangesToSave or not self.ProjectIsSaved()

   369

   370

    def CTNFullName(self):

   371

        return ""

   372

   373

    def GetCTRoot(self):

   374

        return self

   375

   376

    def GetIECLibPath(self):

   377

        return self.iec2c_cfg.getLibCPath()

   378

   379

    def GetIEC2cPath(self):

   380

        return self.iec2c_cfg.getCmd()

   381

   382

    def GetCurrentLocation(self):

   383

        return ()

   384

   385

    def GetCurrentName(self):

   386

        return ""

   387

   388

    def _GetCurrentName(self):

   389

        return ""

   390

   391

    def GetProjectPath(self):

   392

        return self.ProjectPath

   393

   394

    def GetProjectName(self):

   395

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

   396

   397

    def GetIconName(self):

   398

        return "PROJECT"

   399

   400

    def GetDefaultTargetName(self):

   401

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

   402

            return "Linux"

   403

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

   404

            return "OSX"

   405

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

   406

            return "Win32"

   407

   408

        # Fall back to Linux as default target

   409

        return "Linux"

   410

   411

   412

    def GetTarget(self):

   413

        target = self.BeremizRoot.getTargetType()

   414

        if target.getcontent() is None:

   415

            temp_root = self.Parser.CreateRoot()

   416

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

   417

            temp_root.setTargetType(target)

   418

            target_name = self.GetDefaultTargetName()

   419

            target.setcontent(

   420

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

   421

        return target

   422

   423

    def GetParamsAttributes(self, path=None):

   424

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   425

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

   426

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

   427

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

   428

                    child.update(

   429

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

   430

        return params

   431

   432

    def SetParamsAttribute(self, path, value):

   433

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

   434

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

   435

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

   436

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

   437

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   438

        return res

   439

   440

    # helper func to check project path write permission

   441

    def CheckProjectPathPerm(self):

   442

        if CheckPathPerm(self.ProjectPath):

   443

            return True

   444

        if self.AppFrame is not None:

   445

            dialog = wx.MessageDialog(

   446

                self.AppFrame,

   447

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

   448

                _('Error'),

   449

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

   450

            answer = dialog.ShowModal()

   451

            dialog.Destroy()

   452

            if answer == wx.ID_YES:

   453

                if self.SaveProjectAs():

   454

                    self.AppFrame.RefreshTitle()

   455

                    self.AppFrame.RefreshFileMenu()

   456

                    self.AppFrame.RefreshPageTitles()

   457

                    return True

   458

        return False

   459

   460

    def _getProjectFilesPath(self, project_path=None):

   461

        if project_path is not None:

   462

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

   463

        projectfiles_path = os.path.join(

   464

            self.GetProjectPath(), "project_files")

   465

        if not os.path.exists(projectfiles_path):

   466

            os.mkdir(projectfiles_path)

   467

        return projectfiles_path

   468

   469

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

   470

        self.ProjectAddConfiguration(config_name)

   471

        self.ProjectAddConfigurationResource(config_name, res_name)

   472

   473

    def SetProjectDefaultConfiguration(self):

   474

        # Sets default task and instance for new project

   475

        config = self.Project.getconfiguration(

   476

            self.GetProjectMainConfigurationName())

   477

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

   478

        config = config.getname()

   479

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   480

        def_task = [

   481

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