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

    33

import features

    34

import shutil

    35

import wx

    36

import re

    37

import tempfile

    38

from math import ceil

    39

from types import ListType

    40

from threading import Timer, Lock, Thread

    41

from time import localtime

    42

from datetime import datetime

    43

from weakref import WeakKeyDictionary

    44

from itertools import izip

    45

    46

import targets

    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

    60

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    61

from targets.typemapping import UnpackDebugBuffer

    62

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    63

    64

base_folder = paths.AbsParentDir(__file__)

    65

    66

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

    67

    68

ITEM_CONFNODE = 25

    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():

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

   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

   231

        if ProjectController.iec2c_cfg is None:

   232

            ProjectController.iec2c_cfg = Iec2CSettings()

   233

   234

        self.MandatoryParams = None

   235

        self._builder = None

   236

        self._connector = None

   237

        self.DispatchDebugValuesTimer = None

   238

        self.DebugValuesBuffers = []

   239

        self.DebugTicks = []

   240

        self.SetAppFrame(frame, logger)

   241

   242

        # Setup debug information

   243

        self.IECdebug_datas = {}

   244

        self.IECdebug_lock = Lock()

   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.DebugThread = None

   261

        self.debug_break = False

   262

        self.previous_plcstate = None

   263

        # copy ConfNodeMethods so that it can be later customized

   264

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

   265

   266

    def __del__(self):

   267

        if self.DebugTimer:

   268

            self.DebugTimer.cancel()

   269

        self.KillDebugThread()

   270

   271

    def LoadLibraries(self):

   272

        self.Libraries = []

   273

        TypeStack = []

   274

        for libname, clsname in features.libraries:

   275

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

   276

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

   277

                TypeStack.append(Lib.GetTypes())

   278

                self.Libraries.append(Lib)

   279

   280

    def SetAppFrame(self, frame, logger):

   281

        self.AppFrame = frame

   282

        self.logger = logger

   283

        self.StatusTimer = None

   284

        if self.DispatchDebugValuesTimer is not None:

   285

            self.DispatchDebugValuesTimer.Stop()

   286

        self.DispatchDebugValuesTimer = None

   287

   288

        if frame is not None:

   289

   290

            # Timer to pull PLC status

   291

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

   292

            self.AppFrame.Bind(wx.EVT_TIMER,

   293

                               self.PullPLCStatusProc,

   294

                               self.StatusTimer)

   295

   296

            if self._connector is not None:

   297

                frame.LogViewer.SetLogSource(self._connector)

   298

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

   299

   300

            # Timer to dispatch debug values to consumers

   301

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

   302

            self.AppFrame.Bind(wx.EVT_TIMER,

   303

                               self.DispatchDebugValuesProc,

   304

                               self.DispatchDebugValuesTimer)

   305

   306

            self.RefreshConfNodesBlockLists()

   307

   308

    def ResetAppFrame(self, logger):

   309

        if self.AppFrame is not None:

   310

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

   311

            self.StatusTimer = None

   312

            self.AppFrame = None

   313

            self.KillDebugThread()

   314

        self.logger = logger

   315

   316

    def CTNName(self):

   317

        return "Project"

   318

   319

    def CTNTestModified(self):

   320

        return self.ChangesToSave or not self.ProjectIsSaved()

   321

   322

    def CTNFullName(self):

   323

        return ""

   324

   325

    def GetCTRoot(self):

   326

        return self

   327

   328

    def GetIECLibPath(self):

   329

        return self.iec2c_cfg.getLibCPath()

   330

   331

    def GetIEC2cPath(self):

   332

        return self.iec2c_cfg.getCmd()

   333

   334

    def GetCurrentLocation(self):

   335

        return ()

   336

   337

    def GetCurrentName(self):

   338

        return ""

   339

   340

    def _GetCurrentName(self):

   341

        return ""

   342

   343

    def GetProjectPath(self):

   344

        return self.ProjectPath

   345

   346

    def GetProjectName(self):

   347

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

   348

   349

    def GetIconName(self):

   350

        return "PROJECT"

   351

   352

    def GetDefaultTargetName(self):

   353

        if wx.Platform == '__WXMSW__':

   354

            return "Win32"

   355

        else:

   356

            return "Linux"

   357

   358

    def GetTarget(self):

   359

        target = self.BeremizRoot.getTargetType()

   360

        if target.getcontent() is None:

   361

            temp_root = self.Parser.CreateRoot()

   362

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

   363

            temp_root.setTargetType(target)

   364

            target_name = self.GetDefaultTargetName()

   365

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

   366

        return target

   367

   368

    def GetParamsAttributes(self, path=None):

   369

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   370

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

   371

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

   372

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

   373

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

   374

        return params

   375

   376

    def SetParamsAttribute(self, path, value):

   377

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

   378

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

   379

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

   380

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

   381

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   382

        return res

   383

   384

    # helper func to check project path write permission

   385

    def CheckProjectPathPerm(self, dosave=True):

   386

        if CheckPathPerm(self.ProjectPath):

   387

            return True

   388

        if self.AppFrame is not None:

   389

            dialog = wx.MessageDialog(

   390

                self.AppFrame,

   391

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

   392

                _('Error'),

   393

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

   394

            answer = dialog.ShowModal()

   395

            dialog.Destroy()

   396

            if answer == wx.ID_YES:

   397

                if self.SaveProjectAs():

   398

                    self.AppFrame.RefreshTitle()

   399

                    self.AppFrame.RefreshFileMenu()

   400

                    self.AppFrame.RefreshPageTitles()

   401

                    return True

   402

        return False

   403

   404

    def _getProjectFilesPath(self, project_path=None):

   405

        if project_path is not None:

   406

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

   407

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

   408

        if not os.path.exists(projectfiles_path):

   409

            os.mkdir(projectfiles_path)

   410

        return projectfiles_path

   411

   412

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

   413

        self.ProjectAddConfiguration(config_name)

   414

        self.ProjectAddConfigurationResource(config_name, res_name)

   415

   416

    def SetProjectDefaultConfiguration(self):

   417

        # Sets default task and instance for new project

   418

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

   419

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

   420

        config = config.getname()

   421

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   422

        def_task = [

   423

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

   424

        def_instance = [

   425

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

   426

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   427

   428

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

   429

        """

   430

        Create a new project in an empty folder

   431

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

   432

        @param PLCParams: properties of the PLCOpen program created

   433

        """

   434

        # Verify that chosen folder is empty

   435

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

   436

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

   437

   438

        # Create PLCOpen program

   439

        self.CreateNewProject(

   440

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

   441

             "productName": _("Unnamed"),

   442

             "productVersion": "1",

   443

             "companyName": _("Unknown"),

   444

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

   445

        self.AddProjectDefaultConfiguration()

   446

   447

        # Change XSD into class members

   448

        self._AddParamsMembers()

   449

        self.Children = {}

   450

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

   451

        self.ProjectPath = ProjectPath

   452

        self._setBuildPath(BuildPath)

   453

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

   454

        self.RefreshConfNodesBlockLists()

   455

        # this will create files base XML files

   456

        self.SaveProject()

   457

        return None

   458

   459

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

   460

        """

   461

        Load a project contained in a folder

   462

        @param ProjectPath: path of the project folder

   463

        """

   464

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

   465

            ProjectPath = os.path.dirname(ProjectPath)

   466

        # Verify that project contains a PLCOpen program

   467

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

   468

        if not os.path.isfile(plc_file):

   469

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

   470

        # Load PLCOpen file

   471

        error = self.OpenXMLFile(plc_file)

   472

        if error is not None:

   473

            if self.Project is not None:

   474

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

   475

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

   476

            else:

   477

                return error, False

   478

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

   479

            self.AddProjectDefaultConfiguration()

   480

        # Change XSD into class members

   481

        self._AddParamsMembers()