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

    30

import time

    31

import features

    32

import shutil

    33

import wx

    34

import re, tempfile

    35

from math import ceil

    36

from types import ListType

    37

from threading import Timer, Lock, Thread

    38

from time import localtime

    39

from datetime import datetime

    40

from weakref import WeakKeyDictionary

    41

from itertools import izip

    42

    43

import targets

    44

import connectors

    45

import util.paths as paths

    46

from util.misc import CheckPathPerm, GetClassImporter

    47

from util.MiniTextControler import MiniTextControler

    48

from util.ProcessLogger import ProcessLogger

    49

from util.BitmapLibrary import GetBitmap

    50

from editors.FileManagementPanel import FileManagementPanel

    51

from editors.ProjectNodeEditor import ProjectNodeEditor

    52

from editors.IECCodeViewer import IECCodeViewer

    53

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    54

from dialogs import DiscoveryDialog

    55

from PLCControler import PLCControler

    56

from plcopen.structures import IEC_KEYWORDS

    57

from targets.typemapping import DebugTypesSize, LogLevelsCount, LogLevels

    58

from targets.typemapping import UnpackDebugBuffer

    59

from ConfigTreeNode import ConfigTreeNode, XSDSchemaErrorMessage

    60

    61

base_folder = paths.AbsParentDir(__file__)

    62

    63

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

    64

    65

ITEM_CONFNODE = 25

    66

    67

def ExtractChildrenTypesFromCatalog(catalog):

    68

    children_types = []

    69

    for n,d,h,c in catalog:

    70

        if isinstance(c, ListType):

    71

            children_types.extend(ExtractChildrenTypesFromCatalog(c))

    72

        else:

    73

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

    74

    return children_types

    75

    76

def ExtractMenuItemsFromCatalog(catalog):

    77

    menu_items = []

    78

    for n,d,h,c in catalog:

    79

        if isinstance(c, ListType):

    80

            children = ExtractMenuItemsFromCatalog(c)

    81

        else:

    82

            children = []

    83

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

    84

    return menu_items

    85

    86

def GetAddMenuItems():

    87

    return ExtractMenuItemsFromCatalog(features.catalog)

    88

    89

class Iec2CSettings():

    90

    def __init__(self):

    91

        self.iec2c = None

    92

        self.iec2c_buildopts = None

    93

        self.ieclib_path   = self.findLibPath()

    94

        self.ieclib_c_path = self.findLibCPath()

    95

    96

    def findObject(self, paths, test):

    97

        path=None

    98

        for p in paths:

    99

            if test(p):

   100

                path = p

   102

        return path

   104

    def findCmd(self):

   105

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

   106

        paths=[

   107

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

   108

        ]

   109

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

   110

   111

        # otherwise use iec2c from PATH

   112

        if path is not None:

   113

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

   114

   115

        return cmd

   117

    def findLibPath(self):

   118

        paths=[

   119

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

   120

            "/usr/lib/matiec"

   121

        ]

   122

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

   123

        return path

   125

    def findLibCPath(self):

   126

        path=None

   127

        paths=[

   128

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

   129

            self.ieclib_path]

   130

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

   131

        return path

   132

   133

    def findSupportedOptions(self):

   134

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

   135

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

   136

   137

        buildopt = ""

   138

        try:

   139

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

   140

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

   141

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

   142

        except Exception,e:

   143

            return buildopt

   144

   145

        for opt in options:

   146

            if opt in result:

   147

                buildopt = buildopt + " " + opt

   148

        return buildopt

   149

   150

    def getCmd(self):

   151

        if self.iec2c is None:

   152

            self.iec2c = self.findCmd()

   153

        return self.iec2c

   154

   155

    def getOptions(self):

   156

        if self.iec2c_buildopts is None:

   157

            self.iec2c_buildopts = self.findSupportedOptions()

   158

        return self.iec2c_buildopts

   159

   160

    def getLibPath(self):

   161

        return self.ieclib_path

   162

   163

    def getLibCPath(self):

   164

        if self.ieclib_c_path is None:

   165

            self.ieclib_c_path = self.findLibCPath()

   166

        return self.ieclib_c_path

   167

   168

iec2c_cfg = Iec2CSettings()

   169

   170

class ProjectController(ConfigTreeNode, PLCControler):

   171

    """

   172

    This class define Root object of the confnode tree.

   173

    It is responsible of :

   174

    - Managing project directory

   175

    - Building project

   176

    - Handling PLCOpenEditor controler and view

   177

    - Loading user confnodes and instanciante them as children

   178

    - ...

   179

   180

    """

   181

   182

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

   183

    CTNChildrenTypes = ExtractChildrenTypesFromCatalog(features.catalog)

   184

   185

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

   186

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

   187

      <xsd:element name="BeremizRoot">

   188

        <xsd:complexType>

   189

          <xsd:sequence>

   190

            <xsd:element name="TargetType">

   191

              <xsd:complexType>

   192

                <xsd:choice minOccurs="0">

   193

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

   194

                </xsd:choice>

   195

              </xsd:complexType>

   196

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

   197

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

   198

              <xsd:complexType>

   199

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

   200

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

   201

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

   202

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

   203

              </xsd:complexType>

   204

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

   205

          </xsd:sequence>

   206

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

   207

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

   208

        </xsd:complexType>

   209

      </xsd:element>

   210

    </xsd:schema>

   211

    """

   212

    EditorType = ProjectNodeEditor

   213

   214

    def __init__(self, frame, logger):

   215

        PLCControler.__init__(self)

   216

   217

        self.MandatoryParams = None

   218

        self._builder = None

   219

        self._connector = None

   220

        self.DispatchDebugValuesTimer = None

   221

        self.DebugValuesBuffers = []

   222

        self.DebugTicks = []

   223

        self.SetAppFrame(frame, logger)

   224

   225

        # Setup debug information

   226

        self.IECdebug_datas = {}

   227

        self.IECdebug_lock = Lock()

   228

   229

        self.DebugTimer=None

   230

        self.ResetIECProgramsAndVariables()

   231

   232

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

   233

        self.ChangesToSave = False

   234

        # root have no parent

   235

        self.CTNParent = None

   236

        # Keep track of the confnode type name

   237

        self.CTNType = "Beremiz"

   238

        self.Children = {}

   239

        self._View = None

   240

        # After __init__ root confnode is not valid

   241

        self.ProjectPath = None

   242

        self._setBuildPath(None)

   243

        self.DebugThread = None

   244

        self.debug_break = False

   245

        self.previous_plcstate = None

   246

        # copy ConfNodeMethods so that it can be later customized

   247

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

   248

   249

    def __del__(self):

   250

        if self.DebugTimer:

   251

            self.DebugTimer.cancel()

   252

        self.KillDebugThread()

   253

   254

    def LoadLibraries(self):

   255

        self.Libraries = []

   256

        TypeStack=[]

   257

        for libname,clsname in features.libraries:

   258

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

   259

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

   260

                TypeStack.append(Lib.GetTypes())

   261

                self.Libraries.append(Lib)

   262

   263

    def SetAppFrame(self, frame, logger):

   264

        self.AppFrame = frame

   265

        self.logger = logger

   266

        self.StatusTimer = None

   267

        if self.DispatchDebugValuesTimer is not None:

   268

            self.DispatchDebugValuesTimer.Stop()

   269

        self.DispatchDebugValuesTimer = None

   270

   271

        if frame is not None:

   272

   273

            # Timer to pull PLC status

   274

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

   275

            self.AppFrame.Bind(wx.EVT_TIMER,

   276

                self.PullPLCStatusProc, self.StatusTimer)

   277

   278

            if self._connector is not None:

   279

                frame.LogViewer.SetLogSource(self._connector)

   280

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

   281

   282

            # Timer to dispatch debug values to consumers

   283

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

   284

            self.AppFrame.Bind(wx.EVT_TIMER,

   285

                self.DispatchDebugValuesProc, self.DispatchDebugValuesTimer)

   286

   287

            self.RefreshConfNodesBlockLists()

   288

   289

    def ResetAppFrame(self, logger):

   290

        if self.AppFrame is not None:

   291

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

   292

            self.StatusTimer = None

   293

            self.AppFrame = None

   294

   295

        self.logger = logger

   296

   297

    def CTNName(self):

   298

        return "Project"

   299

   300

    def CTNTestModified(self):

   301

         return self.ChangesToSave or not self.ProjectIsSaved()

   302

   303

    def CTNFullName(self):

   304

        return ""

   305

   306

    def GetCTRoot(self):

   307

        return self

   308

   309

    def GetIECLibPath(self):

   310

        return iec2c_cfg.getLibCPath()

   311

   312

    def GetIEC2cPath(self):

   313

        return iec2c_cfg.getCmd()

   314

   315

    def GetCurrentLocation(self):

   316

        return ()

   317

   318

    def GetCurrentName(self):

   319

        return ""

   320

   321

    def _GetCurrentName(self):

   322

        return ""

   323

   324

    def GetProjectPath(self):

   325

        return self.ProjectPath

   326

   327

    def GetProjectName(self):

   328

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

   329

   330

    def GetIconName(self):

   331

        return "PROJECT"

   332

   333

    def GetDefaultTargetName(self):

   334

        if wx.Platform == '__WXMSW__':

   335

            return "Win32"

   336

        else:

   337

            return "Linux"

   338

   339

    def GetTarget(self):

   340

        target = self.BeremizRoot.getTargetType()

   341

        if target.getcontent() is None:

   342

            temp_root = self.Parser.CreateRoot()

   343

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

   344

            temp_root.setTargetType(target)

   345

            target_name = self.GetDefaultTargetName()

   346

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

   347

        return target

   348

   349

    def GetParamsAttributes(self, path = None):

   350

        params = ConfigTreeNode.GetParamsAttributes(self, path)

   351

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

   352

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

   353

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

   354

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

   355

        return params

   356

   357

    def SetParamsAttribute(self, path, value):

   358

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

   359

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

   360

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

   361

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

   362

            wx.CallAfter(self.RefreshConfNodesBlockLists)

   363

        return res

   364

   365

    # helper func to check project path write permission

   366

    def CheckProjectPathPerm(self, dosave=True):

   367

        if CheckPathPerm(self.ProjectPath):

   368

            return True

   369

        if self.AppFrame is not None:

   370

            dialog = wx.MessageDialog(self.AppFrame,

   371

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

   372

                        _('Error'),

   373

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

   374

            answer = dialog.ShowModal()

   375

            dialog.Destroy()

   376

            if answer == wx.ID_YES:

   377

                if self.SaveProjectAs():

   378

                    self.AppFrame.RefreshTitle()

   379

                    self.AppFrame.RefreshFileMenu()

   380

                    self.AppFrame.RefreshPageTitles()

   381

                    return True

   382

        return False

   383

   384

    def _getProjectFilesPath(self, project_path=None):

   385

        if project_path is not None:

   386

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

   387

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

   388

        if not os.path.exists(projectfiles_path):

   389

            os.mkdir(projectfiles_path)

   390

        return projectfiles_path

   391

   392

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

   393

        self.ProjectAddConfiguration(config_name)

   394

        self.ProjectAddConfigurationResource(config_name, res_name)

   395

   396

    def SetProjectDefaultConfiguration(self):

   397

        # Sets default task and instance for new project

   398

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

   399

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

   400

        config = config.getname()

   401

        resource_tagname = self.ComputeConfigurationResourceName(config, resource)

   402

        def_task = [

   403

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

   404

        def_instance = [

   405

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

   406

        self.SetEditedResourceInfos(resource_tagname, def_task, def_instance)

   407

   408

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

   409

        """

   410

        Create a new project in an empty folder

   411

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

   412

        @param PLCParams: properties of the PLCOpen program created

   413

        """

   414

        # Verify that chosen folder is empty

   415

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

   416

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

   417

   418

        # Create PLCOpen program

   419

        self.CreateNewProject(

   420

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

   421

             "productName": _("Unnamed"),

   422

             "productVersion": "1",

   423

             "companyName": _("Unknown"),

   424

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

   425

        self.AddProjectDefaultConfiguration()

   426

   427

        # Change XSD into class members

   428

        self._AddParamsMembers()

   429

        self.Children = {}

   430

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

   431

        self.ProjectPath = ProjectPath

   432

        self._setBuildPath(BuildPath)

   433

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

   434

        self.RefreshConfNodesBlockLists()

   435

        # this will create files base XML files

   436

        self.SaveProject()

   437

        return None

   438

   439

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

   440

        """

   441

        Load a project contained in a folder

   442

        @param ProjectPath: path of the project folder

   443

        """

   444

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

   445

            ProjectPath = os.path.dirname(ProjectPath)

   446

        # Verify that project contains a PLCOpen program

   447

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

   448

        if not os.path.isfile(plc_file):

   449

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

   450

        # Load PLCOpen file

   451

        error = self.OpenXMLFile(plc_file)

   452

        if error is not None:

   453

            if self.Project is not None:

   454

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

   455

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

   456

            else:

   457

                return error, False

   458

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

   459

            self.AddProjectDefaultConfiguration()

   460

        # Change XSD into class members

   461

        self._AddParamsMembers()

   462

        self.Children = {}

   463

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

   464

        self.ProjectPath = ProjectPath

   465

        self._setBuildPath(BuildPath)

   466

        # If dir have already be made, and file exist

   467

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

   468

            #Load the confnode.xml file into parameters members

   469

            result = self.LoadXMLParams()

   470

            if result:

   471

                return result, False

   472

            #Load and init all the children

   473

            self.LoadChildren()

   474

        self.RefreshConfNodesBlockLists()

   475

        self.UpdateButtons()

   476

        return None, False

   477

   478

    def RecursiveConfNodeInfos(self, confnode):

   479

        values = []

   480

        for CTNChild in confnode.IECSortedChildren():

   481

            values.append(

   482

                {"name": "%s: %s" % (CTNChild.GetFullIEC_Channel(),