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, Lock, Thread

    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(".*\.st:(\d+)-(\d+)\.\.(\d+)-(\d+): (?:error)|(?:warning) : (.*)$")

    69

    70

    71

def ExtractChildrenTypesFromCatalog(catalog):

    72

    children_types = []

    73

    for n, d, _h, c in catalog:

    74

        if isinstance(c, ListType):

    75

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    76

        else:

    77

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

    78

    return children_types

    79

    80

    81

def ExtractMenuItemsFromCatalog(catalog):

    82

    menu_items = []

    83

    for n, d, h, c in catalog:

    84

        if isinstance(c, ListType):

    85

            children = ExtractMenuItemsFromCatalog(c)

    86

        else:

    87

            children = []

    88

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

    89

    return menu_items

    90

    91

    92

def GetAddMenuItems():

    93

    return ExtractMenuItemsFromCatalog(features.catalog)

    94

    95

    96

class Iec2CSettings(object):

    97

    def __init__(self):

    98

        self.iec2c = None

    99

        self.iec2c_buildopts = None

   100

        self.ieclib_path = self.findLibPath()

   101

        self.ieclib_c_path = self.findLibCPath()

   102

   103

    def findObject(self, paths, test):

   104

        path = None

   105

        for p in paths:

   106

            if test(p):

   107

                path = p

   108

                break

   109

        return path

   110

   111

    def findCmd(self):

   112

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

   113

        paths = [

   114

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

   115

        ]

   116

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

   117

   118

        # otherwise use iec2c from PATH

   119

        if path is not None:

   120

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

   121

   122

        return cmd

   123

   124

    def findLibPath(self):

   125

        paths = [

   126

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

   127

            "/usr/lib/matiec"

   128

        ]

   129

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

   130

        return path

   131

   132

    def findLibCPath(self):

   133

        path = None

   134

        if self.ieclib_path is not None:

   135

            paths = [

   136

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

   137

                self.ieclib_path]

   138

            path = self.findObject(

   139

                paths,

   140

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

   141

        return path

   142

   143

    def findSupportedOptions(self):

   144

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

   145

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

   146

   147

        buildopt = ""

   148

        try:

   149

            # Invoke compiler. Output files are listed to stdout, errors to stderr

   150

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

   151

                                                         no_stdout=True,

   152

                                                         no_stderr=True).spin()

   153

        except Exception:

   154

            return buildopt

   155

   156

        for opt in options:

   157

            if opt in result:

   158

                buildopt = buildopt + " " + opt

   159

        return buildopt

   160

   161

    def getCmd(self):

   162

        if self.iec2c is None:

   163

            self.iec2c = self.findCmd()

   164

        return self.iec2c

   165

   166

    def getOptions(self):

   167

        if self.iec2c_buildopts is None:

   168

            self.iec2c_buildopts = self.findSupportedOptions()

   169

        return self.iec2c_buildopts

   170

   171

    def getLibPath(self):

   172

        return self.ieclib_path

   173

   174

    def getLibCPath(self):

   175

        if self.ieclib_c_path is None:

   176

            self.ieclib_c_path = self.findLibCPath()

   177

        return self.ieclib_c_path

   178

   179

   180

def GetProjectControllerXSD():

   181

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

   182

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

   183

      <xsd:element name="BeremizRoot">

   184

        <xsd:complexType>

   185

          <xsd:sequence>

   186

            <xsd:element name="TargetType">

   187

              <xsd:complexType>

   188

                <xsd:choice minOccurs="0">

   189

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

   190

                </xsd:choice>

   191

              </xsd:complexType>

   192

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

   193

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

   194

              <xsd:complexType>

   195

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

   196

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

   197

                             'type="xsd:boolean" use="optional" default="true"/>'

   198

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

   199

              </xsd:complexType>

   200

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

   201

          </xsd:sequence>

   202

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

   203

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

   204

        </xsd:complexType>

   205

      </xsd:element>

   206

    </xsd:schema>

   207

    """

   208

    return XSD

   209

   210

   211

class ProjectController(ConfigTreeNode, PLCControler):

   212

    """

   213

    This class define Root object of the confnode tree.

   214

    It is responsible of :

   215

    - Managing project directory

   216

    - Building project

   217

    - Handling PLCOpenEditor controler and view

   218

    - Loading user confnodes and instanciante them as children

   219

    - ...

   220

   221

    """

   222

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

   223

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   224

    XSD = GetProjectControllerXSD()

   225

    EditorType = ProjectNodeEditor

   226

    iec2c_cfg = None

   227

   228

    def __init__(self, frame, logger):

   229

        PLCControler.__init__(self)

   230

        ConfigTreeNode.__init__(self)

   231

   232

        if ProjectController.iec2c_cfg is None:

   233

            ProjectController.iec2c_cfg = Iec2CSettings()

   234

   235

        self.MandatoryParams = None

   236

        self._builder = None

   237

        self._connector = None

   238

        self.DispatchDebugValuesTimer = None

   239

        self.DebugValuesBuffers = []

   240

        self.DebugTicks = []

   241

        self.SetAppFrame(frame, logger)

   242

   243

        # Setup debug information

   244

        self.IECdebug_datas = {}

   245

   246

        self.DebugTimer = None

   247

        self.ResetIECProgramsAndVariables()

   248

   249

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

   250

        self.ChangesToSave = False

   251

        # root have no parent

   252

        self.CTNParent = None

   253

        # Keep track of the confnode type name

   254

        self.CTNType = "Beremiz"

   255

        self.Children = {}

   256

        self._View = None

   257

        # After __init__ root confnode is not valid

   258

        self.ProjectPath = None

   259

        self._setBuildPath(None)

   260

        self.debug_break = False

   261

        self.previous_plcstate = None

   262

        # copy ConfNodeMethods so that it can be later customized

   263

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

   264

   265

    def __del__(self):

   266

        if self.DebugTimer:

   267

            self.DebugTimer.cancel()

   268

        self.KillDebugThread()

   269

   270

    def LoadLibraries(self):

   271

        self.Libraries = []

   272

        TypeStack = []

   273

        for libname, clsname in features.libraries:

   274

            if self.BeremizRoot.Libraries is None or getattr(self.BeremizRoot.Libraries, "Enable_"+libname+"_Library"):

   275

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

   276

                TypeStack.append(Lib.GetTypes())

   277

                self.Libraries.append(Lib)

   278

   279

    def SetAppFrame(self, frame, logger):

   280

        self.AppFrame = frame

   281

        self.logger = logger

   282

        self.StatusTimer = None

   283

        if self.DispatchDebugValuesTimer is not None:

   284

            self.DispatchDebugValuesTimer.Stop()

   285

        self.DispatchDebugValuesTimer = None

   286

   287

        if frame is not None:

   288

   289

            # Timer to pull PLC status

   290

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

   291

            self.AppFrame.Bind(wx.EVT_TIMER,

   292

                               self.PullPLCStatusProc,

   293

                               self.StatusTimer)

   294

   295

            if self._connector is not None:

   296

                frame.LogViewer.SetLogSource(self._connector)

   297

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

   298

   299

            # Timer to dispatch debug values to consumers

   300

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

   301

            self.AppFrame.Bind(wx.EVT_TIMER,

   302

                               self.DispatchDebugValuesProc,

   303

                               self.DispatchDebugValuesTimer)

   304

   305

            self.RefreshConfNodesBlockLists()

   306

   307

    def ResetAppFrame(self, logger):

   308

        if self.AppFrame is not None:

   309

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

   310

            self.StatusTimer = None

   311

            self.AppFrame = None

   312

            self.KillDebugThread()

   313

        self.logger = logger

   314

   315

    def CTNName(self):

   316

        return "Project"

   317

   318

    def CTNTestModified(self):

   319

        return self.ChangesToSave or not self.ProjectIsSaved()

   320

   321

    def CTNFullName(self):

   322

        return ""

   323

   324

    def GetCTRoot(self):

   325

        return self

   326

   327

    def GetIECLibPath(self):

   328

        return self.iec2c_cfg.getLibCPath()

   329

   330

    def GetIEC2cPath(self):

   331

        return self.iec2c_cfg.getCmd()

   332

   333

    def GetCurrentLocation(self):

   334

        return ()

   335

   336

    def GetCurrentName(self):

   337

        return ""

   338

   339

    def _GetCurrentName(self):

   340

        return ""

   341

   342

    def GetProjectPath(self):

   343

        return self.ProjectPath

   344

   345

    def GetProjectName(self):

   346

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

   347

   348

    def GetIconName(self):

   349

        return "PROJECT"

   350

   351

    def GetDefaultTargetName(self):

   352

        if wx.Platform == '__WXMSW__':

   353

            return "Win32"

   354

        else:

   355

            return "Linux"

   356

   357

    def GetTarget(self):

   358

        target = self.BeremizRoot.getTargetType()

   359

        if target.getcontent() is None:

   360

            temp_root = self.Parser.CreateRoot()

   361

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

   362

            temp_root.setTargetType(target)

   363

            target_name = self.GetDefaultTargetName()

   364

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

   365

        return target

   366

   367

    def GetParamsAttributes(self, path=None):

   368

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   369

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

   370

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

   371

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

   372

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

   373

        return params

   374

   375

    def SetParamsAttribute(self, path, value):

   376

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

   377

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

   378

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

   379

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

   380

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   381

        return res

   382

   383

    # helper func to check project path write permission

   384

    def CheckProjectPathPerm(self, dosave=True):

   385

        if CheckPathPerm(self.ProjectPath):

   386

            return True

   387

        if self.AppFrame is not None:

   388

            dialog = wx.MessageDialog(

   389

                self.AppFrame,

   390

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

   391

                _('Error'),

   392

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

   393

            answer = dialog.ShowModal()

   394

            dialog.Destroy()

   395

            if answer == wx.ID_YES:

   396

                if self.SaveProjectAs():

   397

                    self.AppFrame.RefreshTitle()

   398

                    self.AppFrame.RefreshFileMenu()

   399

                    self.AppFrame.RefreshPageTitles()

   400

                    return True

   401

        return False

   402

   403

    def _getProjectFilesPath(self, project_path=None):

   404

        if project_path is not None:

   405

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

   406

        projectfiles_path = os.path.join(self.GetProjectPath(), "project_files")

   407

        if not os.path.exists(projectfiles_path):

   408

            os.mkdir(projectfiles_path)

   409

        return projectfiles_path

   410

   411

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

   412

        self.ProjectAddConfiguration(config_name)

   413

        self.ProjectAddConfigurationResource(config_name, res_name)

   414

   415

    def SetProjectDefaultConfiguration(self):

   416

        # Sets default task and instance for new project

   417

        config = self.Project.getconfiguration(self.GetProjectMainConfigurationName())

   418

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

   419

        config = config.getname()

   420

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   421

        def_task = [

   422

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

   423

        def_instance = [

   424

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

   425

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   426

   427

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

   428

        """

   429

        Create a new project in an empty folder

   430

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

   431

        @param PLCParams: properties of the PLCOpen program created

   432

        """

   433

        # Verify that chosen folder is empty

   434

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

   435

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

   436

   437

        # Create PLCOpen program

   438

        self.CreateNewProject(

   439

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

   440

             "productName": _("Unnamed"),

   441

             "productVersion": "1",

   442

             "companyName": _("Unknown"),

   443

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

   444

        self.AddProjectDefaultConfiguration()

   445

   446

        # Change XSD into class members

   447

        self._AddParamsMembers()

   448

        self.Children = {}

   449

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

   450

        self.ProjectPath = ProjectPath

   451

        self._setBuildPath(BuildPath)

   452

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

   453

        self.RefreshConfNodesBlockLists()

   454

        # this will create files base XML files

   455

        self.SaveProject()

   456

        return None

   457

   458

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

   459

        """

   460

        Load a project contained in a folder

   461

        @param ProjectPath: path of the project folder

   462

        """

   463

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

   464

            ProjectPath = os.path.dirname(ProjectPath)

   465

        # Verify that project contains a PLCOpen program

   466

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

   467

        if not os.path.isfile(plc_file):

   468

            return _("Chosen folder doesn't contain a program. It's not a valid project!"), True

   469

        # Load PLCOpen file

   470

        error = self.OpenXMLFile(plc_file)

   471

        if error is not None:

   472

            if self.Project is not None:

   473

                (fname_err, lnum, src) = (("PLC",) + error)

   474

                self.logger.write_warning(XSDSchemaErrorMessage.format(a1=fname_err, a2=lnum, a3=src))

   475

            else:

   476

                return error, False

   477

        if len(self.GetProjectConfigNames()) == 0:

   478

            self.AddProjectDefaultConfiguration()

   479

        # Change XSD into class members

   480

        self._AddParamsMembers()

   481

        self.Children = {}