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 types import ListType

    40

from threading import Timer

    41

from datetime import datetime

    42

from weakref import WeakKeyDictionary

    43

from itertools import izip

    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 DiscoveryDialog

    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 ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    65

    66

base_folder = paths.AbsParentDir(__file__)

    67

    68

MATIEC_ERROR_MODEL = re.compile(

    69

    ".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")

    70

    71

    72

def ExtractChildrenTypesFromCatalog(catalog):

    73

    children_types = []

    74

    for n, d, _h, c in catalog:

    75

        if isinstance(c, ListType):

    76

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    77

        else:

    78

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

    79

    return children_types

    80

    81

    82

def ExtractMenuItemsFromCatalog(catalog):

    83

    menu_items = []

    84

    for n, d, h, c in catalog:

    85

        if isinstance(c, ListType):

    86

            children = ExtractMenuItemsFromCatalog(c)

    87

        else:

    88

            children = []

    89

        menu_items.append((n, d, h, children))

    90

    return menu_items

    91

    92

    93

def GetAddMenuItems():

    94

    return ExtractMenuItemsFromCatalog(features.catalog)

    95

    96

    97

class Iec2CSettings(object):

    98

    99

    def __init__(self):

   100

        self.iec2c = None

   101

        self.iec2c_buildopts = None

   102

        self.ieclib_path = self.findLibPath()

   103

        self.ieclib_c_path = self.findLibCPath()

   104

   105

    def findObject(self, paths, test):

   106

        path = None

   107

        for p in paths:

   108

            if test(p):

   109

                path = p

   110

                break

   111

        return path

   112

   113

    def findCmd(self):

   114

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

   115

        paths = [

   116

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

   117

        ]

   118

        path = self.findObject(

   119

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

   120

   121

        # otherwise use iec2c from PATH

   122

        if path is not None:

   123

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

   124

   125

        return cmd

   126

   127

    def findLibPath(self):

   128

        paths = [

   129

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

   130

            "/usr/lib/matiec"

   131

        ]

   132

        path = self.findObject(

   133

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

   134

        return path

   135

   136

    def findLibCPath(self):

   137

        path = None

   138

        if self.ieclib_path is not None:

   139

            paths = [

   140

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

   141

                self.ieclib_path]

   142

            path = self.findObject(

   143

                paths,

   144

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

   145

        return path

   146

   147

    def findSupportedOptions(self):

   148

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

   149

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

   150

   151

        buildopt = ""

   152

        try:

   153

            # Invoke compiler.

   154

            # Output files are listed to stdout, errors to stderr

   155

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

   156

                                                         no_stdout=True,

   157

                                                         no_stderr=True).spin()

   158

        except Exception:

   159

            return buildopt

   160

   161

        for opt in options:

   162

            if opt in result:

   163

                buildopt = buildopt + " " + opt

   164

        return buildopt

   165

   166

    def getCmd(self):

   167

        if self.iec2c is None:

   168

            self.iec2c = self.findCmd()

   169

        return self.iec2c

   170

   171

    def getOptions(self):

   172

        if self.iec2c_buildopts is None:

   173

            self.iec2c_buildopts = self.findSupportedOptions()

   174

        return self.iec2c_buildopts

   175

   176

    def getLibPath(self):

   177

        return self.ieclib_path

   178

   179

    def getLibCPath(self):

   180

        if self.ieclib_c_path is None:

   181

            self.ieclib_c_path = self.findLibCPath()

   182

        return self.ieclib_c_path

   183

   184

   185

def GetProjectControllerXSD():

   186

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

   187

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

   188

      <xsd:element name="BeremizRoot">

   189

        <xsd:complexType>

   190

          <xsd:sequence>

   191

            <xsd:element name="TargetType">

   192

              <xsd:complexType>

   193

                <xsd:choice minOccurs="0">

   194

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

   195

                </xsd:choice>

   196

              </xsd:complexType>

   197

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

   198

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

   199

              <xsd:complexType>

   200

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

   201

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

   202

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

   203

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

   204

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

   205

              </xsd:complexType>

   206

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

   207

          </xsd:sequence>

   208

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

   209

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

   210

        </xsd:complexType>

   211

      </xsd:element>

   212

    </xsd:schema>

   213

    """

   214

    return XSD

   215

   216

   217

class ProjectController(ConfigTreeNode, PLCControler):

   218

   219

    """

   220

    This class define Root object of the confnode tree.

   221

    It is responsible of :

   222

    - Managing project directory

   223

    - Building project

   224

    - Handling PLCOpenEditor controler and view

   225

    - Loading user confnodes and instanciante them as children

   226

    - ...

   227

   228

    """

   229

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

   230

    # packages.

   231

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   232

    XSD = GetProjectControllerXSD()

   233

    EditorType = ProjectNodeEditor

   234

    iec2c_cfg = None

   235

   236

    def __init__(self, frame, logger):

   237

        PLCControler.__init__(self)

   238

        ConfigTreeNode.__init__(self)

   239

   240

        if ProjectController.iec2c_cfg is None:

   241

            ProjectController.iec2c_cfg = Iec2CSettings()

   242

   243

        self.MandatoryParams = None

   244

        self._builder = None

   245

        self._connector = None

   246

        self.DispatchDebugValuesTimer = None

   247

        self.DebugValuesBuffers = []

   248

        self.DebugTicks = []

   249

        self.SetAppFrame(frame, logger)

   250

   251

        # Setup debug information

   252

        self.IECdebug_datas = {}

   253

   254

        self.DebugTimer = None

   255

        self.ResetIECProgramsAndVariables()

   256

   257

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

   258

        self.ChangesToSave = False

   259

        # root have no parent

   260

        self.CTNParent = None

   261

        # Keep track of the confnode type name

   262

        self.CTNType = "Beremiz"

   263

        self.Children = {}

   264

        self._View = None

   265

        # After __init__ root confnode is not valid

   266

        self.ProjectPath = None

   267

        self._setBuildPath(None)

   268

        self.debug_break = False

   269

        self.previous_plcstate = None

   270

        # copy StatusMethods so that it can be later customized

   271

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

   272

   273

    def __del__(self):

   274

        if self.DebugTimer:

   275

            self.DebugTimer.cancel()

   276

        self.KillDebugThread()

   277

   278

    def LoadLibraries(self):

   279

        self.Libraries = []

   280

        TypeStack = []

   281

        for libname, clsname, _default in features.libraries:

   282

            if self.BeremizRoot.Libraries is not None and \

   283

               getattr(self.BeremizRoot.Libraries,

   284

                       "Enable_" + libname + "_Library"):

   285

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

   286

                TypeStack.append(Lib.GetTypes())

   287

                self.Libraries.append(Lib)

   288

   289

    def SetAppFrame(self, frame, logger):

   290

        self.AppFrame = frame

   291

        self.logger = logger

   292

        self.StatusTimer = None

   293

        if self.DispatchDebugValuesTimer is not None:

   294

            self.DispatchDebugValuesTimer.Stop()

   295

        self.DispatchDebugValuesTimer = None

   296

   297

        if frame is not None:

   298

   299

            # Timer to pull PLC status

   300

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

   301

            self.AppFrame.Bind(wx.EVT_TIMER,

   302

                               self.PullPLCStatusProc,

   303

                               self.StatusTimer)

   304

   305

            if self._connector is not None:

   306

                frame.LogViewer.SetLogSource(self._connector)

   307

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

   308

   309

            # Timer to dispatch debug values to consumers

   310

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

   311

            self.AppFrame.Bind(wx.EVT_TIMER,

   312

                               self.DispatchDebugValuesProc,

   313

                               self.DispatchDebugValuesTimer)

   314

   315

            self.RefreshConfNodesBlockLists()

   316

   317

    def ResetAppFrame(self, logger):

   318

        if self.AppFrame is not None:

   319

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

   320

            self.StatusTimer = None

   321

            self.AppFrame = None

   322

            self.KillDebugThread()

   323

        self.logger = logger

   324

   325

    def CTNName(self):

   326

        return "Project"

   327

   328

    def CTNTestModified(self):

   329

        return self.ChangesToSave or not self.ProjectIsSaved()

   330

   331

    def CTNFullName(self):

   332

        return ""

   333

   334

    def GetCTRoot(self):

   335

        return self

   336

   337

    def GetIECLibPath(self):

   338

        return self.iec2c_cfg.getLibCPath()

   339

   340

    def GetIEC2cPath(self):

   341

        return self.iec2c_cfg.getCmd()

   342

   343

    def GetCurrentLocation(self):

   344

        return ()

   345

   346

    def GetCurrentName(self):

   347

        return ""

   348

   349

    def _GetCurrentName(self):

   350

        return ""

   351

   352

    def GetProjectPath(self):

   353

        return self.ProjectPath

   354

   355

    def GetProjectName(self):

   356

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

   357

   358

    def GetIconName(self):

   359

        return "PROJECT"

   360

   361

    def GetDefaultTargetName(self):

   362

        if wx.Platform == '__WXMSW__':

   363

            return "Win32"

   364

        else:

   365

            return "Linux"

   366

   367

    def GetTarget(self):

   368

        target = self.BeremizRoot.getTargetType()

   369

        if target.getcontent() is None:

   370

            temp_root = self.Parser.CreateRoot()

   371

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

   372

            temp_root.setTargetType(target)

   373

            target_name = self.GetDefaultTargetName()

   374

            target.setcontent(

   375

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

   376

        return target

   377

   378

    def GetParamsAttributes(self, path=None):

   379

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   380

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

   381

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

   382

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

   383

                    child.update(

   384

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

   385

        return params

   386

   387

    def SetParamsAttribute(self, path, value):

   388

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

   389

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

   390

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

   391

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

   392

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   393

        return res

   394

   395

    # helper func to check project path write permission

   396

    def CheckProjectPathPerm(self, dosave=True):

   397

        if CheckPathPerm(self.ProjectPath):

   398

            return True

   399

        if self.AppFrame is not None:

   400

            dialog = wx.MessageDialog(

   401

                self.AppFrame,

   402

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

   403

                _('Error'),

   404

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

   405

            answer = dialog.ShowModal()

   406

            dialog.Destroy()

   407

            if answer == wx.ID_YES:

   408

                if self.SaveProjectAs():

   409

                    self.AppFrame.RefreshTitle()

   410

                    self.AppFrame.RefreshFileMenu()

   411

                    self.AppFrame.RefreshPageTitles()

   412

                    return True

   413

        return False

   414

   415

    def _getProjectFilesPath(self, project_path=None):

   416

        if project_path is not None:

   417

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

   418

        projectfiles_path = os.path.join(

   419

            self.GetProjectPath(), "project_files")

   420

        if not os.path.exists(projectfiles_path):

   421

            os.mkdir(projectfiles_path)

   422

        return projectfiles_path

   423

   424

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

   425

        self.ProjectAddConfiguration(config_name)

   426

        self.ProjectAddConfigurationResource(config_name, res_name)

   427

   428

    def SetProjectDefaultConfiguration(self):

   429

        # Sets default task and instance for new project

   430

        config = self.Project.getconfiguration(

   431

            self.GetProjectMainConfigurationName())

   432

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

   433

        config = config.getname()

   434

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   435

        def_task = [

   436

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

   437

        def_instance = [

   438

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

   439

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   440

   441

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

   442

        """

   443

        Create a new project in an empty folder

   444

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

   445

        @param PLCParams: properties of the PLCOpen program created

   446

        """

   447

        # Verify that chosen folder is empty

   448

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

   449

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

   450

   451

        # Create PLCOpen program

   452

        self.CreateNewProject(

   453

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

   454

             "productName": _("Unnamed"),

   455

             "productVersion": "1",

   456

             "companyName": _("Unknown"),

   457

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

   458

        self.AddProjectDefaultConfiguration()

   459

   460

        # Change XSD into class members

   461

        self._AddParamsMembers()

   462

        self.Children = {}

   463

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

   464

        self.ProjectPath = ProjectPath

   465

        self._setBuildPath(BuildPath)

   466

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

   467

        self.RefreshConfNodesBlockLists()

   468

        # this will create files base XML files

   469

        self.SaveProject()

   470

        return None

   471

   472

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

   473

        """

   474

        Load a project contained in a folder

   475

        @param ProjectPath: path of the project folder

   476

        """

   477

        if os.path.basename(ProjectPath) == "":

   478

            ProjectPath = os.path.dirname(ProjectPath)

   479

        # Verify that project contains a PLCOpen program

   480

        plc_file = os.path.join(ProjectPath, "plc.xml")

   481

        if not os.path.isfile(plc_file):