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

        paths = [

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

   142

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

   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,

   149

                                                       no_stderr=True).spin()

   150

        except Exception, e:

   151

            return buildopt

   152

   153

        for opt in options:

   154

            if opt in result:

   155

                buildopt = buildopt + " " + opt

   156

        return buildopt

   157

   158

    def getCmd(self):

   159

        if self.iec2c is None:

   160

            self.iec2c = self.findCmd()

   161

        return self.iec2c

   162

   163

    def getOptions(self):

   164

        if self.iec2c_buildopts is None:

   165

            self.iec2c_buildopts = self.findSupportedOptions()

   166

        return self.iec2c_buildopts

   167

   168

    def getLibPath(self):

   169

        return self.ieclib_path

   170

   171

    def getLibCPath(self):

   172

        if self.ieclib_c_path is None:

   173

            self.ieclib_c_path = self.findLibCPath()

   174

        return self.ieclib_c_path

   175

   176

   177

iec2c_cfg = Iec2CSettings()

   178

   179

   180

class ProjectController(ConfigTreeNode, PLCControler):

   181

    """

   182

    This class define Root object of the confnode tree.

   183

    It is responsible of :

   184

    - Managing project directory

   185

    - Building project

   186

    - Handling PLCOpenEditor controler and view

   187

    - Loading user confnodes and instanciante them as children

   188

    - ...

   189

   190

    """

   191

   192

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

   193

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   194

   195

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

   196

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

   197

      <xsd:element name="BeremizRoot">

   198

        <xsd:complexType>

   199

          <xsd:sequence>

   200

            <xsd:element name="TargetType">

   201

              <xsd:complexType>

   202

                <xsd:choice minOccurs="0">

   203

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

   204

                </xsd:choice>

   205

              </xsd:complexType>

   206

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

   207

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

   208

              <xsd:complexType>

   209

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

   210

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

   211

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

   212

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

   213

              </xsd:complexType>

   214

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

   215

          </xsd:sequence>

   216

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

   217

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

   218

        </xsd:complexType>

   219

      </xsd:element>

   220

    </xsd:schema>

   221

    """

   222

    EditorType = ProjectNodeEditor

   223

   224

    def __init__(self, frame, logger):

   225

        PLCControler.__init__(self)

   226

   227

        self.MandatoryParams = None

   228

        self._builder = None

   229

        self._connector = None

   230

        self.DispatchDebugValuesTimer = None

   231

        self.DebugValuesBuffers = []

   232

        self.DebugTicks = []

   233

        self.SetAppFrame(frame, logger)

   234

   235

        # Setup debug information

   236

        self.IECdebug_datas = {}

   237

        self.IECdebug_lock = Lock()

   238

   239

        self.DebugTimer = None

   240

        self.ResetIECProgramsAndVariables()

   241

   242

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

   243

        self.ChangesToSave = False

   244

        # root have no parent

   245

        self.CTNParent = None

   246

        # Keep track of the confnode type name

   247

        self.CTNType = "Beremiz"

   248

        self.Children = {}

   249

        self._View = None

   250

        # After __init__ root confnode is not valid

   251

        self.ProjectPath = None

   252

        self._setBuildPath(None)

   253

        self.DebugThread = None

   254

        self.debug_break = False

   255

        self.previous_plcstate = None

   256

        # copy ConfNodeMethods so that it can be later customized

   257

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

   258

   259

    def __del__(self):

   260

        if self.DebugTimer:

   261

            self.DebugTimer.cancel()

   262

        self.KillDebugThread()

   263

   264

    def LoadLibraries(self):

   265

        self.Libraries = []

   266

        TypeStack = []

   267

        for libname, clsname in features.libraries:

   268

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

   269

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

   270

                TypeStack.append(Lib.GetTypes())

   271

                self.Libraries.append(Lib)

   272

   273

    def SetAppFrame(self, frame, logger):

   274

        self.AppFrame = frame

   275

        self.logger = logger

   276

        self.StatusTimer = None

   277

        if self.DispatchDebugValuesTimer is not None:

   278

            self.DispatchDebugValuesTimer.Stop()

   279

        self.DispatchDebugValuesTimer = None

   280

   281

        if frame is not None:

   282

   283

            # Timer to pull PLC status

   284

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

   285

            self.AppFrame.Bind(wx.EVT_TIMER,

   286

                               self.PullPLCStatusProc,

   287

                               self.StatusTimer)

   288

   289

            if self._connector is not None:

   290

                frame.LogViewer.SetLogSource(self._connector)

   291

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

   292

   293

            # Timer to dispatch debug values to consumers

   294

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

   295

            self.AppFrame.Bind(wx.EVT_TIMER,

   296

                               self.DispatchDebugValuesProc,

   297

                               self.DispatchDebugValuesTimer)

   298

   299

            self.RefreshConfNodesBlockLists()

   300

   301

    def ResetAppFrame(self, logger):

   302

        if self.AppFrame is not None:

   303

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

   304

            self.StatusTimer = None

   305

            self.AppFrame = None

   306

   307

        self.logger = logger

   308

   309

    def CTNName(self):

   310

        return "Project"

   311

   312

    def CTNTestModified(self):

   313

        return self.ChangesToSave or not self.ProjectIsSaved()

   314

   315

    def CTNFullName(self):

   316

        return ""

   317

   318

    def GetCTRoot(self):

   319

        return self

   320

   321

    def GetIECLibPath(self):

   322

        return iec2c_cfg.getLibCPath()

   323

   324

    def GetIEC2cPath(self):

   325

        return iec2c_cfg.getCmd()

   326

   327

    def GetCurrentLocation(self):

   328

        return ()

   329

   330

    def GetCurrentName(self):

   331

        return ""

   332

   333

    def _GetCurrentName(self):

   334

        return ""

   335

   336

    def GetProjectPath(self):

   337

        return self.ProjectPath

   338

   339

    def GetProjectName(self):

   340

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

   341

   342

    def GetIconName(self):

   343

        return "PROJECT"

   344

   345

    def GetDefaultTargetName(self):

   346

        if wx.Platform == '__WXMSW__':

   347

            return "Win32"

   348

        else:

   349

            return "Linux"

   350

   351

    def GetTarget(self):

   352

        target = self.BeremizRoot.getTargetType()

   353

        if target.getcontent() is None:

   354

            temp_root = self.Parser.CreateRoot()

   355

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

   356

            temp_root.setTargetType(target)

   357

            target_name = self.GetDefaultTargetName()

   358

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

   359

        return target

   360

   361

    def GetParamsAttributes(self, path=None):

   362

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   363

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

   364

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

   365

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

   366

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

   367

        return params

   368

   369

    def SetParamsAttribute(self, path, value):

   370

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

   371

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

   372

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

   373

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

   374

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   375

        return res

   376

   377

    # helper func to check project path write permission

   378

    def CheckProjectPathPerm(self, dosave=True):

   379

        if CheckPathPerm(self.ProjectPath):

   380

            return True

   381

        if self.AppFrame is not None:

   382

            dialog = wx.MessageDialog(

   383

                self.AppFrame,

   384

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

   385

                _('Error'),

   386

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

   387

            answer = dialog.ShowModal()

   388

            dialog.Destroy()

   389

            if answer == wx.ID_YES:

   390

                if self.SaveProjectAs():

   391

                    self.AppFrame.RefreshTitle()

   392

                    self.AppFrame.RefreshFileMenu()

   393

                    self.AppFrame.RefreshPageTitles()

   394

                    return True

   395

        return False

   396

   397

    def _getProjectFilesPath(self, project_path=None):

   398

        if project_path is not None:

   399

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

   400

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

   401

        if not os.path.exists(projectfiles_path):

   402

            os.mkdir(projectfiles_path)

   403

        return projectfiles_path

   404

   405

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

   406

        self.ProjectAddConfiguration(config_name)

   407

        self.ProjectAddConfigurationResource(config_name, res_name)

   408

   409

    def SetProjectDefaultConfiguration(self):

   410

        # Sets default task and instance for new project

   411

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

   412

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

   413

        config = config.getname()

   414

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   415

        def_task = [

   416

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

   417

        def_instance = [

   418

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

   419

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   420

   421

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

   422

        """

   423

        Create a new project in an empty folder

   424

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

   425

        @param PLCParams: properties of the PLCOpen program created

   426

        """

   427

        # Verify that chosen folder is empty

   428

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

   429

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

   430

   431

        # Create PLCOpen program

   432

        self.CreateNewProject(

   433

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

   434

             "productName": _("Unnamed"),

   435

             "productVersion": "1",

   436

             "companyName": _("Unknown"),

   437

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

   438

        self.AddProjectDefaultConfiguration()

   439

   440

        # Change XSD into class members

   441

        self._AddParamsMembers()

   442

        self.Children = {}

   443

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

   444

        self.ProjectPath = ProjectPath

   445

        self._setBuildPath(BuildPath)

   446

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

   447

        self.RefreshConfNodesBlockLists()

   448

        # this will create files base XML files

   449

        self.SaveProject()

   450

        return None

   451

   452

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

   453

        """

   454

        Load a project contained in a folder

   455

        @param ProjectPath: path of the project folder

   456

        """

   457

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

   458

            ProjectPath = os.path.dirname(ProjectPath)

   459

        # Verify that project contains a PLCOpen program

   460

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

   461

        if not os.path.isfile(plc_file):

   462

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

   463

        # Load PLCOpen file

   464

        error = self.OpenXMLFile(plc_file)

   465

        if error is not None:

   466

            if self.Project is not None:

   467

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

   468

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

   469

            else:

   470

                return error, False

   471

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

   472

            self.AddProjectDefaultConfiguration()

   473

        # Change XSD into class members

   474

        self._AddParamsMembers()

   475

        self.Children = {}

   476

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

   477

        self.ProjectPath = ProjectPath

   478

        self._setBuildPath(BuildPath)

   479

        # If dir have already be made, and file exist

   480

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