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

    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 = [

   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 = [

   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

    def LoadLibraries(self):

   283

        self.Libraries = OrderedDict()

   284

        TypeStack = []

   285

        for libname, clsname, default in features.libraries:

   286

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

   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[libname] = Lib

   297

   298

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

   299

        """ 

   300

        Project controller applies libraries requirements when adding new CTN

   301

        """

   302

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

   303

   304

        # find library associated with new CTN, if any

   305

        associated_lib = {default:libname 

   306

                          for libname, _clsname, default 

   307

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

   308

   309

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

   310

        if associated_lib is not None:

   311

            # FIXME: This should be done with GetParamsAttribute

   312

            # but it fails with missing optional attributes

   313

            attrname = "Enable_" + associated_lib + "_Library"

   314

            libobj = self.BeremizRoot.Libraries

   315

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

   316

            if not lib_enabled:

   317

                # use SetParamsAttribute to trigger reload of libs

   318

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

   319

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

   320

                    a1=associated_lib, a2=CTNType)

   321

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

   322

   323

        return res

   324

   325

    def SetAppFrame(self, frame, logger):

   326

        self.AppFrame = frame

   327

        self.logger = logger

   328

        self.StatusTimer = None

   329

        if self.DispatchDebugValuesTimer is not None:

   330

            self.DispatchDebugValuesTimer.Stop()

   331

        self.DispatchDebugValuesTimer = None

   332

   333

        if frame is not None:

   334

   335

            # Timer to pull PLC status

   336

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

   337

            self.AppFrame.Bind(wx.EVT_TIMER,

   338

                               self.PullPLCStatusProc,

   339

                               self.StatusTimer)

   340

   341

            if self._connector is not None:

   342

                frame.LogViewer.SetLogSource(self._connector)

   343

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

   344

   345

            # Timer to dispatch debug values to consumers

   346

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

   347

            self.AppFrame.Bind(wx.EVT_TIMER,

   348

                               self.DispatchDebugValuesProc,

   349

                               self.DispatchDebugValuesTimer)

   350

   351

            self.RefreshConfNodesBlockLists()

   352

   353

    def ResetAppFrame(self, logger):

   354

        if self.AppFrame is not None:

   355

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

   356

            self.StatusTimer = None

   357

            self.AppFrame = None

   358

            self.KillDebugThread()

   359

        self.logger = logger

   360

   361

    def CTNName(self):

   362

        return "Project"

   363

   364

    def CTNTestModified(self):

   365

        return self.ChangesToSave or not self.ProjectIsSaved()

   366

   367

    def CTNFullName(self):

   368

        return ""

   369

   370

    def GetCTRoot(self):

   371

        return self

   372

   373

    def GetIECLibPath(self):

   374

        return self.iec2c_cfg.getLibCPath()

   375

   376

    def GetIEC2cPath(self):

   377

        return self.iec2c_cfg.getCmd()

   378

   379

    def GetCurrentLocation(self):

   380

        return ()

   381

   382

    def GetCurrentName(self):

   383

        return ""

   384

   385

    def _GetCurrentName(self):

   386

        return ""

   387

   388

    def GetProjectPath(self):

   389

        return self.ProjectPath

   390

   391

    def GetProjectName(self):

   392

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

   393

   394

    def GetIconName(self):

   395

        return "PROJECT"

   396

   397

    def GetDefaultTargetName(self):

   398

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

   399

            return "Linux"

   400

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

   401

            return "OSX"

   402

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

   403

            return "Win32"

   404

   405

        # Fall back to Linux as default target

   406

        return "Linux"

   407

   408

   409

    def GetTarget(self):

   410

        target = self.BeremizRoot.getTargetType()

   411

        if target.getcontent() is None:

   412

            temp_root = self.Parser.CreateRoot()

   413

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

   414

            temp_root.setTargetType(target)

   415

            target_name = self.GetDefaultTargetName()

   416

            target.setcontent(

   417

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

   418

        return target

   419

   420

    def GetParamsAttributes(self, path=None):

   421

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   422

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

   423

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

   424

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

   425

                    child.update(

   426

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

   427

        return params

   428

   429

    def SetParamsAttribute(self, path, value):

   430

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

   431

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

   432

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

   433

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

   434

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   435

        return res

   436

   437

    # helper func to check project path write permission

   438

    def CheckProjectPathPerm(self):

   439

        if CheckPathPerm(self.ProjectPath):

   440

            return True

   441

        if self.AppFrame is not None:

   442

            dialog = wx.MessageDialog(

   443

                self.AppFrame,

   444

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

   445

                _('Error'),

   446

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

   447

            answer = dialog.ShowModal()

   448

            dialog.Destroy()

   449

            if answer == wx.ID_YES:

   450

                if self.SaveProjectAs():

   451

                    self.AppFrame.RefreshTitle()

   452

                    self.AppFrame.RefreshFileMenu()

   453

                    self.AppFrame.RefreshPageTitles()

   454

                    return True

   455

        return False

   456

   457

    def _getProjectFilesPath(self, project_path=None):

   458

        if project_path is not None:

   459

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

   460

        projectfiles_path = os.path.join(

   461

            self.GetProjectPath(), "project_files")

   462

        if not os.path.exists(projectfiles_path):

   463

            os.mkdir(projectfiles_path)

   464

        return projectfiles_path

   465

   466

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

   467

        self.ProjectAddConfiguration(config_name)

   468

        self.ProjectAddConfigurationResource(config_name, res_name)

   469

   470

    def SetProjectDefaultConfiguration(self):

   471

        # Sets default task and instance for new project

   472

        config = self.Project.getconfiguration(

   473

            self.GetProjectMainConfigurationName())

   474

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

   475

        config = config.getname()

   476

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   477

        def_task = [

   478

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

   479

        def_instance = [

   480

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

   481

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)