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

        self.IECdebug_lock = Lock()

   246

   247

        self.DebugTimer = None

   248

        self.ResetIECProgramsAndVariables()

   249

   250

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

   251

        self.ChangesToSave = False

   252

        # root have no parent

   253

        self.CTNParent = None

   254

        # Keep track of the confnode type name

   255

        self.CTNType = "Beremiz"

   256

        self.Children = {}

   257

        self._View = None

   258

        # After __init__ root confnode is not valid

   259

        self.ProjectPath = None

   260

        self._setBuildPath(None)

   261

        self.DebugThread = None

   262

        self.debug_break = False

   263

        self.previous_plcstate = None

   264

        # copy ConfNodeMethods so that it can be later customized

   265

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

   266

   267

    def __del__(self):

   268

        if self.DebugTimer:

   269

            self.DebugTimer.cancel()

   270

        self.KillDebugThread()

   271

   272

    def LoadLibraries(self):

   273

        self.Libraries = []

   274

        TypeStack = []

   275

        for libname, clsname in features.libraries:

   276

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

   277

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

   278

                TypeStack.append(Lib.GetTypes())

   279

                self.Libraries.append(Lib)

   280

   281

    def SetAppFrame(self, frame, logger):

   282

        self.AppFrame = frame

   283

        self.logger = logger

   284

        self.StatusTimer = None

   285

        if self.DispatchDebugValuesTimer is not None:

   286

            self.DispatchDebugValuesTimer.Stop()

   287

        self.DispatchDebugValuesTimer = None

   288

   289

        if frame is not None:

   290

   291

            # Timer to pull PLC status

   292

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

   293

            self.AppFrame.Bind(wx.EVT_TIMER,

   294

                               self.PullPLCStatusProc,

   295

                               self.StatusTimer)

   296

   297

            if self._connector is not None:

   298

                frame.LogViewer.SetLogSource(self._connector)

   299

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

   300

   301

            # Timer to dispatch debug values to consumers

   302

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

   303

            self.AppFrame.Bind(wx.EVT_TIMER,

   304

                               self.DispatchDebugValuesProc,

   305

                               self.DispatchDebugValuesTimer)

   306

   307

            self.RefreshConfNodesBlockLists()

   308

   309

    def ResetAppFrame(self, logger):

   310

        if self.AppFrame is not None:

   311

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

   312

            self.StatusTimer = None

   313

            self.AppFrame = None

   314

            self.KillDebugThread()

   315

        self.logger = logger

   316

   317

    def CTNName(self):

   318

        return "Project"

   319

   320

    def CTNTestModified(self):

   321

        return self.ChangesToSave or not self.ProjectIsSaved()

   322

   323

    def CTNFullName(self):

   324

        return ""

   325

   326

    def GetCTRoot(self):

   327

        return self

   328

   329

    def GetIECLibPath(self):

   330

        return self.iec2c_cfg.getLibCPath()

   331

   332

    def GetIEC2cPath(self):

   333

        return self.iec2c_cfg.getCmd()

   334

   335

    def GetCurrentLocation(self):

   336

        return ()

   337

   338

    def GetCurrentName(self):

   339

        return ""

   340

   341

    def _GetCurrentName(self):

   342

        return ""

   343

   344

    def GetProjectPath(self):

   345

        return self.ProjectPath

   346

   347

    def GetProjectName(self):

   348

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

   349

   350

    def GetIconName(self):

   351

        return "PROJECT"

   352

   353

    def GetDefaultTargetName(self):

   354

        if wx.Platform == '__WXMSW__':

   355

            return "Win32"

   356

        else:

   357

            return "Linux"

   358

   359

    def GetTarget(self):

   360

        target = self.BeremizRoot.getTargetType()

   361

        if target.getcontent() is None:

   362

            temp_root = self.Parser.CreateRoot()

   363

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

   364

            temp_root.setTargetType(target)

   365

            target_name = self.GetDefaultTargetName()

   366

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

   367

        return target

   368

   369

    def GetParamsAttributes(self, path=None):

   370

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   371

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

   372

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

   373

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

   374

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

   375

        return params

   376

   377

    def SetParamsAttribute(self, path, value):

   378

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

   379

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

   380

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

   381

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

   382

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   383

        return res

   384

   385

    # helper func to check project path write permission

   386

    def CheckProjectPathPerm(self, dosave=True):

   387

        if CheckPathPerm(self.ProjectPath):

   388

            return True

   389

        if self.AppFrame is not None:

   390

            dialog = wx.MessageDialog(

   391

                self.AppFrame,

   392

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

   393

                _('Error'),

   394

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

   395

            answer = dialog.ShowModal()

   396

            dialog.Destroy()

   397

            if answer == wx.ID_YES:

   398

                if self.SaveProjectAs():

   399

                    self.AppFrame.RefreshTitle()

   400

                    self.AppFrame.RefreshFileMenu()

   401

                    self.AppFrame.RefreshPageTitles()

   402

                    return True

   403

        return False

   404

   405

    def _getProjectFilesPath(self, project_path=None):

   406

        if project_path is not None:

   407

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

   408

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

   409

        if not os.path.exists(projectfiles_path):

   410

            os.mkdir(projectfiles_path)

   411

        return projectfiles_path

   412

   413

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

   414

        self.ProjectAddConfiguration(config_name)

   415

        self.ProjectAddConfigurationResource(config_name, res_name)

   416

   417

    def SetProjectDefaultConfiguration(self):

   418

        # Sets default task and instance for new project

   419

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

   420

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

   421

        config = config.getname()

   422

        resource_tagname = ComputeConfigurationResourceName(config, resource)

   423

        def_task = [

   424

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

   425

        def_instance = [

   426

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

   427

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   428

   429

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

   430

        """

   431

        Create a new project in an empty folder

   432

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

   433

        @param PLCParams: properties of the PLCOpen program created

   434

        """

   435

        # Verify that chosen folder is empty

   436

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

   437

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

   438

   439

        # Create PLCOpen program

   440

        self.CreateNewProject(

   441

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

   442

             "productName": _("Unnamed"),

   443

             "productVersion": "1",

   444

             "companyName": _("Unknown"),

   445

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

   446

        self.AddProjectDefaultConfiguration()

   447

   448

        # Change XSD into class members

   449

        self._AddParamsMembers()

   450

        self.Children = {}

   451

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

   452

        self.ProjectPath = ProjectPath

   453

        self._setBuildPath(BuildPath)

   454

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

   455

        self.RefreshConfNodesBlockLists()

   456

        # this will create files base XML files

   457

        self.SaveProject()

   458

        return None

   459

   460

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

   461

        """

   462

        Load a project contained in a folder

   463

        @param ProjectPath: path of the project folder

   464

        """

   465

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

   466

            ProjectPath = os.path.dirname(ProjectPath)

   467

        # Verify that project contains a PLCOpen program

   468

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

   469

        if not os.path.isfile(plc_file):

   470

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

   471

        # Load PLCOpen file

   472

        error = self.OpenXMLFile(plc_file)

   473

        if error is not None:

   474

            if self.Project is not None:

   475

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

   476

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

   477

            else:

   478

                return error, False

   479

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

   480

            self.AddProjectDefaultConfiguration()

   481

        # Change XSD into class members