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 six.moves import xrange

    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

    64

from runtime import PlcStatus

    65

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    66

    67

base_folder = paths.AbsParentDir(__file__)

    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 n, d, _h, c in catalog:

    76

        if isinstance(c, list):

    77

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    78

        else:

    79

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

    80

    return children_types

    81

    82

    83

def ExtractMenuItemsFromCatalog(catalog):

    84

    menu_items = []

    85

    for n, d, h, c in catalog:

    86

        if isinstance(c, list):

    87

            children = ExtractMenuItemsFromCatalog(c)

    88

        else:

    89

            children = []

    90

        menu_items.append((n, d, h, 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):

   101

        self.iec2c = None

   102

        self.iec2c_buildopts = None

   103

        self.ieclib_path = self.findLibPath()

   104

        self.ieclib_c_path = self.findLibCPath()

   105

   106

    def findObject(self, paths, test):

   107

        path = None

   108

        for p in paths:

   109

            if test(p):

   110

                path = p

   111

                break

   112

        return path

   113

   114

    def findCmd(self):

   115

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

   116

        paths = [

   117

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

   118

        ]

   119

        path = self.findObject(

   120

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

   121

   122

        # otherwise use iec2c from PATH

   123

        if path is not None:

   124

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

   125

   126

        return cmd

   127

   128

    def findLibPath(self):

   129

        paths = [

   130

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

   131

            "/usr/lib/matiec"

   132

        ]

   133

        path = self.findObject(

   134

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

   135

        return path

   136

   137

    def findLibCPath(self):

   138

        path = None

   139

        if self.ieclib_path is not None:

   140

            paths = [

   141

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

   142

                self.ieclib_path]

   143

            path = self.findObject(

   144

                paths,

   145

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

   146

        return path

   147

   148

    def findSupportedOptions(self):

   149

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

   150

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

   151

   152

        buildopt = ""

   153

        try:

   154

            # Invoke compiler.

   155

            # Output files are listed to stdout, errors to stderr

   156

            _status, result, _err_result = ProcessLogger(None, buildcmd,

   157

                                                         no_stdout=True,

   158

                                                         no_stderr=True).spin()

   159

        except Exception:

   160

            return buildopt

   161

   162

        for opt in options:

   163

            if opt in result:

   164

                buildopt = buildopt + " " + opt

   165

        return buildopt

   166

   167

    def getCmd(self):

   168

        if self.iec2c is None:

   169

            self.iec2c = self.findCmd()

   170

        return self.iec2c

   171

   172

    def getOptions(self):

   173

        if self.iec2c_buildopts is None:

   174

            self.iec2c_buildopts = self.findSupportedOptions()

   175

        return self.iec2c_buildopts

   176

   177

    def getLibPath(self):

   178

        return self.ieclib_path

   179

   180

    def getLibCPath(self):

   181

        if self.ieclib_c_path is None:

   182

            self.ieclib_c_path = self.findLibCPath()

   183

        return self.ieclib_c_path

   184

   185

   186

def GetProjectControllerXSD():

   187

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

   188

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

   189

      <xsd:element name="BeremizRoot">

   190

        <xsd:complexType>

   191

          <xsd:sequence>

   192

            <xsd:element name="TargetType">

   193

              <xsd:complexType>

   194

                <xsd:choice minOccurs="0">

   195

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

   196

                </xsd:choice>

   197

              </xsd:complexType>

   198

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

   199

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

   200

              <xsd:complexType>

   201

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

   202

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

   203

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

   204

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

   205

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

   206

              </xsd:complexType>

   207

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

   208

          </xsd:sequence>

   209

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

   210

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

   211

        </xsd:complexType>

   212

      </xsd:element>

   213

    </xsd:schema>

   214

    """

   215

    return XSD

   216

   217

   218

class ProjectController(ConfigTreeNode, PLCControler):

   219

   220

    """

   221

    This class define Root object of the confnode tree.

   222

    It is responsible of :

   223

    - Managing project directory

   224

    - Building project

   225

    - Handling PLCOpenEditor controler and view

   226

    - Loading user confnodes and instanciante them as children

   227

    - ...

   228

   229

    """

   230

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

   231

    # packages.

   232

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   233

    XSD = GetProjectControllerXSD()

   234

    EditorType = ProjectNodeEditor

   235

    iec2c_cfg = None

   236

   237

    def __init__(self, frame, logger):

   238

        PLCControler.__init__(self)

   239

        ConfigTreeNode.__init__(self)

   240

   241

        if ProjectController.iec2c_cfg is None:

   242

            ProjectController.iec2c_cfg = Iec2CSettings()

   243

   244

        self.MandatoryParams = None

   245

        self._builder = None

   246

        self._connector = None

   247

        self.DispatchDebugValuesTimer = None

   248

        self.DebugValuesBuffers = []

   249

        self.DebugTicks = []

   250

        self.SetAppFrame(frame, logger)

   251

   252

        # Setup debug information

   253

        self.IECdebug_datas = {}

   254

   255

        self.DebugTimer = None

   256

        self.ResetIECProgramsAndVariables()

   257

   258

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

   259

        self.ChangesToSave = False

   260

        # root have no parent

   261

        self.CTNParent = None

   262

        # Keep track of the confnode type name

   263

        self.CTNType = "Beremiz"

   264

        self.Children = {}

   265

        self._View = None

   266

        # After __init__ root confnode is not valid

   267

        self.ProjectPath = None

   268

        self._setBuildPath(None)

   269

        self.debug_break = False

   270

        self.previous_plcstate = None

   271

        # copy StatusMethods so that it can be later customized

   272

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

   273

   274

    def __del__(self):

   275

        if self.DebugTimer:

   276

            self.DebugTimer.cancel()

   277

        self.KillDebugThread()

   278

   279

    def LoadLibraries(self):

   280

        self.Libraries = []

   281

        TypeStack = []

   282

        for libname, clsname, lib_enabled in features.libraries:

   283

            if self.BeremizRoot.Libraries is not None:

   284

                enable_attr = getattr(self.BeremizRoot.Libraries,

   285

                                      "Enable_" + libname + "_Library")

   286

                if enable_attr is not None:

   287

                    lib_enabled = enable_attr

   288

   289

            if lib_enabled:

   290

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

   291

                TypeStack.append(Lib.GetTypes())

   292

                self.Libraries.append(Lib)

   293

   294

    def SetAppFrame(self, frame, logger):

   295

        self.AppFrame = frame

   296

        self.logger = logger

   297

        self.StatusTimer = None

   298

        if self.DispatchDebugValuesTimer is not None:

   299

            self.DispatchDebugValuesTimer.Stop()

   300

        self.DispatchDebugValuesTimer = None

   301

   302

        if frame is not None:

   303

   304

            # Timer to pull PLC status

   305

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

   306

            self.AppFrame.Bind(wx.EVT_TIMER,

   307

                               self.PullPLCStatusProc,

   308

                               self.StatusTimer)

   309

   310

            if self._connector is not None:

   311

                frame.LogViewer.SetLogSource(self._connector)

   312

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

   313

   314

            # Timer to dispatch debug values to consumers

   315

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

   316

            self.AppFrame.Bind(wx.EVT_TIMER,

   317

                               self.DispatchDebugValuesProc,

   318

                               self.DispatchDebugValuesTimer)

   319

   320

            self.RefreshConfNodesBlockLists()

   321

   322

    def ResetAppFrame(self, logger):

   323

        if self.AppFrame is not None:

   324

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

   325

            self.StatusTimer = None

   326

            self.AppFrame = None

   327

            self.KillDebugThread()

   328

        self.logger = logger

   329

   330

    def CTNName(self):

   331

        return "Project"

   332

   333

    def CTNTestModified(self):

   334

        return self.ChangesToSave or not self.ProjectIsSaved()

   335

   336

    def CTNFullName(self):

   337

        return ""

   338

   339

    def GetCTRoot(self):

   340

        return self

   341

   342

    def GetIECLibPath(self):

   343

        return self.iec2c_cfg.getLibCPath()

   344

   345

    def GetIEC2cPath(self):

   346

        return self.iec2c_cfg.getCmd()

   347

   348

    def GetCurrentLocation(self):

   349

        return ()

   350

   351

    def GetCurrentName(self):

   352

        return ""

   353

   354

    def _GetCurrentName(self):

   355

        return ""

   356

   357

    def GetProjectPath(self):

   358

        return self.ProjectPath

   359

   360

    def GetProjectName(self):

   361

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

   362

   363

    def GetIconName(self):

   364

        return "PROJECT"

   365

   366

    def GetDefaultTargetName(self):

   367

        if wx.Platform == '__WXMSW__':

   368

            return "Win32"

   369

        else:

   370

            return "Linux"

   371

   372

    def GetTarget(self):

   373

        target = self.BeremizRoot.getTargetType()

   374

        if target.getcontent() is None:

   375

            temp_root = self.Parser.CreateRoot()

   376

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

   377

            temp_root.setTargetType(target)

   378

            target_name = self.GetDefaultTargetName()

   379

            target.setcontent(

   380

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

   381

        return target

   382

   383

    def GetParamsAttributes(self, path=None):

   384

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   385

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

   386

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

   387

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

   388

                    child.update(

   389

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

   390

        return params

   391

   392

    def SetParamsAttribute(self, path, value):

   393

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

   394

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

   395

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

   396

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

   397

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   398

        return res

   399

   400

    # helper func to check project path write permission

   401

    def CheckProjectPathPerm(self, dosave=True):

   402

        if CheckPathPerm(self.ProjectPath):

   403

            return True

   404

        if self.AppFrame is not None:

   405

            dialog = wx.MessageDialog(

   406

                self.AppFrame,

   407

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

   408

                _('Error'),

   409

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

   410

            answer = dialog.ShowModal()

   411

            dialog.Destroy()

   412

            if answer == wx.ID_YES:

   413

                if self.SaveProjectAs():

   414

                    self.AppFrame.RefreshTitle()

   415

                    self.AppFrame.RefreshFileMenu()

   416

                    self.AppFrame.RefreshPageTitles()

   417

                    return True

   418

        return False

   419

   420

    def _getProjectFilesPath(self, project_path=None):

   421

        if project_path is not None:

   422

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

   423

        projectfiles_path = os.path.join(

   424

            self.GetProjectPath(), "project_files")

   425

        if not os.path.exists(projectfiles_path):

   426

            os.mkdir(projectfiles_path)

   427

        return projectfiles_path

   428

   429

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

   430

        self.ProjectAddConfiguration(config_name)

   431

        self.ProjectAddConfigurationResource(config_name, res_name)

   432

   433

    def SetProjectDefaultConfiguration(self):

   434

        # Sets default task and instance for new project

   435

        config = self.Project.getconfiguration(

   436

            self.GetProjectMainConfigurationName())

   437

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

   438

        config = config.getname()

   439

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   440

        def_task = [

   441

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

   442

        def_instance = [

   443

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

   444

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   445

   446

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

   447

        """

   448

        Create a new project in an empty folder

   449

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

   450

        @param PLCParams: properties of the PLCOpen program created

   451

        """

   452

        # Verify that chosen folder is empty

   453

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

   454

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

   455

   456

        # Create PLCOpen program

   457

        self.CreateNewProject(

   458

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

   459

             "productName": _("Unnamed"),

   460

             "productVersion": "1",

   461

             "companyName": _("Unknown"),

   462

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

   463

        self.AddProjectDefaultConfiguration()

   464

   465

        # Change XSD into class members

   466

        self._AddParamsMembers()

   467

        self.Children = {}

   468

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

   469

        self.ProjectPath = ProjectPath

   470

        self._setBuildPath(BuildPath)

   471

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

   472

        self.RefreshConfNodesBlockLists()

   473

        # this will create files base XML files

   474

        self.SaveProject()

   475

        return None

   476

   477

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

   478

        """

   479

        Load a project contained in a folder

   480

        @param ProjectPath: path of the project folder

   481

        """