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

import os

    30

import sys

    31

import traceback

    32

import time

    34

import shutil

    35

import re

    36

import tempfile

    37

from math import ceil

    38

from types import ListType

    39

from threading import Timer, Lock, Thread

    40

from datetime import datetime

    41

from weakref import WeakKeyDictionary

    42

from itertools import izip

    43

    44

import wx

    45

    46

import features

    47

import connectors

    48

import util.paths as paths

    49

from util.misc import CheckPathPerm, GetClassImporter

    50

from util.MiniTextControler import MiniTextControler

    51

from util.ProcessLogger import ProcessLogger

    52

from util.BitmapLibrary import GetBitmap

    53

from editors.FileManagementPanel import FileManagementPanel

    54

from editors.ProjectNodeEditor import ProjectNodeEditor

    55

from editors.IECCodeViewer import IECCodeViewer

    56

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    57

from dialogs import DiscoveryDialog

    58

from PLCControler import PLCControler

    59

from plcopen.structures import IEC_KEYWORDS

    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, e:

   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

   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 = self.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