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

import targets

    62

from targets.typemapping import DebugTypesSize, UnpackDebugBuffer

    63

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    64

    65

base_folder = paths.AbsParentDir(__file__)

    66

    67

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

    68

    69

ITEM_CONFNODE = 25

    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

    def __init__(self):

    99

        self.iec2c = None

   100

        self.iec2c_buildopts = None

   101

        self.ieclib_path = self.findLibPath()

   102

        self.ieclib_c_path = self.findLibCPath()

   103

   104

    def findObject(self, paths, test):

   105

        path = None

   106

        for p in paths:

   107

            if test(p):

   108

                path = p

   109

                break

   110

        return path

   111

   112

    def findCmd(self):

   113

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

   114

        paths = [

   115

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

   116

        ]

   117

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

   118

   119

        # otherwise use iec2c from PATH

   120

        if path is not None:

   121

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

   122

   123

        return cmd

   124

   125

    def findLibPath(self):

   126

        paths = [

   127

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

   128

            "/usr/lib/matiec"

   129

        ]

   130

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

   131

        return path

   132

   133

    def findLibCPath(self):

   134

        path = None

   135

        if self.ieclib_path is not None:

   136

            paths = [

   137

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

   138

                self.ieclib_path]

   139

            path = self.findObject(

   140

                paths,

   141

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

   142

        return path

   143

   144

    def findSupportedOptions(self):

   145

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

   146

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

   147

   148

        buildopt = ""

   149

        try:

   150

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

   151

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

   152

                                                         no_stdout=True,

   153

                                                         no_stderr=True).spin()

   154

        except Exception:

   155

            return buildopt

   156

   157

        for opt in options:

   158

            if opt in result:

   159

                buildopt = buildopt + " " + opt

   160

        return buildopt

   161

   162

    def getCmd(self):

   163

        if self.iec2c is None:

   164

            self.iec2c = self.findCmd()

   165

        return self.iec2c

   166

   167

    def getOptions(self):

   168

        if self.iec2c_buildopts is None:

   169

            self.iec2c_buildopts = self.findSupportedOptions()

   170

        return self.iec2c_buildopts

   171

   172

    def getLibPath(self):

   173

        return self.ieclib_path

   174

   175

    def getLibCPath(self):

   176

        if self.ieclib_c_path is None:

   177

            self.ieclib_c_path = self.findLibCPath()

   178

        return self.ieclib_c_path

   179

   180

   181

def GetProjectControllerXSD():

   182

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

   183

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

   184

      <xsd:element name="BeremizRoot">

   185

        <xsd:complexType>

   186

          <xsd:sequence>

   187

            <xsd:element name="TargetType">

   188

              <xsd:complexType>

   189

                <xsd:choice minOccurs="0">

   190

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

   191

                </xsd:choice>

   192

              </xsd:complexType>

   193

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

   194

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

   195

              <xsd:complexType>

   196

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

   197

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

   198

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

   199

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

   200

              </xsd:complexType>

   201

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

   202

          </xsd:sequence>

   203

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

   204

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

   205

        </xsd:complexType>

   206

      </xsd:element>

   207

    </xsd:schema>

   208

    """

   209

    return XSD

   210

   211

   212

class ProjectController(ConfigTreeNode, PLCControler):

   213

    """

   214

    This class define Root object of the confnode tree.

   215

    It is responsible of :

   216

    - Managing project directory

   217

    - Building project

   218

    - Handling PLCOpenEditor controler and view

   219

    - Loading user confnodes and instanciante them as children

   220

    - ...

   221

   222

    """

   223

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

   224

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   225

    XSD = GetProjectControllerXSD()

   226

    EditorType = ProjectNodeEditor

   227

    iec2c_cfg = None

   228

   229

    def __init__(self, frame, logger):

   230

        PLCControler.__init__(self)

   231

        ConfigTreeNode.__init__(self)

   232

   233

        if ProjectController.iec2c_cfg is None:

   234

            ProjectController.iec2c_cfg = Iec2CSettings()

   235

   236

        self.MandatoryParams = None

   237

        self._builder = None

   238

        self._connector = None

   239

        self.DispatchDebugValuesTimer = None

   240

        self.DebugValuesBuffers = []

   241

        self.DebugTicks = []

   242

        self.SetAppFrame(frame, logger)

   243

   244

        # Setup debug information

   245

        self.IECdebug_datas = {}

   246

        self.IECdebug_lock = Lock()

   247

   248

        self.DebugTimer = None

   249

        self.ResetIECProgramsAndVariables()

   250

   251

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

   252

        self.ChangesToSave = False

   253

        # root have no parent

   254

        self.CTNParent = None

   255

        # Keep track of the confnode type name

   256

        self.CTNType = "Beremiz"

   257

        self.Children = {}

   258

        self._View = None

   259

        # After __init__ root confnode is not valid

   260

        self.ProjectPath = None

   261

        self._setBuildPath(None)

   262

        self.DebugThread = None

   263

        self.debug_break = False

   264

        self.previous_plcstate = None

   265

        # copy ConfNodeMethods so that it can be later customized

   266

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

   267

   268

    def __del__(self):

   269

        if self.DebugTimer:

   270

            self.DebugTimer.cancel()

   271

        self.KillDebugThread()

   272

   273

    def LoadLibraries(self):

   274

        self.Libraries = []

   275

        TypeStack = []

   276

        for libname, clsname in features.libraries:

   277

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

   278

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

   279

                TypeStack.append(Lib.GetTypes())

   280

                self.Libraries.append(Lib)

   281

   282

    def SetAppFrame(self, frame, logger):

   283

        self.AppFrame = frame

   284

        self.logger = logger

   285

        self.StatusTimer = None

   286

        if self.DispatchDebugValuesTimer is not None:

   287

            self.DispatchDebugValuesTimer.Stop()

   288

        self.DispatchDebugValuesTimer = None

   289

   290

        if frame is not None:

   291

   292

            # Timer to pull PLC status

   293

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

   294

            self.AppFrame.Bind(wx.EVT_TIMER,

   295

                               self.PullPLCStatusProc,

   296

                               self.StatusTimer)

   297

   298

            if self._connector is not None:

   299

                frame.LogViewer.SetLogSource(self._connector)

   300

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

   301

   302

            # Timer to dispatch debug values to consumers

   303

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

   304

            self.AppFrame.Bind(wx.EVT_TIMER,

   305

                               self.DispatchDebugValuesProc,

   306

                               self.DispatchDebugValuesTimer)

   307

   308

            self.RefreshConfNodesBlockLists()

   309

   310

    def ResetAppFrame(self, logger):

   311

        if self.AppFrame is not None:

   312

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

   313

            self.StatusTimer = None

   314

            self.AppFrame = None

   315

            self.KillDebugThread()

   316

        self.logger = logger

   317

   318

    def CTNName(self):

   319

        return "Project"

   320

   321

    def CTNTestModified(self):

   322

        return self.ChangesToSave or not self.ProjectIsSaved()

   323

   324

    def CTNFullName(self):

   325

        return ""

   326

   327

    def GetCTRoot(self):

   328

        return self

   329

   330

    def GetIECLibPath(self):

   331

        return self.iec2c_cfg.getLibCPath()

   332

   333

    def GetIEC2cPath(self):

   334

        return self.iec2c_cfg.getCmd()

   335

   336

    def GetCurrentLocation(self):

   337

        return ()

   338

   339

    def GetCurrentName(self):

   340

        return ""

   341

   342

    def _GetCurrentName(self):

   343

        return ""

   344

   345

    def GetProjectPath(self):

   346

        return self.ProjectPath

   347

   348

    def GetProjectName(self):

   349

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

   350

   351

    def GetIconName(self):

   352

        return "PROJECT"

   353

   354

    def GetDefaultTargetName(self):

   355

        if wx.Platform == '__WXMSW__':

   356

            return "Win32"

   357

        else:

   358

            return "Linux"

   359

   360

    def GetTarget(self):

   361

        target = self.BeremizRoot.getTargetType()

   362

        if target.getcontent() is None:

   363

            temp_root = self.Parser.CreateRoot()

   364

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

   365

            temp_root.setTargetType(target)

   366

            target_name = self.GetDefaultTargetName()

   367

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

   368

        return target

   369

   370

    def GetParamsAttributes(self, path=None):

   371

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   372

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

   373

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

   374

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

   375

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

   376

        return params

   377

   378

    def SetParamsAttribute(self, path, value):

   379

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

   380

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

   381

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

   382

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

   383

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   384

        return res

   385

   386

    # helper func to check project path write permission

   387

    def CheckProjectPathPerm(self, dosave=True):

   388

        if CheckPathPerm(self.ProjectPath):

   389

            return True

   390

        if self.AppFrame is not None:

   391

            dialog = wx.MessageDialog(

   392

                self.AppFrame,

   393

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

   394

                _('Error'),

   395

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

   396

            answer = dialog.ShowModal()

   397

            dialog.Destroy()

   398

            if answer == wx.ID_YES:

   399

                if self.SaveProjectAs():

   400

                    self.AppFrame.RefreshTitle()

   401

                    self.AppFrame.RefreshFileMenu()

   402

                    self.AppFrame.RefreshPageTitles()

   403

                    return True

   404

        return False

   405

   406

    def _getProjectFilesPath(self, project_path=None):

   407

        if project_path is not None:

   408

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

   409

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

   410

        if not os.path.exists(projectfiles_path):

   411

            os.mkdir(projectfiles_path)

   412

        return projectfiles_path

   413

   414

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

   415

        self.ProjectAddConfiguration(config_name)

   416

        self.ProjectAddConfigurationResource(config_name, res_name)

   417

   418

    def SetProjectDefaultConfiguration(self):

   419

        # Sets default task and instance for new project

   420

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

   421

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

   422

        config = config.getname()

   423

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   424

        def_task = [

   425

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

   426

        def_instance = [

   427

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

   428

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   429

   430

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

   431

        """

   432

        Create a new project in an empty folder

   433

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

   434

        @param PLCParams: properties of the PLCOpen program created

   435

        """

   436

        # Verify that chosen folder is empty

   437

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

   438

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

   439

   440

        # Create PLCOpen program

   441

        self.CreateNewProject(

   442

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

   443

             "productName": _("Unnamed"),

   444

             "productVersion": "1",

   445

             "companyName": _("Unknown"),

   446

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

   447

        self.AddProjectDefaultConfiguration()

   448

   449

        # Change XSD into class members

   450

        self._AddParamsMembers()

   451

        self.Children = {}

   452

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

   453

        self.ProjectPath = ProjectPath

   454

        self._setBuildPath(BuildPath)

   455

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

   456

        self.RefreshConfNodesBlockLists()

   457

        # this will create files base XML files

   458

        self.SaveProject()

   459

        return None

   460

   461

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

   462

        """

   463

        Load a project contained in a folder

   464

        @param ProjectPath: path of the project folder

   465

        """

   466

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

   467

            ProjectPath = os.path.dirname(ProjectPath)

   468

        # Verify that project contains a PLCOpen program

   469

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

   470

        if not os.path.isfile(plc_file):

   471

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

   472

        # Load PLCOpen file

   473

        error = self.OpenXMLFile(plc_file)

   474

        if error is not None:

   475

            if self.Project is not None:

   476

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

   477

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

   478

            else:

   479

                return error, False

   480

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

   481

            self.AddProjectDefaultConfiguration()