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

   176

iec2c_cfg = Iec2CSettings()

   177

   178

   179

class ProjectController(ConfigTreeNode, PLCControler):

   180

    """

   181

    This class define Root object of the confnode tree.

   182

    It is responsible of :

   183

    - Managing project directory

   184

    - Building project

   185

    - Handling PLCOpenEditor controler and view

   186

    - Loading user confnodes and instanciante them as children

   187

    - ...

   188

   189

    """

   190

   191

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

   192

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   193

   194

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

   195

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

   196

      <xsd:element name="BeremizRoot">

   197

        <xsd:complexType>

   198

          <xsd:sequence>

   199

            <xsd:element name="TargetType">

   200

              <xsd:complexType>

   201

                <xsd:choice minOccurs="0">

   202

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

   203

                </xsd:choice>

   204

              </xsd:complexType>

   205

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

   206

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

   207

              <xsd:complexType>

   208

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

   209

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

   210

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

   211

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

   212

              </xsd:complexType>

   213

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

   214

          </xsd:sequence>

   215

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

   216

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

   217

        </xsd:complexType>

   218

      </xsd:element>

   219

    </xsd:schema>

   220

    """

   221

    EditorType = ProjectNodeEditor

   222

   223

    def __init__(self, frame, logger):

   224

        PLCControler.__init__(self)

   225

   226

        self.MandatoryParams = None

   227

        self._builder = None

   228

        self._connector = None

   229

        self.DispatchDebugValuesTimer = None

   230

        self.DebugValuesBuffers = []

   231

        self.DebugTicks = []

   232

        self.SetAppFrame(frame, logger)

   233

   234

        # Setup debug information

   235

        self.IECdebug_datas = {}

   236

        self.IECdebug_lock = Lock()

   237

   238

        self.DebugTimer = None

   239

        self.ResetIECProgramsAndVariables()

   240

   241

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

   242

        self.ChangesToSave = False

   243

        # root have no parent

   244

        self.CTNParent = None

   245

        # Keep track of the confnode type name

   246

        self.CTNType = "Beremiz"

   247

        self.Children = {}

   248

        self._View = None

   249

        # After __init__ root confnode is not valid

   250

        self.ProjectPath = None

   251

        self._setBuildPath(None)

   252

        self.DebugThread = None

   253

        self.debug_break = False

   254

        self.previous_plcstate = None

   255

        # copy ConfNodeMethods so that it can be later customized

   256

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

   257

   258

    def __del__(self):

   259

        if self.DebugTimer:

   260

            self.DebugTimer.cancel()

   261

        self.KillDebugThread()

   262

   263

    def LoadLibraries(self):

   264

        self.Libraries = []

   265

        TypeStack = []

   266

        for libname, clsname in features.libraries:

   267

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

   268

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

   269

                TypeStack.append(Lib.GetTypes())

   270

                self.Libraries.append(Lib)

   271

   272

    def SetAppFrame(self, frame, logger):

   273

        self.AppFrame = frame

   274

        self.logger = logger

   275

        self.StatusTimer = None

   276

        if self.DispatchDebugValuesTimer is not None:

   277

            self.DispatchDebugValuesTimer.Stop()

   278

        self.DispatchDebugValuesTimer = None

   279

   280

        if frame is not None:

   281

   282

            # Timer to pull PLC status

   283

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

   284

            self.AppFrame.Bind(wx.EVT_TIMER,

   285

                self.PullPLCStatusProc, self.StatusTimer)

   286

   287

            if self._connector is not None:

   288

                frame.LogViewer.SetLogSource(self._connector)

   289

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

   290

   291

            # Timer to dispatch debug values to consumers

   292

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

   293

            self.AppFrame.Bind(wx.EVT_TIMER,

   294

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   295

   296

            self.RefreshConfNodesBlockLists()

   297

   298

    def ResetAppFrame(self, logger):

   299

        if self.AppFrame is not None:

   300

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

   301

            self.StatusTimer = None

   302

            self.AppFrame = None

   303

   304

        self.logger = logger

   305

   306

    def CTNName(self):

   307

        return "Project"

   308

   309

    def CTNTestModified(self):

   311

   312

    def CTNFullName(self):

   313

        return ""

   314

   315

    def GetCTRoot(self):

   316

        return self

   317

   318

    def GetIECLibPath(self):

   319

        return iec2c_cfg.getLibCPath()

   320

   321

    def GetIEC2cPath(self):

   322

        return iec2c_cfg.getCmd()

   323

   324

    def GetCurrentLocation(self):

   325

        return ()

   326

   327

    def GetCurrentName(self):

   328

        return ""

   329

   330

    def _GetCurrentName(self):

   331

        return ""

   332

   333

    def GetProjectPath(self):

   334

        return self.ProjectPath

   335

   336

    def GetProjectName(self):

   337

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

   338

   339

    def GetIconName(self):

   340

        return "PROJECT"

   341

   342

    def GetDefaultTargetName(self):

   343

        if wx.Platform == '__WXMSW__':

   344

            return "Win32"

   345

        else:

   346

            return "Linux"

   347

   348

    def GetTarget(self):

   349

        target = self.BeremizRoot.getTargetType()

   350

        if target.getcontent() is None:

   351

            temp_root = self.Parser.CreateRoot()

   352

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

   353

            temp_root.setTargetType(target)

   354

            target_name = self.GetDefaultTargetName()

   355

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

   356

        return target

   357

   358

    def GetParamsAttributes(self, path=None):

   359

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   360

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

   361

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

   362

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

   363

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

   364

        return params

   365

   366

    def SetParamsAttribute(self, path, value):

   367

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

   368

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

   369

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

   370

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

   371

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   372

        return res

   373

   374

    # helper func to check project path write permission

   375

    def CheckProjectPathPerm(self, dosave=True):

   376

        if CheckPathPerm(self.ProjectPath):

   377

            return True

   378

        if self.AppFrame is not None:

   379

            dialog = wx.MessageDialog(self.AppFrame,

   380

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

   381

                        _('Error'),

   382

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

   383

            answer = dialog.ShowModal()

   384

            dialog.Destroy()

   385

            if answer == wx.ID_YES:

   386

                if self.SaveProjectAs():

   387

                    self.AppFrame.RefreshTitle()

   388

                    self.AppFrame.RefreshFileMenu()

   389

                    self.AppFrame.RefreshPageTitles()

   390

                    return True

   391

        return False

   392

   393

    def _getProjectFilesPath(self, project_path=None):

   394

        if project_path is not None:

   395

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

   396

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

   397

        if not os.path.exists(projectfiles_path):

   398

            os.mkdir(projectfiles_path)

   399

        return projectfiles_path

   400

   401

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

   402

        self.ProjectAddConfiguration(config_name)

   403

        self.ProjectAddConfigurationResource(config_name, res_name)

   404

   405

    def SetProjectDefaultConfiguration(self):

   406

        # Sets default task and instance for new project

   407

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

   408

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

   409

        config = config.getname()

   410

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   411

        def_task = [

   412

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

   413

        def_instance = [

   414

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

   415

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   416

   417

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

   418

        """

   419

        Create a new project in an empty folder

   420

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

   421

        @param PLCParams: properties of the PLCOpen program created

   422

        """

   423

        # Verify that chosen folder is empty

   424

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

   425

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

   426

   427

        # Create PLCOpen program

   428

        self.CreateNewProject(

   429

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

   430

             "productName": _("Unnamed"),

   431

             "productVersion": "1",

   432

             "companyName": _("Unknown"),

   433

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

   434

        self.AddProjectDefaultConfiguration()

   435

   436

        # Change XSD into class members

   437

        self._AddParamsMembers()

   438

        self.Children = {}

   439

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

   440

        self.ProjectPath = ProjectPath

   441

        self._setBuildPath(BuildPath)

   442

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

   443

        self.RefreshConfNodesBlockLists()

   444

        # this will create files base XML files

   445

        self.SaveProject()

   446

        return None

   447

   448

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

   449

        """

   450

        Load a project contained in a folder

   451

        @param ProjectPath: path of the project folder

   452

        """

   453

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

   454

            ProjectPath = os.path.dirname(ProjectPath)

   455

        # Verify that project contains a PLCOpen program

   456

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

   457

        if not os.path.isfile(plc_file):

   458

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

   459

        # Load PLCOpen file

   460

        error = self.OpenXMLFile(plc_file)

   461

        if error is not None:

   462

            if self.Project is not None:

   463

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

   464

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

   465

            else:

   466

                return error, False

   467

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

   468

            self.AddProjectDefaultConfiguration()

   469

        # Change XSD into class members

   470

        self._AddParamsMembers()

   471

        self.Children = {}

   472

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

   473

        self.ProjectPath = ProjectPath

   474

        self._setBuildPath(BuildPath)

   475

        # If dir have already be made, and file exist

   476

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

   477

            # Load the confnode.xml file into parameters members

   478

            result = self.LoadXMLParams()

   479

            if result:

   480

                return result, False