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

   105

        for p in paths:

   106

            if test(p):

   107

                path = p

   108

                break

   109

        return path

   110

   111

    def findCmd(self):

   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:

   121

   122

        return cmd

   123

   124

    def findLibPath(self):

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

   135

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

   136

            self.ieclib_path]

   137

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

   138

        return path

   139

   140

    def findSupportedOptions(self):

   141

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

   143

   144

        buildopt = ""

   145

        try:

   146

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

   147

            status, result, err_result = ProcessLogger(None, buildcmd,

   148

                no_stdout=True, no_stderr=True).spin()

   149

        except Exception, e:

   150

            return buildopt

   151

   152

        for opt in options:

   153

            if opt in result:

   154

                buildopt = buildopt + " " + opt

   155

        return buildopt

   156

   157

    def getCmd(self):

   158

        if self.iec2c is None:

   159

            self.iec2c = self.findCmd()

   160

        return self.iec2c

   161

   162

    def getOptions(self):

   163

        if self.iec2c_buildopts is None:

   164

            self.iec2c_buildopts = self.findSupportedOptions()

   165

        return self.iec2c_buildopts

   166

   167

    def getLibPath(self):

   168

        return self.ieclib_path

   169

   170

    def getLibCPath(self):

   171

        if self.ieclib_c_path is None:

   172

            self.ieclib_c_path = self.findLibCPath()

   173

        return self.ieclib_c_path

   174

   175

iec2c_cfg = Iec2CSettings()

   176

   177

   178

class ProjectController(ConfigTreeNode, PLCControler):

   179

    """

   180

    This class define Root object of the confnode tree.

   181

    It is responsible of :

   182

    - Managing project directory

   183

    - Building project

   184

    - Handling PLCOpenEditor controler and view

   185

    - Loading user confnodes and instanciante them as children

   186

    - ...

   187

   188

    """

   189

   190

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

   191

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   192

   193

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

   194

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

   195

      <xsd:element name="BeremizRoot">

   196

        <xsd:complexType>

   197

          <xsd:sequence>

   198

            <xsd:element name="TargetType">

   199

              <xsd:complexType>

   200

                <xsd:choice minOccurs="0">

   201

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

   202

                </xsd:choice>

   203

              </xsd:complexType>

   204

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

   205

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

   206

              <xsd:complexType>

   209

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

   210

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

   211

              </xsd:complexType>

   213

          </xsd:sequence>

   214

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

   215

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

   216

        </xsd:complexType>

   217

      </xsd:element>

   218

    </xsd:schema>

   219

    """

   220

    EditorType = ProjectNodeEditor

   221

   222

    def __init__(self, frame, logger):

   223

        PLCControler.__init__(self)

   224

   225

        self.MandatoryParams = None

   226

        self._builder = None

   227

        self._connector = None

   228

        self.DispatchDebugValuesTimer = None

   229

        self.DebugValuesBuffers = []

   230

        self.DebugTicks = []

   231

        self.SetAppFrame(frame, logger)

   232

   233

        # Setup debug information

   234

        self.IECdebug_datas = {}

   235

        self.IECdebug_lock = Lock()

   236

   238

        self.ResetIECProgramsAndVariables()

   239

   240

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

   241

        self.ChangesToSave = False

   242

        # root have no parent

   243

        self.CTNParent = None

   244

        # Keep track of the confnode type name

   245

        self.CTNType = "Beremiz"

   246

        self.Children = {}

   247

        self._View = None

   248

        # After __init__ root confnode is not valid

   249

        self.ProjectPath = None

   250

        self._setBuildPath(None)

   251

        self.DebugThread = None

   252

        self.debug_break = False

   253

        self.previous_plcstate = None

   254

        # copy ConfNodeMethods so that it can be later customized

   255

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

   256

   257

    def __del__(self):

   258

        if self.DebugTimer:

   259

            self.DebugTimer.cancel()

   260

        self.KillDebugThread()

   261

   262

    def LoadLibraries(self):

   263

        self.Libraries = []

   265

        for libname, clsname in features.libraries:

   266

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

   267

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

   268

                TypeStack.append(Lib.GetTypes())

   269

                self.Libraries.append(Lib)

   270

   271

    def SetAppFrame(self, frame, logger):

   272

        self.AppFrame = frame

   273

        self.logger = logger

   274

        self.StatusTimer = None

   275

        if self.DispatchDebugValuesTimer is not None:

   276

            self.DispatchDebugValuesTimer.Stop()

   277

        self.DispatchDebugValuesTimer = None

   278

   279

        if frame is not None:

   280

   281

            # Timer to pull PLC status

   282

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

   283

            self.AppFrame.Bind(wx.EVT_TIMER,

   284

                self.PullPLCStatusProc, self.StatusTimer)

   285

   286

            if self._connector is not None:

   287

                frame.LogViewer.SetLogSource(self._connector)

   288

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

   289

   290

            # Timer to dispatch debug values to consumers

   291

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

   292

            self.AppFrame.Bind(wx.EVT_TIMER,

   293

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   294

   295

            self.RefreshConfNodesBlockLists()

   296

   297

    def ResetAppFrame(self, logger):

   298

        if self.AppFrame is not None:

   299

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

   300

            self.StatusTimer = None

   301

            self.AppFrame = None

   302

   303

        self.logger = logger

   304

   305

    def CTNName(self):

   306

        return "Project"

   307

   308

    def CTNTestModified(self):

   309

         return self.ChangesToSave or not self.ProjectIsSaved()

   310

   311

    def CTNFullName(self):

   312

        return ""

   313

   314

    def GetCTRoot(self):

   315

        return self

   316

   317

    def GetIECLibPath(self):

   318

        return iec2c_cfg.getLibCPath()

   319

   320

    def GetIEC2cPath(self):

   321

        return iec2c_cfg.getCmd()

   322

   323

    def GetCurrentLocation(self):

   324

        return ()

   325

   326

    def GetCurrentName(self):

   327

        return ""

   328

   329

    def _GetCurrentName(self):

   330

        return ""

   331

   332

    def GetProjectPath(self):

   333

        return self.ProjectPath

   334

   335

    def GetProjectName(self):

   336

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

   337

   338

    def GetIconName(self):

   339

        return "PROJECT"

   340

   341

    def GetDefaultTargetName(self):

   342

        if wx.Platform == '__WXMSW__':

   343

            return "Win32"

   344

        else:

   345

            return "Linux"

   346

   347

    def GetTarget(self):

   348

        target = self.BeremizRoot.getTargetType()

   349

        if target.getcontent() is None:

   350

            temp_root = self.Parser.CreateRoot()

   351

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

   352

            temp_root.setTargetType(target)

   353

            target_name = self.GetDefaultTargetName()

   354

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

   355

        return target

   356

   357

    def GetParamsAttributes(self, path = None):

   358

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   359

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

   360

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

   361

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

   362

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

   363

        return params

   364

   365

    def SetParamsAttribute(self, path, value):

   366

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

   367

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

   368

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

   369

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

   370

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   371

        return res

   372

   373

    # helper func to check project path write permission

   374

    def CheckProjectPathPerm(self, dosave=True):

   375

        if CheckPathPerm(self.ProjectPath):

   376

            return True

   377

        if self.AppFrame is not None:

   378

            dialog = wx.MessageDialog(self.AppFrame,

   379

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

   380

                        _('Error'),

   381

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

   382

            answer = dialog.ShowModal()

   383

            dialog.Destroy()

   384

            if answer == wx.ID_YES:

   385

                if self.SaveProjectAs():

   386

                    self.AppFrame.RefreshTitle()

   387

                    self.AppFrame.RefreshFileMenu()

   388

                    self.AppFrame.RefreshPageTitles()

   389

                    return True

   390

        return False

   391

   392

    def _getProjectFilesPath(self, project_path=None):

   393

        if project_path is not None:

   394

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

   395

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

   396

        if not os.path.exists(projectfiles_path):

   397

            os.mkdir(projectfiles_path)

   398

        return projectfiles_path

   399

   400

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

   401

        self.ProjectAddConfiguration(config_name)

   402

        self.ProjectAddConfigurationResource(config_name, res_name)

   403

   404

    def SetProjectDefaultConfiguration(self):

   405

        # Sets default task and instance for new project

   406

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

   407

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

   408

        config = config.getname()

   409

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   410

        def_task = [

   411

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

   412

        def_instance = [

   413

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

   414

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   415

   416

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

   417

        """

   418

        Create a new project in an empty folder

   419

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

   420

        @param PLCParams: properties of the PLCOpen program created

   421

        """

   422

        # Verify that chosen folder is empty

   423

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

   424

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

   425

   426

        # Create PLCOpen program

   427

        self.CreateNewProject(

   428

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

   429

             "productName": _("Unnamed"),

   430

             "productVersion": "1",

   431

             "companyName": _("Unknown"),

   432

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

   433

        self.AddProjectDefaultConfiguration()

   434

   435

        # Change XSD into class members

   436

        self._AddParamsMembers()

   437

        self.Children = {}

   438

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

   439

        self.ProjectPath = ProjectPath

   440

        self._setBuildPath(BuildPath)

   441

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

   442

        self.RefreshConfNodesBlockLists()

   443

        # this will create files base XML files

   444

        self.SaveProject()

   445

        return None

   446

   447

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

   448

        """

   449

        Load a project contained in a folder

   450

        @param ProjectPath: path of the project folder

   451

        """

   452

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

   453

            ProjectPath = os.path.dirname(ProjectPath)

   454

        # Verify that project contains a PLCOpen program

   455

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

   456

        if not os.path.isfile(plc_file):

   457

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

   458

        # Load PLCOpen file

   459

        error = self.OpenXMLFile(plc_file)

   460

        if error is not None:

   461

            if self.Project is not None:

   462

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

   463

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

   464

            else:

   465

                return error, False

   466

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

   467

            self.AddProjectDefaultConfiguration()

   468

        # Change XSD into class members

   469

        self._AddParamsMembers()

   470

        self.Children = {}

   471

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

   472

        self.ProjectPath = ProjectPath

   473

        self._setBuildPath(BuildPath)

   474

        # If dir have already be made, and file exist

   475

        if os.path.isdir(self.CTNPath()) and os.path.isfile(self.ConfNodeXmlFilePath()):

   476

            # Load the confnode.xml file into parameters members

   477

            result = self.LoadXMLParams()

   478

            if result:

   479

                return result, False

   480

            # Load and init all the children