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 traceback

    31

import time

    32

from time import localtime

    33

import shutil

    34

import re

    35

import tempfile

    36

from types import ListType

    37

from threading import Timer, Lock, Thread

    38

from datetime import datetime

    39

from weakref import WeakKeyDictionary

    40

from itertools import izip

    41

    42

import wx

    43

    44

import features

    45

import connectors

    46

import util.paths as paths

    47

from util.misc import CheckPathPerm, GetClassImporter

    48

from util.MiniTextControler import MiniTextControler

    49

from util.ProcessLogger import ProcessLogger

    50

from util.BitmapLibrary import GetBitmap

    51

from editors.FileManagementPanel import FileManagementPanel

    52

from editors.ProjectNodeEditor import ProjectNodeEditor

    53

from editors.IECCodeViewer import IECCodeViewer

    54

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    55

from dialogs import DiscoveryDialog

    56

from PLCControler import PLCControler

    57

from plcopen.structures import IEC_KEYWORDS

    58

import targets

    59

from targets.typemapping import DebugTypesSize, UnpackDebugBuffer

    60

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    61

    62

base_folder = paths.AbsParentDir(__file__)

    63

    64

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

    65

    66

ITEM_CONFNODE = 25

    67

    68

    69

def ExtractChildrenTypesFromCatalog(catalog):

    70

    children_types = []

    71

    for n, d, _h, c in catalog:

    72

        if isinstance(c, ListType):

    73

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    74

        else:

    75

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

    76

    return children_types

    77

    78

    79

def ExtractMenuItemsFromCatalog(catalog):

    80

    menu_items = []

    81

    for n, d, h, c in catalog:

    82

        if isinstance(c, ListType):

    83

            children = ExtractMenuItemsFromCatalog(c)

    84

        else:

    85

            children = []

    86

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

    87

    return menu_items

    88

    89

    90

def GetAddMenuItems():

    91

    return ExtractMenuItemsFromCatalog(features.catalog)

    92

    93

    94

class Iec2CSettings(object):

    95

    def __init__(self):

    96

        self.iec2c = None

    97

        self.iec2c_buildopts = None

    98

        self.ieclib_path = self.findLibPath()

    99

        self.ieclib_c_path = self.findLibCPath()

   100

   101

    def findObject(self, paths, test):

   102

        path = None

   103

        for p in paths:

   104

            if test(p):

   105

                path = p

   106

                break

   107

        return path

   108

   109

    def findCmd(self):

   110

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

   111

        paths = [

   112

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

   113

        ]

   114

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

   115

   116

        # otherwise use iec2c from PATH

   117

        if path is not None:

   118

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

   119

   120

        return cmd

   121

   122

    def findLibPath(self):

   123

        paths = [

   124

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

   125

            "/usr/lib/matiec"

   126

        ]

   127

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

   128

        return path

   129

   130

    def findLibCPath(self):

   131

        path = None

   132

        if self.ieclib_path is not None:

   133

            paths = [

   134

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

   135

                self.ieclib_path]

   136

            path = self.findObject(

   137

                paths,

   138

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

   139

        return path

   140

   141

    def findSupportedOptions(self):

   142

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

   143

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

   144

   145

        buildopt = ""

   146

        try:

   147

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

   148

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

   149

                                                         no_stdout=True,

   150

                                                         no_stderr=True).spin()

   151

        except Exception:

   152

            return buildopt

   153

   154

        for opt in options:

   155

            if opt in result:

   156

                buildopt = buildopt + " " + opt

   157

        return buildopt

   158

   159

    def getCmd(self):

   160

        if self.iec2c is None:

   161

            self.iec2c = self.findCmd()

   162

        return self.iec2c

   163

   164

    def getOptions(self):

   165

        if self.iec2c_buildopts is None:

   166

            self.iec2c_buildopts = self.findSupportedOptions()

   167

        return self.iec2c_buildopts

   168

   169

    def getLibPath(self):

   170

        return self.ieclib_path

   171

   172

    def getLibCPath(self):

   173

        if self.ieclib_c_path is None:

   174

            self.ieclib_c_path = self.findLibCPath()

   175

        return self.ieclib_c_path

   176

   177

   178

def GetProjectControllerXSD():

   179

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

   180

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

   181

      <xsd:element name="BeremizRoot">

   182

        <xsd:complexType>

   183

          <xsd:sequence>

   184

            <xsd:element name="TargetType">

   185

              <xsd:complexType>

   186

                <xsd:choice minOccurs="0">

   187

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

   188

                </xsd:choice>

   189

              </xsd:complexType>

   190

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

   191

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

   192

              <xsd:complexType>

   193

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

   194

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

   195

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

   196

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

   197

              </xsd:complexType>

   198

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

   199

          </xsd:sequence>

   200

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

   201

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

   202

        </xsd:complexType>

   203

      </xsd:element>

   204

    </xsd:schema>

   205

    """

   206

    return XSD

   207

   208

   209

class ProjectController(ConfigTreeNode, PLCControler):

   210

    """

   211

    This class define Root object of the confnode tree.

   212

    It is responsible of :

   213

    - Managing project directory

   214

    - Building project

   215

    - Handling PLCOpenEditor controler and view

   216

    - Loading user confnodes and instanciante them as children

   217

    - ...

   218

   219

    """

   220

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

   221

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   222

    XSD = GetProjectControllerXSD()

   223

    EditorType = ProjectNodeEditor

   224

    iec2c_cfg = None

   225

   226

    def __init__(self, frame, logger):

   227

        PLCControler.__init__(self)

   228

        ConfigTreeNode.__init__(self)

   229

   230

        if ProjectController.iec2c_cfg is None:

   231

            ProjectController.iec2c_cfg = Iec2CSettings()

   232

   233

        self.MandatoryParams = None

   234

        self._builder = None

   235

        self._connector = None

   236

        self.DispatchDebugValuesTimer = None

   237

        self.DebugValuesBuffers = []

   238

        self.DebugTicks = []

   239

        self.SetAppFrame(frame, logger)

   240

   241

        # Setup debug information

   242

        self.IECdebug_datas = {}

   243

        self.IECdebug_lock = Lock()

   244

   245

        self.DebugTimer = None

   246

        self.ResetIECProgramsAndVariables()

   247

   248

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

   249

        self.ChangesToSave = False

   250

        # root have no parent

   251

        self.CTNParent = None

   252

        # Keep track of the confnode type name

   253

        self.CTNType = "Beremiz"

   254

        self.Children = {}

   255

        self._View = None

   256

        # After __init__ root confnode is not valid

   257

        self.ProjectPath = None

   258

        self._setBuildPath(None)

   259

        self.DebugThread = 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 = self.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 = {}